@lota-sdk/core 0.4.8 → 0.4.10

package/src/db/memory-store.ts

@@ -1,9 +1,10 @@
+import type { Context } from 'effect'
+import { Schema, Duration, Effect, Metric, Schedule } from 'effect'
 import { BoundQuery, eq, inside } from 'surrealdb'
 
 import { aiLogger } from '../config/logger'
-import { DEFAULT_MEMORY_SEARCH_LIMIT } from '../config/search'
-import { getDefaultEmbeddings } from '../embeddings/provider'
-import { withTimeout } from '../utils/async'
+import { ProviderEmbeddings } from '../embeddings/provider'
+import type { BackgroundWorkService } from '../services/background-work.service'
 import { clampImportance, truncateText } from '../utils/string'
 import { memoryQueryBuilder } from './memory-query-builder'
 import type { RelationCounts } from './memory-store.helpers'
@@ -19,38 +20,84 @@ import type {
 } from './memory-types'
 import { ensureRecordId, recordIdToString } from './record-id'
 import type { RecordIdInput, RecordIdRef } from './record-id'
-import { databaseService } from './service'
+import type { SurrealDBService } from './service'
+import type { SurrealDBError } from './service-normalization'
 import { TABLES } from './tables'
+import { isRetriableTransactionConflict } from './transaction-conflict'
+
+type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkService>
 
 const MEMORY_TABLE = TABLES.MEMORY
 const MEMORY_HISTORY_TABLE = TABLES.MEMORY_HISTORY
 const MEMORY_RELATION_TABLE = TABLES.MEMORY_RELATION
+const DEFAULT_MEMORY_SEARCH_LIMIT = 10
 const MIN_RELEVANCE_SCORE = 0.25
 const STRONG_GRAPH_BOOSTS = { support: 0.1, contradict: 0.2 } as const
 const WEAK_GRAPH_BOOSTS = { support: 0.05, contradict: 0.1 } as const
 const CANDIDATE_FANOUT_MULTIPLIER = 4
 const CANDIDATE_SLICE_FLOOR = 50
-const TOUCH_MEMORIES_MAX_ATTEMPTS = 4
-const TOUCH_MEMORIES_RETRY_BASE_DELAY_MS = 25
-const TOUCH_MEMORIES_RETRY_JITTER_MS = 20
+const memorySearchDuration = Metric.histogram('memory_search_duration_ms', {
+  boundaries: Metric.boundariesFromIterable([10, 50, 100, 250, 500, 1000, 2000]),
+})
+const TOUCH_MEMORIES_RETRY_OPTIONS = {
+  times: 3,
+  schedule: Schedule.jittered(Schedule.exponential(Duration.millis(25), 2)),
+  while: (error: unknown) => isRetriableTransactionConflict(error),
+} as const
+
+class MemoryStoreError extends Schema.TaggedErrorClass<MemoryStoreError>()('MemoryStoreError', {
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function tryMemoryStorePromise<A, E, R = never>(
+  message: string,
+  thunk: () => PromiseLike<A> | Effect.Effect<A, E, R>,
+): Effect.Effect<A, MemoryStoreError, R> {
+  return Effect.suspend(() => {
+    try {
+      const value = thunk()
+      if (Effect.isEffect(value)) {
+        return value.pipe(Effect.mapError((cause) => new MemoryStoreError({ message, cause })))
+      }
+
+      return Effect.tryPromise({ try: () => value, catch: (cause) => new MemoryStoreError({ message, cause }) })
+    } catch (cause) {
+      return Effect.fail(new MemoryStoreError({ message, cause }))
+    }
+  })
+}
 
 interface EmbeddingClient {
   embedQuery(text: string): Promise<number[]>
 }
 
 export class SurrealMemoryStore {
-  constructor(private embeddings: EmbeddingClient) {}
+  private db: SurrealDBService
+  private embeddings: EmbeddingClient
+  private background: BackgroundWorker
+  constructor(db: SurrealDBService, embeddings: EmbeddingClient, background: BackgroundWorker) {
+    this.db = db
+    this.embeddings = embeddings
+    this.background = background
+  }
 
-  private toMetadataFieldPath(key: string): string {
+  private recordMemorySearchDuration(elapsed: number): Effect.Effect<void> {
+    return this.background.runForget(Metric.update(memorySearchDuration, elapsed), 'memory-store.recordSearchDuration')
+  }
+
+  private toMetadataFieldPathEffect(key: string): Effect.Effect<string, MemoryStoreError> {
     const segments = key.split('.').map((segment) => segment.trim())
     if (
       segments.length === 0 ||
       segments.some((segment) => segment.length === 0 || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(segment))
     ) {
-      throw new Error(`Invalid memory metadata filter key: ${key}`)
+      return Effect.fail(
+        new MemoryStoreError({ message: `Invalid memory metadata filter key: ${key}`, cause: undefined }),
+      )
     }
 
-    return `metadata.${segments.join('.')}`
+    return Effect.succeed(`metadata.${segments.join('.')}`)
   }
 
   private tokenizeQuery(query: string): string[] {
@@ -79,11 +126,11 @@ export class SurrealMemoryStore {
     return score
   }
 
-  private async listRecentBasic(options: {
+  private listRecentBasic(options: {
     scopeId: string
     limit: number
     memoryType?: MemoryRecord['memoryType']
-  }): Promise<BasicSearchRow[]> {
+  }): Effect.Effect<BasicSearchRow[], SurrealDBError, never> {
     const typeFilter = options.memoryType ? 'AND memoryType = $memoryType' : ''
     const sql = `
       SELECT id, content, metadata, createdAt
@@ -94,18 +141,18 @@ export class SurrealMemoryStore {
       LIMIT $limit
     `
 
-    return databaseService.query<BasicSearchRow>(
+    return this.db.query<BasicSearchRow>(
       new BoundQuery(sql, { scopeId: options.scopeId, memoryType: options.memoryType, limit: options.limit }),
     )
   }
 
-  async listTopMemories(options: {
+  private listTopMemoriesEffect(options: {
     scopeId: string
     limit: number
     memoryType?: MemoryRecord['memoryType']
     durability?: MemoryRecord['durability']
     minImportance?: number
-  }): Promise<MemoryRecord[]> {
+  }): Effect.Effect<MemoryRecord[], MemoryStoreError, never> {
     const typeFilter = options.memoryType ? 'AND memoryType = $memoryType' : ''
     const durabilityFilter = options.durability ? 'AND durability = $durability' : ''
     const importanceFilter = typeof options.minImportance === 'number' ? 'AND importance >= $minImportance' : ''
@@ -118,26 +165,36 @@ export class SurrealMemoryStore {
       LIMIT $limit
     `
 
-    const rows = await databaseService.query<SurrealMemoryRow>(
-      new BoundQuery(sql, {
-        scopeId: options.scopeId,
-        memoryType: options.memoryType,
-        durability: options.durability,
-        minImportance: options.minImportance,
-        limit: options.limit,
-      }),
-    )
+    return tryMemoryStorePromise('Failed to list top memories.', () =>
+      this.db.query<SurrealMemoryRow>(
+        new BoundQuery(sql, {
+          scopeId: options.scopeId,
+          memoryType: options.memoryType,
+          durability: options.durability,
+          minImportance: options.minImportance,
+          limit: options.limit,
+        }),
+      ),
+    ).pipe(Effect.map((rows) => rows.map((row: SurrealMemoryRow) => mapRowToMemoryRecord(row))))
+  }
 
-    return rows.map((row) => mapRowToMemoryRecord(row))
+  listTopMemories(options: {
+    scopeId: string
+    limit: number
+    memoryType?: MemoryRecord['memoryType']
+    durability?: MemoryRecord['durability']
+    minImportance?: number
+  }): Effect.Effect<MemoryRecord[], MemoryStoreError, never> {
+    return this.listTopMemoriesEffect(options)
   }
 
-  private async vectorSearchWithEmbedding(options: {
+  private vectorSearchWithEmbeddingEffect(options: {
     embedding: number[]
     scopeId: string
     limit: number
     memoryType?: MemoryRecord['memoryType']
     fastMode?: boolean
-  }): Promise<MemorySearchResult[]> {
+  }): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
     const { sql, bindVars } = memoryQueryBuilder.buildVectorSearch({
       embedding: options.embedding,
       scopeId: options.scopeId,
@@ -145,26 +202,28 @@ export class SurrealMemoryStore {
       memoryType: options.memoryType,
     })
 
-    const results = await this.queryFinalStatement<BasicSearchRow & { distance: number }>(sql, bindVars)
-    if (results.length === 0) return []
-    if (options.fastMode) {
-      return this.mapFastRows(results, options.limit, (row) => 1 / (1 + row.distance))
-    }
-
-    const memoryIds = results.map((row) => row.id)
-    const relationCounts = await this.fetchRelationCountsBatch(memoryIds)
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        const results = yield* this.queryFinalStatementEffect<BasicSearchRow & { distance: number }>(sql, bindVars)
+        if (results.length === 0) return []
+        if (options.fastMode) {
+          return this.mapFastRows(results, options.limit, (row) => 1 / (1 + row.distance))
+        }
 
-    const processed = processGraphAwareRows(
-      results,
-      relationCounts,
-      options.limit,
-      (row) => 1 / (1 + row.distance),
-      STRONG_GRAPH_BOOSTS,
-      MIN_RELEVANCE_SCORE,
+        const relationCounts = yield* this.fetchRelationCountsBatchEffect(results.map((row) => row.id))
+        const processed = processGraphAwareRows(
+          results,
+          relationCounts,
+          options.limit,
+          (row) => 1 / (1 + row.distance),
+          STRONG_GRAPH_BOOSTS,
+          MIN_RELEVANCE_SCORE,
+        )
+
+        yield* this.touchMemories(processed.map((row) => row.id))
+        return processed
+      }.bind(this),
     )
-
-    this.touchMemories(processed.map((row) => row.id))
-    return processed
   }
 
   private mapFastRows<T extends BasicSearchRow>(
@@ -182,20 +241,22 @@ export class SurrealMemoryStore {
       }))
   }
 
-  private async generateEmbedding(content: string): Promise<number[]> {
+  private generateEmbeddingEffect(content: string): Effect.Effect<number[], MemoryStoreError, never> {
     const normalized = content.trim()
-    if (!normalized) return []
+    if (!normalized) return Effect.succeed([])
 
-    return this.embeddings.embedQuery(normalized)
+    return tryMemoryStorePromise('Failed to generate memory embedding.', () => this.embeddings.embedQuery(normalized))
   }
 
-  async warmEmbedding(content: string): Promise<void> {
-    await this.generateEmbedding(content)
+  warmEmbedding(content: string): Effect.Effect<void, MemoryStoreError, never> {
+    return Effect.asVoid(this.generateEmbeddingEffect(content))
   }
 
-  private async fetchRelationCountsBatch(memoryIds: RecordIdInput[]): Promise<Map<string, RelationCounts>> {
+  private fetchRelationCountsBatchEffect(
+    memoryIds: RecordIdInput[],
+  ): Effect.Effect<Map<string, RelationCounts>, MemoryStoreError, never> {
     if (memoryIds.length === 0) {
-      return new Map()
+      return Effect.succeed(new Map<string, RelationCounts>())
     }
 
     const memoryRefs = memoryIds.map((id) => ensureRecordId(id, TABLES.MEMORY))
@@ -211,31 +272,37 @@ export class SurrealMemoryStore {
       WHERE id IN $memoryIds
     `
 
-    const results = await databaseService.query<{
-      id: RecordIdInput
-      supersedeCount: number
-      contradictCount: number
-      supportCount: number
-      contradictionTexts: string[] | null
-    }>(new BoundQuery(sql, { memoryIds: memoryRefs }))
-
-    const countsMap = new Map<string, RelationCounts>()
-    for (const row of results) {
-      const rawTexts = row.contradictionTexts ?? []
-      const contradictions = rawTexts.filter((text): text is string => typeof text === 'string' && text.length > 0)
-      countsMap.set(recordIdToString(row.id, TABLES.MEMORY), {
-        supersedeCount: row.supersedeCount,
-        contradictCount: row.contradictCount,
-        supportCount: row.supportCount,
-        contradictions,
-      })
-    }
+    return tryMemoryStorePromise('Failed to fetch relation counts.', () =>
+      this.db.query<{
+        id: RecordIdInput
+        supersedeCount: number
+        contradictCount: number
+        supportCount: number
+        contradictionTexts: string[] | null
+      }>(new BoundQuery(sql, { memoryIds: memoryRefs })),
+    ).pipe(
+      Effect.map((results) => {
+        const countsMap = new Map<string, RelationCounts>()
+        for (const row of results) {
+          const rawTexts = row.contradictionTexts ?? []
+          const contradictions = rawTexts.filter(
+            (text: string | null): text is string => typeof text === 'string' && text.length > 0,
+          )
+          countsMap.set(recordIdToString(row.id, TABLES.MEMORY), {
+            supersedeCount: row.supersedeCount,
+            contradictCount: row.contradictCount,
+            supportCount: row.supportCount,
+            contradictions,
+          })
+        }
 
-    return countsMap
+        return countsMap
+      }),
+    )
   }
 
-  private touchMemories(memoryIds: string[]): void {
-    if (memoryIds.length === 0) return
+  private touchMemories(memoryIds: string[]): Effect.Effect<void> {
+    if (memoryIds.length === 0) return Effect.void
     const uniqueIds = [...new Set(memoryIds)]
     const memoryRefs = uniqueIds.map((id) => ensureRecordId(id, TABLES.MEMORY))
     const sql = `
@@ -245,43 +312,36 @@ export class SurrealMemoryStore {
     `
     const query = new BoundQuery(sql, { memoryIds: memoryRefs })
 
-    void this.runTouchMemoriesWithRetry(query)
-  }
-
-  private async runTouchMemoriesWithRetry(query: BoundQuery): Promise<void> {
-    for (let attempt = 1; attempt <= TOUCH_MEMORIES_MAX_ATTEMPTS; attempt += 1) {
-      try {
-        await databaseService.query(query)
-        return
-      } catch (error) {
-        const retriable = this.isRetriableTransactionConflict(error)
-        const hasMoreAttempts = attempt < TOUCH_MEMORIES_MAX_ATTEMPTS
-        if (!retriable || !hasMoreAttempts) {
-          aiLogger.warn`Failed to update memory access counters after ${attempt} attempt(s): ${error}`
-          return
-        }
-
-        const backoffMs =
-          TOUCH_MEMORIES_RETRY_BASE_DELAY_MS * 2 ** (attempt - 1) +
-          Math.floor(Math.random() * TOUCH_MEMORIES_RETRY_JITTER_MS)
-        await Bun.sleep(backoffMs)
-      }
-    }
+    return this.background.runForget(this.runTouchMemoriesWithRetry(query), 'memory-store.touchMemories')
   }
 
-  private isRetriableTransactionConflict(error: unknown): boolean {
-    if (!(error instanceof Error)) return false
-    const message = error.message.toLowerCase()
-    return message.includes('transaction conflict') || message.includes('this transaction can be retried')
+  private runTouchMemoriesWithRetry(query: BoundQuery): Effect.Effect<void, never, never> {
+    return this.db.query(query).pipe(
+      Effect.retry(TOUCH_MEMORIES_RETRY_OPTIONS),
+      Effect.catch((error) =>
+        Effect.sync(() => {
+          aiLogger.warn`Failed to update memory access counters: ${error}`
+        }),
+      ),
+      Effect.asVoid,
+    )
   }
 
-  private async queryFinalStatement<T>(sql: string, bindVars: Record<string, unknown>): Promise<T[]> {
-    const statements = await databaseService.queryAll<unknown>(new BoundQuery(sql, bindVars))
-    const finalStatement = statements.at(-1)
-    return Array.isArray(finalStatement) ? (finalStatement as T[]) : []
+  private queryFinalStatementEffect<T>(
+    sql: string,
+    bindVars: Record<string, unknown>,
+  ): Effect.Effect<T[], MemoryStoreError, never> {
+    return tryMemoryStorePromise('Failed to query memory statements.', () =>
+      this.db.queryAll<unknown>(new BoundQuery(sql, bindVars)),
+    ).pipe(
+      Effect.map((statements) => {
+        const finalStatement = statements.at(-1)
+        return Array.isArray(finalStatement) ? (finalStatement as T[]) : []
+      }),
+    )
   }
 
-  private async fallbackWeightedSearch(
+  private fallbackWeightedSearchEffect(
     query: string,
     tokens: string[],
     options: {
@@ -292,123 +352,143 @@ export class SurrealMemoryStore {
       reason: string
       fastMode?: boolean
     },
-  ): Promise<MemorySearchResult[]> {
-    aiLogger.debug`Weighted hybrid search fallback to vector/recent (scopeId: ${options.scopeId}, reason: ${options.reason})`
-    const vectorResults = await this.vectorSearchWithEmbedding({
-      embedding: options.embedding,
-      scopeId: options.scopeId,
-      limit: options.limit,
-      memoryType: options.memoryType,
-      fastMode: options.fastMode,
-    })
-
-    if (vectorResults.length > 0) {
-      return vectorResults
-    }
-
-    const recentLimit = Math.max(50, options.limit * 10)
-    const recent = await this.listRecentBasic({
-      scopeId: options.scopeId,
-      limit: recentLimit,
-      memoryType: options.memoryType,
-    })
-
-    if (recent.length === 0) {
-      return []
-    }
-
-    const scoredRows = recent
-      .map((row, index) => ({ ...row, index, textScore: this.scoreTextMatch(row.content, tokens, query) }))
-      .sort((a, b) => {
-        if (b.textScore !== a.textScore) return b.textScore - a.textScore
-        return a.index - b.index
-      })
-      .slice(0, Math.max(options.limit * CANDIDATE_FANOUT_MULTIPLIER, CANDIDATE_SLICE_FLOOR))
-
-    if (options.fastMode) {
-      return this.mapFastRows(scoredRows, options.limit, (row) => row.textScore)
-    }
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        aiLogger.debug`Weighted hybrid search fallback to vector/recent (scopeId: ${options.scopeId}, reason: ${options.reason})`
+        const vectorResults = yield* this.vectorSearchWithEmbeddingEffect({
+          embedding: options.embedding,
+          scopeId: options.scopeId,
+          limit: options.limit,
+          memoryType: options.memoryType,
+          fastMode: options.fastMode,
+        })
+        if (vectorResults.length > 0) return vectorResults
+
+        const recentLimit = Math.max(50, options.limit * 10)
+        const recent = yield* tryMemoryStorePromise('Failed to list recent memories.', () =>
+          this.listRecentBasic({ scopeId: options.scopeId, limit: recentLimit, memoryType: options.memoryType }),
+        )
+        if (recent.length === 0) return []
+
+        const scoredRows = recent
+          .map((row, index) => ({ ...row, index, textScore: this.scoreTextMatch(row.content, tokens, query) }))
+          .sort((a, b) => {
+            if (b.textScore !== a.textScore) return b.textScore - a.textScore
+            return a.index - b.index
+          })
+          .slice(0, Math.max(options.limit * CANDIDATE_FANOUT_MULTIPLIER, CANDIDATE_SLICE_FLOOR))
+
+        if (options.fastMode) {
+          return this.mapFastRows(scoredRows, options.limit, (row) => row.textScore)
+        }
 
-    const recentIds = scoredRows.map((row) => row.id)
-    const recentRelationCounts = await this.fetchRelationCountsBatch(recentIds)
-    const processed = processGraphAwareRows(
-      scoredRows,
-      recentRelationCounts,
-      options.limit,
-      (row) => row.textScore,
-      WEAK_GRAPH_BOOSTS,
-      MIN_RELEVANCE_SCORE,
+        const recentRelationCounts = yield* this.fetchRelationCountsBatchEffect(scoredRows.map((row) => row.id))
+        const processed = processGraphAwareRows(
+          scoredRows,
+          recentRelationCounts,
+          options.limit,
+          (row) => row.textScore,
+          WEAK_GRAPH_BOOSTS,
+          MIN_RELEVANCE_SCORE,
+        )
+
+        yield* this.touchMemories(processed.map((row) => row.id))
+        return processed
+      }.bind(this),
     )
-
-    this.touchMemories(processed.map((row) => row.id))
-    return processed
   }
 
   private static WRITE_DEDUP_THRESHOLD = 0.9
 
-  async insert(
+  private insertEffect(
     content: string,
     scopeId: string,
     memoryType: MemoryRecord['memoryType'],
     metadata: Record<string, unknown> = {},
     importance: number = 1,
     durability: MemoryRecord['durability'] = 'standard',
-  ): Promise<string> {
+  ): Effect.Effect<string, MemoryStoreError, never> {
     const hash = hashContent(content, scopeId, memoryType)
-    const embedding = await this.generateEmbedding(content)
-
-    importance = clampImportance(importance)
-
-    const nearDup = await this.findNearDuplicate(embedding, scopeId, content)
-    if (nearDup) {
-      const mergedImportance = clampImportance(Math.max(nearDup.importance, importance))
-      const keepNew = content.length >= nearDup.content.length
-      const winnerContent = keepNew ? content : nearDup.content
-      await this.update(nearDup.id, winnerContent, { importance: mergedImportance })
-      aiLogger.debug`Write-time dedup: merged into existing memory ${nearDup.id} (similarity: ${nearDup.similarity.toFixed(3)})`
-      return nearDup.id
-    }
-
-    const result = await databaseService.insert<{ id: RecordIdInput }>(MEMORY_TABLE, {
-      content,
-      embedding,
-      hash,
-      scopeId,
-      memoryType,
-      metadata,
-      importance,
-      durability,
-    })
-
-    const id = result[0]?.id ? recordIdToString(result[0].id, TABLES.MEMORY) : ''
+    const normalizedImportance = clampImportance(importance)
+
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        const embedding = yield* this.generateEmbeddingEffect(content)
+        const nearDup = yield* this.findNearDuplicateEffect(embedding, scopeId, content)
+        if (nearDup) {
+          const mergedImportance = clampImportance(Math.max(nearDup.importance, normalizedImportance))
+          const keepNew = content.length >= nearDup.content.length
+          const winnerContent = keepNew ? content : nearDup.content
+          yield* this.updateEffect(nearDup.id, winnerContent, { importance: mergedImportance })
+          aiLogger.debug`Write-time dedup: merged into existing memory ${nearDup.id} (similarity: ${nearDup.similarity.toFixed(3)})`
+          return nearDup.id
+        }
 
-    await this.recordHistory(id, null, content, 'ADD')
+        const result = yield* tryMemoryStorePromise('Failed to insert memory.', () =>
+          this.db.insert<{ id: RecordIdInput }>(MEMORY_TABLE, {
+            content,
+            embedding,
+            hash,
+            scopeId,
+            memoryType,
+            metadata,
+            importance: normalizedImportance,
+            durability,
+          }),
+        )
+        const id = result[0]?.id ? recordIdToString(result[0].id, TABLES.MEMORY) : ''
+        yield* this.recordHistoryEffect(id, null, content, 'ADD')
+        return id
+      }.bind(this),
+    )
+  }
 
-    return id
+  insert(
+    content: string,
+    scopeId: string,
+    memoryType: MemoryRecord['memoryType'],
+    metadata: Record<string, unknown> = {},
+    importance: number = 1,
+    durability: MemoryRecord['durability'] = 'standard',
+  ): Effect.Effect<string, MemoryStoreError, never> {
+    return this.insertEffect(content, scopeId, memoryType, metadata, importance, durability)
   }
 
-  async getByHash(hash: string): Promise<MemoryRecord | null> {
-    const rows = await databaseService.query<SurrealMemoryRow>(
-      new BoundQuery(
-        `
-          SELECT *
-          FROM ${MEMORY_TABLE}
-          WHERE hash = $hash
-          LIMIT 1
-        `,
-        { hash },
+  private getByHashEffect(hash: string): Effect.Effect<MemoryRecord | null, MemoryStoreError, never> {
+    return tryMemoryStorePromise('Failed to query memory by hash.', () =>
+      this.db.query<SurrealMemoryRow>(
+        new BoundQuery(
+          `
+            SELECT *
+            FROM ${MEMORY_TABLE}
+            WHERE hash = $hash
+            LIMIT 1
+          `,
+          { hash },
+        ),
       ),
+    ).pipe(
+      Effect.map((rows) => {
+        const row = rows.at(0)
+        return row ? mapRowToMemoryRecord(row) : null
+      }),
     )
+  }
 
-    const row = rows.at(0)
-    return row ? mapRowToMemoryRecord(row) : null
+  getByHash(hash: string): Effect.Effect<MemoryRecord | null, MemoryStoreError, never> {
+    return this.getByHashEffect(hash)
   }
 
-  private async findNearDuplicate(
+  private findNearDuplicateEffect(
     embedding: number[],
     scopeId: string,
     content: string,
-  ): Promise<{ id: string; content: string; importance: number; similarity: number } | null> {
+  ): Effect.Effect<
+    { id: string; content: string; importance: number; similarity: number } | null,
+    MemoryStoreError,
+    never
+  > {
     const candidateLimit = 12
     const sql = `
       LET $candidateRows = (
@@ -434,109 +514,130 @@ export class SurrealMemoryStore {
       LIMIT ${candidateLimit}
     `
 
-    const neighborRows = await this.queryFinalStatement<{
+    return this.queryFinalStatementEffect<{
       id: RecordIdInput
       content: string
       importance: number
       similarity: number
-    }>(sql, { scopeId, embedding })
-    const neighbors = neighborRows.map((row) => ({ ...row, id: recordIdToString(row.id, TABLES.MEMORY) }))
-
-    for (const neighbor of neighbors) {
-      if (neighbor.similarity < SurrealMemoryStore.WRITE_DEDUP_THRESHOLD) break
-      const [shorter, longer] =
-        content.length <= neighbor.content.length ? [content, neighbor.content] : [neighbor.content, content]
-      const a = shorter.toLowerCase().trim()
-      const b = longer.toLowerCase().trim()
-      if (b.includes(a)) return neighbor
-      const aWords = new Set(a.split(/\s+/))
-      const bWords = new Set(b.split(/\s+/))
-      let overlap = 0
-      for (const word of aWords) {
-        if (bWords.has(word)) overlap++
-      }
-      if (aWords.size > 0 && overlap / aWords.size >= 0.8) return neighbor
-    }
+    }>(sql, { scopeId, embedding }).pipe(
+      Effect.map((neighborRows) => {
+        const neighbors = neighborRows.map((row) => ({ ...row, id: recordIdToString(row.id, TABLES.MEMORY) }))
+
+        for (const neighbor of neighbors) {
+          if (neighbor.similarity < SurrealMemoryStore.WRITE_DEDUP_THRESHOLD) break
+          const [shorter, longer] =
+            content.length <= neighbor.content.length ? [content, neighbor.content] : [neighbor.content, content]
+          const a = shorter.toLowerCase().trim()
+          const b = longer.toLowerCase().trim()
+          if (b.includes(a)) return neighbor
+          const aWords = new Set(a.split(/\s+/))
+          const bWords = new Set(b.split(/\s+/))
+          let overlap = 0
+          for (const word of aWords) {
+            if (bWords.has(word)) overlap++
+          }
+          if (aWords.size > 0 && overlap / aWords.size >= 0.8) return neighbor
+        }
 
-    return null
+        return null
+      }),
+    )
   }
 
-  async search(
+  private searchEffect(
     query: string,
     scopeId: string,
     limit: number = DEFAULT_MEMORY_SEARCH_LIMIT,
     memoryType?: MemoryRecord['memoryType'],
-  ): Promise<MemorySearchResult[]> {
-    aiLogger.debug`Memory store search (scopeId: ${scopeId}, memoryType: ${memoryType}, limit: ${limit})`
-    const queryEmbedding = await this.generateEmbedding(query)
-
-    const { sql, bindVars } = memoryQueryBuilder.buildVectorSearch({
-      embedding: queryEmbedding,
-      scopeId,
-      limit,
-      memoryType,
-    })
-
-    const results = await this.queryFinalStatement<BasicSearchRow & { distance: number }>(sql, bindVars)
-
-    aiLogger.debug`Memory store search raw results: ${results.length} rows found`
-
-    const memoryIds = results.map((row) => row.id)
-    const relationCounts = await this.fetchRelationCountsBatch(memoryIds)
-
-    const processed = processGraphAwareRows(
-      results,
-      relationCounts,
-      limit,
-      (row) => 1 / (1 + row.distance),
-      STRONG_GRAPH_BOOSTS,
-      MIN_RELEVANCE_SCORE,
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        aiLogger.debug`Memory store search (scopeId: ${scopeId}, memoryType: ${memoryType}, limit: ${limit})`
+        const queryEmbedding = yield* this.generateEmbeddingEffect(query)
+        const { sql, bindVars } = memoryQueryBuilder.buildVectorSearch({
+          embedding: queryEmbedding,
+          scopeId,
+          limit,
+          memoryType,
+        })
+
+        const results = yield* this.queryFinalStatementEffect<BasicSearchRow & { distance: number }>(sql, bindVars)
+        aiLogger.debug`Memory store search raw results: ${results.length} rows found`
+
+        const relationCounts = yield* this.fetchRelationCountsBatchEffect(results.map((row) => row.id))
+        const processed = processGraphAwareRows(
+          results,
+          relationCounts,
+          limit,
+          (row) => 1 / (1 + row.distance),
+          STRONG_GRAPH_BOOSTS,
+          MIN_RELEVANCE_SCORE,
+        )
+
+        aiLogger.debug`Memory store search final results: ${processed.length} memories after filtering`
+        yield* this.touchMemories(processed.map((row) => row.id))
+        return processed
+      }.bind(this),
     )
-
-    aiLogger.debug`Memory store search final results: ${processed.length} memories after filtering`
-    this.touchMemories(processed.map((row) => row.id))
-    return processed
   }
 
-  async hybridSearch(
+  search(
     query: string,
     scopeId: string,
     limit: number = DEFAULT_MEMORY_SEARCH_LIMIT,
     memoryType?: MemoryRecord['memoryType'],
-  ): Promise<MemorySearchResult[]> {
-    const queryEmbedding = await this.generateEmbedding(query)
-
-    const { sql, bindVars } = memoryQueryBuilder.buildHybridSearch({
-      query,
-      embedding: queryEmbedding,
-      scopeId,
-      limit,
-      memoryType,
-    })
-
-    type RrfRow = BasicSearchRow & { rrfScore: number }
-
-    const results = await this.queryFinalStatement<RrfRow>(sql, bindVars)
-
-    const memoryIds = results.map((row) => row.id)
-    const relationCounts = await this.fetchRelationCountsBatch(memoryIds)
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return this.searchEffect(query, scopeId, limit, memoryType)
+  }
 
-    const processed = processGraphAwareRows(
-      results,
-      relationCounts,
-      limit,
-      (row) => row.rrfScore,
-      WEAK_GRAPH_BOOSTS,
-      MIN_RELEVANCE_SCORE,
+  private hybridSearchEffect(
+    query: string,
+    scopeId: string,
+    limit: number = DEFAULT_MEMORY_SEARCH_LIMIT,
+    memoryType?: MemoryRecord['memoryType'],
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        const queryEmbedding = yield* this.generateEmbeddingEffect(query)
+        const { sql, bindVars } = memoryQueryBuilder.buildHybridSearch({
+          query,
+          embedding: queryEmbedding,
+          scopeId,
+          limit,
+          memoryType,
+        })
+
+        type RrfRow = BasicSearchRow & { rrfScore: number }
+
+        const results = yield* this.queryFinalStatementEffect<RrfRow>(sql, bindVars)
+        const relationCounts = yield* this.fetchRelationCountsBatchEffect(results.map((row) => row.id))
+        const processed = processGraphAwareRows(
+          results,
+          relationCounts,
+          limit,
+          (row) => row.rrfScore,
+          WEAK_GRAPH_BOOSTS,
+          MIN_RELEVANCE_SCORE,
+        )
+
+        yield* this.touchMemories(processed.map((row) => row.id))
+        return processed
+      }.bind(this),
     )
+  }
 
-    this.touchMemories(processed.map((row) => row.id))
-    return processed
+  hybridSearch(
+    query: string,
+    scopeId: string,
+    limit: number = DEFAULT_MEMORY_SEARCH_LIMIT,
+    memoryType?: MemoryRecord['memoryType'],
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return this.hybridSearchEffect(query, scopeId, limit, memoryType)
   }
 
   private static HYBRID_SEARCH_TIMEOUT_MS = 2000
 
-  async hybridSearchWeighted(
+  private hybridSearchWeightedEffect(
     query: string,
     options: {
       scopeId: string
@@ -546,253 +647,336 @@ export class SurrealMemoryStore {
       normalization?: LinearNormalization
       fastMode?: boolean
     },
-  ): Promise<MemorySearchResult[]> {
-    const searchStart = performance.now()
-    const queryEmbedding = await this.generateEmbedding(query)
-
-    const tokens = this.tokenizeQuery(query)
-    if (tokens.length === 0) {
-      aiLogger.debug`Skipping hybrid search (no valid tokens). Using vector search only.`
-      return this.vectorSearchWithEmbedding({
-        embedding: queryEmbedding,
-        scopeId: options.scopeId,
-        limit: options.limit,
-        memoryType: options.memoryType,
-        fastMode: options.fastMode,
-      })
-    }
-
-    const tokenQuery = tokens.join(' ')
-    const fullTextQuery = tokenQuery.length > 0 ? tokenQuery : query
-
-    const weights = options.weights ?? [2, 1]
-    const normalization = options.normalization ?? 'minmax'
-
-    const { sql, bindVars } = memoryQueryBuilder.buildLinearSearch({
-      query: fullTextQuery,
-      embedding: queryEmbedding,
-      scopeId: options.scopeId,
-      limit: options.limit,
-      memoryType: options.memoryType,
-      weights,
-      normalization,
-    })
-
-    type LinearRow = BasicSearchRow & { linearScore: number }
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        const searchStart = performance.now()
+        const queryEmbedding = yield* this.generateEmbeddingEffect(query)
+        const tokens = this.tokenizeQuery(query)
+        if (tokens.length === 0) {
+          aiLogger.debug`Skipping hybrid search (no valid tokens). Using vector search only.`
+          return yield* this.vectorSearchWithEmbeddingEffect({
+            embedding: queryEmbedding,
+            scopeId: options.scopeId,
+            limit: options.limit,
+            memoryType: options.memoryType,
+            fastMode: options.fastMode,
+          })
+        }
 
-    let results: LinearRow[]
-    try {
-      results = await withTimeout(
-        this.queryFinalStatement<LinearRow>(sql, bindVars),
-        SurrealMemoryStore.HYBRID_SEARCH_TIMEOUT_MS,
-        'Hybrid search',
-      )
-    } catch {
-      const elapsed = performance.now() - searchStart
-      aiLogger.warn`Hybrid search timed out after ${elapsed.toFixed(0)}ms (scopeId: ${options.scopeId}). Falling back to vector-only.`
-      return this.vectorSearchWithEmbedding({
-        embedding: queryEmbedding,
-        scopeId: options.scopeId,
-        limit: options.limit,
-        memoryType: options.memoryType,
-        fastMode: options.fastMode,
-      })
-    }
+        const tokenQuery = tokens.join(' ')
+        const fullTextQuery = tokenQuery.length > 0 ? tokenQuery : query
+
+        const weights = options.weights ?? [2, 1]
+        const normalization = options.normalization ?? 'minmax'
+
+        const { sql, bindVars } = memoryQueryBuilder.buildLinearSearch({
+          query: fullTextQuery,
+          embedding: queryEmbedding,
+          scopeId: options.scopeId,
+          limit: options.limit,
+          memoryType: options.memoryType,
+          weights,
+          normalization,
+        })
+
+        type LinearRow = BasicSearchRow & { linearScore: number }
+
+        const recordSearchDuration = this.recordMemorySearchDuration.bind(this)
+        const linearResults = yield* this.queryFinalStatementEffect<LinearRow>(sql, bindVars).pipe(
+          Effect.timeout(Duration.millis(SurrealMemoryStore.HYBRID_SEARCH_TIMEOUT_MS)),
+          Effect.catchTag('TimeoutError', () =>
+            Effect.gen(function* () {
+              const elapsed = performance.now() - searchStart
+              yield* recordSearchDuration(elapsed)
+              aiLogger.warn`Hybrid search timed out after ${elapsed.toFixed(0)}ms (scopeId: ${options.scopeId}). Falling back to vector-only.`
+              return null
+            }),
+          ),
+        )
+
+        if (linearResults === null) {
+          return yield* this.vectorSearchWithEmbeddingEffect({
+            embedding: queryEmbedding,
+            scopeId: options.scopeId,
+            limit: options.limit,
+            memoryType: options.memoryType,
+            fastMode: options.fastMode,
+          })
+        }
 
-    if (results.length === 0) {
-      aiLogger.debug`Weighted hybrid search returned 0 raw results (scopeId: ${options.scopeId})`
-      return this.fallbackWeightedSearch(query, tokens, {
-        embedding: queryEmbedding,
-        scopeId: options.scopeId,
-        limit: options.limit,
-        memoryType: options.memoryType,
-        reason: 'no_raw_results',
-        fastMode: options.fastMode,
-      })
-    }
+        if (linearResults.length === 0) {
+          aiLogger.debug`Weighted hybrid search returned 0 raw results (scopeId: ${options.scopeId})`
+          return yield* this.fallbackWeightedSearchEffect(query, tokens, {
+            embedding: queryEmbedding,
+            scopeId: options.scopeId,
+            limit: options.limit,
+            memoryType: options.memoryType,
+            reason: 'no_raw_results',
+            fastMode: options.fastMode,
+          })
+        }
 
-    if (options.fastMode) {
-      const fastResults = this.mapFastRows(results, options.limit, (row) => row.linearScore)
-      return fastResults
-    }
+        if (options.fastMode) {
+          return this.mapFastRows(linearResults, options.limit, (row) => row.linearScore)
+        }
 
-    const memoryIds = results.map((row) => row.id)
-    const relationCounts = await this.fetchRelationCountsBatch(memoryIds)
+        const relationCounts = yield* this.fetchRelationCountsBatchEffect(linearResults.map((row) => row.id))
+        const processed = processGraphAwareRows(
+          linearResults,
+          relationCounts,
+          options.limit,
+          (row) => row.linearScore,
+          WEAK_GRAPH_BOOSTS,
+          MIN_RELEVANCE_SCORE,
+        )
+
+        if (processed.length === 0) {
+          aiLogger.debug`Weighted hybrid search candidates were fully filtered (scopeId: ${options.scopeId}). Falling back to vector/recent.`
+          return yield* this.fallbackWeightedSearchEffect(query, tokens, {
+            embedding: queryEmbedding,
+            scopeId: options.scopeId,
+            limit: options.limit,
+            memoryType: options.memoryType,
+            reason: 'filtered_to_zero',
+            fastMode: options.fastMode,
+          })
+        }
 
-    const processed = processGraphAwareRows(
-      results,
-      relationCounts,
-      options.limit,
-      (row) => row.linearScore,
-      WEAK_GRAPH_BOOSTS,
-      MIN_RELEVANCE_SCORE,
+        const elapsed = performance.now() - searchStart
+        yield* this.recordMemorySearchDuration(elapsed)
+        aiLogger.debug`[SUCCESS_WEIGHTED_SEARCH] Weighted hybrid search succeeded (scopeId: ${options.scopeId}, rawResults: ${linearResults.length}, returned: ${processed.length}, weights: ${weights.join(',')}, normalization: ${normalization}, latencyMs: ${elapsed.toFixed(0)})`
+        yield* this.touchMemories(processed.map((row) => row.id))
+        return processed
+      }.bind(this),
     )
+  }
 
-    if (processed.length === 0) {
-      aiLogger.debug`Weighted hybrid search candidates were fully filtered (scopeId: ${options.scopeId}). Falling back to vector/recent.`
-      return this.fallbackWeightedSearch(query, tokens, {
-        embedding: queryEmbedding,
-        scopeId: options.scopeId,
-        limit: options.limit,
-        memoryType: options.memoryType,
-        reason: 'filtered_to_zero',
-        fastMode: options.fastMode,
-      })
-    }
-
-    const elapsed = performance.now() - searchStart
-    aiLogger.info`[SUCCESS_WEIGHTED_SEARCH] Weighted hybrid search succeeded (scopeId: ${options.scopeId}, rawResults: ${results.length}, returned: ${processed.length}, weights: ${weights.join(',')}, normalization: ${normalization}, latencyMs: ${elapsed.toFixed(0)})`
-    this.touchMemories(processed.map((row) => row.id))
-    return processed
+  hybridSearchWeighted(
+    query: string,
+    options: {
+      scopeId: string
+      limit: number
+      memoryType?: MemoryRecord['memoryType']
+      weights?: [number, number]
+      normalization?: LinearNormalization
+      fastMode?: boolean
+    },
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return this.hybridSearchWeightedEffect(query, options)
   }
 
-  async get(id: string): Promise<MemoryRecord | null> {
+  private getEffect(id: string): Effect.Effect<MemoryRecord | null, MemoryStoreError, never> {
     const sql = `SELECT * FROM ${MEMORY_TABLE} WHERE id = $id`
-    const results = await databaseService.query<SurrealMemoryRow>(
-      new BoundQuery(sql, { id: ensureRecordId(id, TABLES.MEMORY) }),
+    return tryMemoryStorePromise('Failed to get memory.', () =>
+      this.db.query<SurrealMemoryRow>(new BoundQuery(sql, { id: ensureRecordId(id, TABLES.MEMORY) })),
+    ).pipe(
+      Effect.map((results) => {
+        const row = results.at(0)
+        if (!row) return null
+        return mapRowToMemoryRecord(row)
+      }),
     )
+  }
 
-    const row = results.at(0)
-    if (!row) return null
-    return mapRowToMemoryRecord(row)
+  get(id: string): Effect.Effect<MemoryRecord | null, MemoryStoreError, never> {
+    return this.getEffect(id)
   }
 
-  async update(
+  private updateEffect(
     id: string,
     newContent: string,
     options?: { importance?: number; durability?: MemoryRecord['durability']; metadata?: Record<string, unknown> },
-  ): Promise<void> {
-    const existing = await this.get(id)
-    if (!existing) return
-
-    const newHash = hashContent(newContent, existing.scopeId, existing.memoryType)
-    const newEmbedding = await this.generateEmbedding(newContent)
-
-    const importance =
-      typeof options?.importance === 'number'
-        ? Math.max(existing.importance, clampImportance(options.importance))
-        : undefined
-
-    const durability = options?.durability
-    const metadata = options?.metadata ? { ...existing.metadata, ...options.metadata } : undefined
-
-    const updatePayload: Record<string, unknown> = { content: newContent, embedding: newEmbedding, hash: newHash }
-    if (importance !== undefined) {
-      updatePayload.importance = importance
-    }
-    if (durability !== undefined) {
-      updatePayload.durability = durability
-    }
-    if (metadata !== undefined) {
-      updatePayload.metadata = metadata
-    }
-
-    await databaseService.updateWhere(MEMORY_TABLE, eq('id', ensureRecordId(id, TABLES.MEMORY)), updatePayload)
+  ): Effect.Effect<void, MemoryStoreError, never> {
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        const existing = yield* this.getEffect(id)
+        if (!existing) return
+
+        const newHash = hashContent(newContent, existing.scopeId, existing.memoryType)
+        const newEmbedding = yield* this.generateEmbeddingEffect(newContent)
+        const importance =
+          typeof options?.importance === 'number'
+            ? Math.max(existing.importance, clampImportance(options.importance))
+            : undefined
+
+        const durability = options?.durability
+        const metadata = options?.metadata ? { ...existing.metadata, ...options.metadata } : undefined
+
+        const updatePayload: Record<string, unknown> = { content: newContent, embedding: newEmbedding, hash: newHash }
+        if (importance !== undefined) {
+          updatePayload.importance = importance
+        }
+        if (durability !== undefined) {
+          updatePayload.durability = durability
+        }
+        if (metadata !== undefined) {
+          updatePayload.metadata = metadata
+        }
 
-    await this.recordHistory(id, existing.content, newContent, 'UPDATE')
+        yield* tryMemoryStorePromise('Failed to update memory.', () =>
+          this.db.updateWhere(MEMORY_TABLE, eq('id', ensureRecordId(id, TABLES.MEMORY)), updatePayload),
+        )
+        yield* this.recordHistoryEffect(id, existing.content, newContent, 'UPDATE')
+      }.bind(this),
+    )
   }
 
-  async delete(id: string): Promise<void> {
-    const existing = await this.get(id)
-    if (!existing) return
+  update(
+    id: string,
+    newContent: string,
+    options?: { importance?: number; durability?: MemoryRecord['durability']; metadata?: Record<string, unknown> },
+  ): Effect.Effect<void, MemoryStoreError, never> {
+    return this.updateEffect(id, newContent, options)
+  }
 
-    await databaseService.deleteById(MEMORY_TABLE, id)
+  private deleteEffect(id: string): Effect.Effect<void, MemoryStoreError, never> {
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        const existing = yield* this.getEffect(id)
+        if (!existing) return
 
-    await this.recordHistory(id, existing.content, null, 'DELETE')
+        yield* tryMemoryStorePromise('Failed to delete memory.', () => this.db.deleteById(MEMORY_TABLE, id))
+        yield* this.recordHistoryEffect(id, existing.content, null, 'DELETE')
+      }.bind(this),
+    )
   }
 
-  async list(options: MemoryListOptions): Promise<MemoryRecord[]> {
-    const whereClauses = [
-      'scopeId = $scopeId',
-      'archivedAt IS NONE',
-      '(validUntil IS NONE OR validUntil > time::now())',
-    ]
-    const bindVars: Record<string, unknown> = { scopeId: options.scopeId }
-
-    if (options.memoryType) {
-      whereClauses.push('memoryType = $memoryType')
-      bindVars.memoryType = options.memoryType
-    }
+  delete(id: string): Effect.Effect<void, MemoryStoreError, never> {
+    return this.deleteEffect(id)
+  }
 
-    for (const [index, [key, value]] of Object.entries(options.metadataEquals ?? {}).entries()) {
-      const fieldPath = this.toMetadataFieldPath(key)
-      const bindKey = `metadataEquals_${index}`
-      whereClauses.push(`${fieldPath} = $${bindKey}`)
-      bindVars[bindKey] = value
-    }
+  private listEffect(options: MemoryListOptions): Effect.Effect<MemoryRecord[], MemoryStoreError, never> {
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        const whereClauses = [
+          'scopeId = $scopeId',
+          'archivedAt IS NONE',
+          '(validUntil IS NONE OR validUntil > time::now())',
+        ]
+        const bindVars: Record<string, unknown> = { scopeId: options.scopeId }
+
+        if (options.memoryType) {
+          whereClauses.push('memoryType = $memoryType')
+          bindVars.memoryType = options.memoryType
+        }
 
-    for (const [index, [key, value]] of Object.entries(options.metadataNotEquals ?? {}).entries()) {
-      const fieldPath = this.toMetadataFieldPath(key)
-      const bindKey = `metadataNotEquals_${index}`
-      whereClauses.push(`(${fieldPath} IS NONE OR ${fieldPath} != $${bindKey})`)
-      bindVars[bindKey] = value
-    }
+        for (const [index, [key, value]] of Object.entries(options.metadataEquals ?? {}).entries()) {
+          const fieldPath = yield* this.toMetadataFieldPathEffect(key)
+          const bindKey = `metadataEquals_${index}`
+          whereClauses.push(`${fieldPath} = $${bindKey}`)
+          bindVars[bindKey] = value
+        }
 
-    const sortDirection = options.sort === 'createdAtAsc' ? 'ASC' : 'DESC'
-    const limitClause = typeof options.limit === 'number' ? 'LIMIT $limit' : ''
-    if (typeof options.limit === 'number') {
-      bindVars.limit = options.limit
-    }
+        for (const [index, [key, value]] of Object.entries(options.metadataNotEquals ?? {}).entries()) {
+          const fieldPath = yield* this.toMetadataFieldPathEffect(key)
+          const bindKey = `metadataNotEquals_${index}`
+          whereClauses.push(`(${fieldPath} IS NONE OR ${fieldPath} != $${bindKey})`)
+          bindVars[bindKey] = value
+        }
 
-    const sql = `
-      SELECT * FROM ${MEMORY_TABLE}
-      WHERE ${whereClauses.join('\n        AND ')}
-      ORDER BY createdAt ${sortDirection}
-      ${limitClause}
-    `
+        const sortDirection = options.sort === 'createdAtAsc' ? 'ASC' : 'DESC'
+        const limitClause = typeof options.limit === 'number' ? 'LIMIT $limit' : ''
+        if (typeof options.limit === 'number') {
+          bindVars.limit = options.limit
+        }
 
-    const results = await databaseService.query<SurrealMemoryRow>(new BoundQuery(sql, bindVars))
+        const sql = `
+          SELECT * FROM ${MEMORY_TABLE}
+          WHERE ${whereClauses.join('\n        AND ')}
+          ORDER BY createdAt ${sortDirection}
+          ${limitClause}
+        `
 
-    return results.map((row) => mapRowToMemoryRecord(row))
+        return yield* tryMemoryStorePromise('Failed to list memories.', () =>
+          this.db.query<SurrealMemoryRow>(new BoundQuery(sql, bindVars)),
+        ).pipe(Effect.map((results) => results.map((row: SurrealMemoryRow) => mapRowToMemoryRecord(row))))
+      }.bind(this),
+    )
   }
 
-  async findByHash(hash: string): Promise<MemoryRecord | null> {
-    const sql = `SELECT * FROM ${MEMORY_TABLE} WHERE hash = $hash`
-    const results = await databaseService.query<SurrealMemoryRow>(new BoundQuery(sql, { hash }))
-
-    const row = results.at(0)
-    if (!row) return null
-    return mapRowToMemoryRecord(row)
+  list(options: MemoryListOptions): Effect.Effect<MemoryRecord[], MemoryStoreError, never> {
+    return this.listEffect(options)
   }
 
-  async addRelation(fromId: string, toId: string, relationType: RelationType, confidence: number = 1.0): Promise<void> {
-    confidence = clampImportance(confidence)
+  private addRelationEffect(
+    fromId: string,
+    toId: string,
+    relationType: RelationType,
+    confidence: number = 1.0,
+  ): Effect.Effect<void, MemoryStoreError, never> {
+    const normalizedConfidence = clampImportance(confidence)
     const fromRef = ensureRecordId(fromId, TABLES.MEMORY)
     const toRef = ensureRecordId(toId, TABLES.MEMORY)
-    await databaseService.relate(fromRef, MEMORY_RELATION_TABLE, toRef, { relationType, confidence })
+    return Effect.gen(
+      function* (this: SurrealMemoryStore) {
+        yield* tryMemoryStorePromise('Failed to create memory relation.', () =>
+          this.db.relate(fromRef, MEMORY_RELATION_TABLE, toRef, { relationType, confidence: normalizedConfidence }),
+        )
+        if (relationType !== 'supersedes') return
+
+        yield* tryMemoryStorePromise('Failed to update superseded memory validity.', () =>
+          this.db.query(
+            new BoundQuery(
+              `UPDATE ${MEMORY_TABLE} SET validUntil = time::now() WHERE id = $toId AND validUntil IS NONE`,
+              { toId: toRef },
+            ),
+          ),
+        )
+        yield* this.flagDependentsForReviewEffect(toRef)
+      }.bind(this),
+    )
+  }
 
-    if (relationType === 'supersedes') {
-      await databaseService.query(
-        new BoundQuery(`UPDATE ${MEMORY_TABLE} SET validUntil = time::now() WHERE id = $toId AND validUntil IS NONE`, {
-          toId: toRef,
-        }),
-      )
-      await this.flagDependentsForReview(toRef)
-    }
+  addRelation(
+    fromId: string,
+    toId: string,
+    relationType: RelationType,
+    confidence: number = 1.0,
+  ): Effect.Effect<void, MemoryStoreError, never> {
+    return this.addRelationEffect(fromId, toId, relationType, confidence)
   }
 
-  private async flagDependentsForReview(supersededId: RecordIdRef): Promise<void> {
-    const dependents = await databaseService.query<{ id: RecordIdInput }>(
-      new BoundQuery(
-        `SELECT id FROM ${MEMORY_TABLE}
-       WHERE ->${MEMORY_RELATION_TABLE}[WHERE relationType = 'depends_on']->${MEMORY_TABLE} CONTAINS $supersededId
-         AND archivedAt IS NONE
-         AND needsReview = false`,
-        { supersededId },
+  private flagDependentsForReviewEffect(supersededId: RecordIdRef): Effect.Effect<void, MemoryStoreError, never> {
+    return tryMemoryStorePromise('Failed to flag dependent memories for review.', () =>
+      this.db.query<{ id: RecordIdInput }>(
+        new BoundQuery(
+          `SELECT id FROM ${MEMORY_TABLE}
+         WHERE ->${MEMORY_RELATION_TABLE}[WHERE relationType = 'depends_on']->${MEMORY_TABLE} CONTAINS $supersededId
+           AND archivedAt IS NONE
+           AND needsReview = false`,
+          { supersededId },
+        ),
       ),
+    ).pipe(
+      Effect.flatMap((dependents) => {
+        if (dependents.length === 0) return Effect.void
+
+        const ids = dependents.map((d: { id: RecordIdInput }) => ensureRecordId(d.id, TABLES.MEMORY))
+        return tryMemoryStorePromise('Failed to flag dependent memories for review.', () =>
+          this.db.updateWhere(MEMORY_TABLE, inside('id', ids), { needsReview: true }),
+        ).pipe(
+          Effect.tap(() =>
+            Effect.sync(() => {
+              aiLogger.debug`Flagged ${dependents.length} dependent memories for review after supersede`
+            }),
+          ),
+        )
+      }),
     )
+  }
 
-    if (dependents.length === 0) return
-
-    const ids = dependents.map((d) => ensureRecordId(d.id, TABLES.MEMORY))
-    await databaseService.updateWhere(MEMORY_TABLE, inside('id', ids), { needsReview: true })
-    aiLogger.debug`Flagged ${dependents.length} dependent memories for review after supersede`
+  getRelatedMemories(
+    memoryId: string,
+    relationType?: RelationType,
+  ): Effect.Effect<{ relatesTo: MemoryRecord[]; relatedBy: MemoryRecord[] }, MemoryStoreError, never> {
+    return this.getRelatedMemoriesEffect(memoryId, relationType)
   }
 
-  async getRelatedMemories(
+  private getRelatedMemoriesEffect(
     memoryId: string,
     relationType?: RelationType,
-  ): Promise<{ relatesTo: MemoryRecord[]; relatedBy: MemoryRecord[] }> {
+  ): Effect.Effect<{ relatesTo: MemoryRecord[]; relatedBy: MemoryRecord[] }, MemoryStoreError, never> {
     const typeFilter = relationType ? `[WHERE relationType = $relationType]` : ''
 
     const sql = `
@@ -802,18 +986,30 @@ export class SurrealMemoryStore {
       FROM ONLY $memoryId
     `
 
-    const result = await databaseService.query<{ relatesTo: SurrealMemoryRow[]; relatedBy: SurrealMemoryRow[] }>(
-      new BoundQuery(sql, { memoryId: ensureRecordId(memoryId, TABLES.MEMORY), relationType }),
+    return tryMemoryStorePromise('Failed to get related memories.', () =>
+      this.db.query<{ relatesTo: SurrealMemoryRow[]; relatedBy: SurrealMemoryRow[] }>(
+        new BoundQuery(sql, { memoryId: ensureRecordId(memoryId, TABLES.MEMORY), relationType }),
+      ),
+    ).pipe(
+      Effect.map((result) => {
+        const data = result[0] ?? { relatesTo: [], relatedBy: [] }
+        return {
+          relatesTo: data.relatesTo.map((row: SurrealMemoryRow) => mapRowToMemoryRecord(row)),
+          relatedBy: data.relatedBy.map((row: SurrealMemoryRow) => mapRowToMemoryRecord(row)),
+        }
+      }),
     )
+  }
 
-    const data = result[0] ?? { relatesTo: [], relatedBy: [] }
-    return {
-      relatesTo: data.relatesTo.map((row) => mapRowToMemoryRecord(row)),
-      relatedBy: data.relatedBy.map((row) => mapRowToMemoryRecord(row)),
-    }
+  findConflicts(
+    scopeId: string,
+  ): Effect.Effect<Array<{ memory: MemoryRecord; contradictedBy: MemoryRecord[] }>, MemoryStoreError, never> {
+    return this.findConflictsEffect(scopeId)
   }
 
-  async findConflicts(scopeId: string): Promise<Array<{ memory: MemoryRecord; contradictedBy: MemoryRecord[] }>> {
+  private findConflictsEffect(
+    scopeId: string,
+  ): Effect.Effect<Array<{ memory: MemoryRecord; contradictedBy: MemoryRecord[] }>, MemoryStoreError, never> {
     const sql = `
       SELECT 
         *,
@@ -823,91 +1019,132 @@ export class SurrealMemoryStore {
         AND count(<-${MEMORY_RELATION_TABLE}[WHERE relationType = 'contradicts']) > 0
     `
 
-    const results = await databaseService.query<SurrealMemoryRow & { contradictedBy: SurrealMemoryRow[] }>(
-      new BoundQuery(sql, { scopeId }),
+    return tryMemoryStorePromise('Failed to find memory conflicts.', () =>
+      this.db.query<SurrealMemoryRow & { contradictedBy: SurrealMemoryRow[] }>(new BoundQuery(sql, { scopeId })),
+    ).pipe(
+      Effect.map((results) =>
+        results.map((row: SurrealMemoryRow & { contradictedBy: SurrealMemoryRow[] }) => ({
+          memory: mapRowToMemoryRecord(row),
+          contradictedBy: row.contradictedBy.map((r: SurrealMemoryRow) => mapRowToMemoryRecord(r)),
+        })),
+      ),
     )
-
-    return results.map((row) => ({
-      memory: mapRowToMemoryRecord(row),
-      contradictedBy: row.contradictedBy.map((r) => mapRowToMemoryRecord(r)),
-    }))
   }
 
-  async graphWalk(
+  private graphWalkEffect(
     startId: string,
     depth = 2,
-  ): Promise<{
-    memories: MemoryRecord[]
-    edges: Array<{ from: string; to: string; relationType: RelationType; confidence: number }>
-  }> {
+  ): Effect.Effect<
+    {
+      memories: MemoryRecord[]
+      edges: Array<{ from: string; to: string; relationType: RelationType; confidence: number }>
+    },
+    MemoryStoreError,
+    never
+  > {
     const maxDepth = Math.min(depth, 3)
 
     const visited = new Set<string>([startId])
     const allEdges: Array<{ from: string; to: string; relationType: RelationType; confidence: number }> = []
     const allMemories: MemoryRecord[] = []
 
-    let frontier = [startId]
+    const walkHop = (frontier: string[], hop: number): Effect.Effect<void, MemoryStoreError, never> => {
+      if (hop >= maxDepth || frontier.length === 0) {
+        return Effect.void
+      }
 
-    for (let hop = 0; hop < maxDepth && frontier.length > 0; hop++) {
       const nextFrontier: string[] = []
 
-      for (const nodeId of frontier) {
-        const sql = `
-          SELECT
-            ->${MEMORY_RELATION_TABLE}.{in AS from, out AS to, relationType, confidence} AS outEdges,
-            ->${MEMORY_RELATION_TABLE}->${MEMORY_TABLE}[WHERE archivedAt IS NONE].* AS outMemories,
-            <-${MEMORY_RELATION_TABLE}.{in AS from, out AS to, relationType, confidence} AS inEdges,
-            <-${MEMORY_RELATION_TABLE}<-${MEMORY_TABLE}[WHERE archivedAt IS NONE].* AS inMemories
-          FROM ONLY $nodeId
-        `
-        const results = await databaseService.query<{
-          outEdges: Array<{ from: RecordIdInput; to: RecordIdInput; relationType: RelationType; confidence: number }>
-          outMemories: SurrealMemoryRow[]
-          inEdges: Array<{ from: RecordIdInput; to: RecordIdInput; relationType: RelationType; confidence: number }>
-          inMemories: SurrealMemoryRow[]
-        }>(new BoundQuery(sql, { nodeId: ensureRecordId(nodeId, TABLES.MEMORY) }))
-
-        const row = results.at(0)
-        if (row) {
-          for (const edge of row.outEdges) {
-            allEdges.push({
-              from: recordIdToString(edge.from, TABLES.MEMORY),
-              to: recordIdToString(edge.to, TABLES.MEMORY),
-              relationType: edge.relationType,
-              confidence: edge.confidence,
-            })
-          }
-          for (const edge of row.inEdges) {
-            allEdges.push({
-              from: recordIdToString(edge.from, TABLES.MEMORY),
-              to: recordIdToString(edge.to, TABLES.MEMORY),
-              relationType: edge.relationType,
-              confidence: edge.confidence,
-            })
-          }
-          for (const mem of [...row.outMemories, ...row.inMemories]) {
-            const memoryId = recordIdToString(mem.id, TABLES.MEMORY)
-            if (!visited.has(memoryId)) {
-              visited.add(memoryId)
-              allMemories.push(mapRowToMemoryRecord(mem))
-              nextFrontier.push(memoryId)
+      return Effect.all(
+        frontier.map((nodeId) =>
+          tryMemoryStorePromise('Failed to walk memory graph.', () =>
+            this.db.query<{
+              outEdges: Array<{
+                from: RecordIdInput
+                to: RecordIdInput
+                relationType: RelationType
+                confidence: number
+              }>
+              outMemories: SurrealMemoryRow[]
+              inEdges: Array<{ from: RecordIdInput; to: RecordIdInput; relationType: RelationType; confidence: number }>
+              inMemories: SurrealMemoryRow[]
+            }>(
+              new BoundQuery(
+                `
+            SELECT
+              ->${MEMORY_RELATION_TABLE}.{in AS from, out AS to, relationType, confidence} AS outEdges,
+              ->${MEMORY_RELATION_TABLE}->${MEMORY_TABLE}[WHERE archivedAt IS NONE].* AS outMemories,
+              <-${MEMORY_RELATION_TABLE}.{in AS from, out AS to, relationType, confidence} AS inEdges,
+              <-${MEMORY_RELATION_TABLE}<-${MEMORY_TABLE}[WHERE archivedAt IS NONE].* AS inMemories
+            FROM ONLY $nodeId
+          `,
+                { nodeId: ensureRecordId(nodeId, TABLES.MEMORY) },
+              ),
+            ),
+          ),
+        ),
+      ).pipe(
+        Effect.flatMap((results) =>
+          Effect.sync(() => {
+            for (const result of results) {
+              const row = result.at(0)
+              if (!row) continue
+
+              for (const edge of row.outEdges) {
+                allEdges.push({
+                  from: recordIdToString(edge.from, TABLES.MEMORY),
+                  to: recordIdToString(edge.to, TABLES.MEMORY),
+                  relationType: edge.relationType,
+                  confidence: edge.confidence,
+                })
+              }
+              for (const edge of row.inEdges) {
+                allEdges.push({
+                  from: recordIdToString(edge.from, TABLES.MEMORY),
+                  to: recordIdToString(edge.to, TABLES.MEMORY),
+                  relationType: edge.relationType,
+                  confidence: edge.confidence,
+                })
+              }
+              for (const mem of [...row.outMemories, ...row.inMemories]) {
+                const memoryId = recordIdToString(mem.id, TABLES.MEMORY)
+                if (!visited.has(memoryId)) {
+                  visited.add(memoryId)
+                  allMemories.push(mapRowToMemoryRecord(mem))
+                  nextFrontier.push(memoryId)
+                }
+              }
             }
-          }
-        }
-      }
 
-      frontier = nextFrontier
+            return undefined
+          }).pipe(Effect.flatMap(() => walkHop(nextFrontier, hop + 1))),
+        ),
+      )
     }
 
-    return { memories: allMemories, edges: allEdges }
+    return walkHop([startId], 0).pipe(Effect.as({ memories: allMemories, edges: allEdges }))
+  }
+
+  graphWalk(
+    startId: string,
+    depth = 2,
+  ): Effect.Effect<
+    {
+      memories: MemoryRecord[]
+      edges: Array<{ from: string; to: string; relationType: RelationType; confidence: number }>
+    },
+    MemoryStoreError,
+    never
+  > {
+    return this.graphWalkEffect(startId, depth)
   }
 
-  private async recordHistory(
+  private recordHistoryEffect(
     memoryId: string,
     prevValue: string | null,
     newValue: string | null,
     event: MemoryEvent,
-  ): Promise<void> {
+  ): Effect.Effect<void, MemoryStoreError, never> {
     const memoryRef = ensureRecordId(memoryId, TABLES.MEMORY)
     const historyRow: Record<string, unknown> = {
       memoryId: memoryRef,
@@ -915,12 +1152,17 @@ export class SurrealMemoryStore {
       ...(prevValue === null ? {} : { prevValue }),
       ...(newValue === null ? {} : { newValue }),
     }
-    await databaseService.insert<Record<string, unknown>>(MEMORY_HISTORY_TABLE, historyRow)
+    return tryMemoryStorePromise('Failed to record memory history.', () =>
+      this.db.insert<Record<string, unknown>>(MEMORY_HISTORY_TABLE, historyRow),
+    ).pipe(Effect.asVoid)
   }
 
-  async enrichWithNeighbors(results: MemorySearchResult[], topN: number = 5): Promise<MemorySearchResult[]> {
+  private enrichWithNeighborsEffect(
+    results: MemorySearchResult[],
+    topN: number = 5,
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
     const topIds = results.slice(0, topN).map((r) => r.id)
-    if (topIds.length === 0) return results
+    if (topIds.length === 0) return Effect.succeed(results)
 
     const topRefs = topIds.map((id) => ensureRecordId(id, TABLES.MEMORY))
 
@@ -933,65 +1175,90 @@ export class SurrealMemoryStore {
       WHERE id IN $ids
     `
 
-    const rows = await databaseService.query<{
-      id: RecordIdInput
-      outgoing: Array<{ id: RecordIdInput; content: string; relationType?: string }> | null
-      incoming: Array<{ id: RecordIdInput; content: string; relationType?: string }> | null
-    }>(new BoundQuery(sql, { ids: topRefs }))
-
-    const neighborMap = new Map<string, string[]>()
-    for (const row of rows) {
-      const rowId = recordIdToString(row.id, TABLES.MEMORY)
-      const contexts: string[] = []
-      const seen = new Set<string>()
-      for (const neighbor of [...(row.outgoing ?? []), ...(row.incoming ?? [])]) {
-        const neighborId = recordIdToString(neighbor.id, TABLES.MEMORY)
-        if (!neighbor.content || seen.has(neighborId)) continue
-        seen.add(neighborId)
-        const label = neighbor.relationType ? `[${neighbor.relationType}]` : ''
-        const truncated = truncateText(neighbor.content, 200)
-        contexts.push(`${label} ${truncated}`.trim())
-      }
-      if (contexts.length > 0) {
-        neighborMap.set(rowId, contexts)
-      }
-    }
+    return tryMemoryStorePromise('Failed to enrich memories with neighbors.', () =>
+      this.db.query<{
+        id: RecordIdInput
+        outgoing: Array<{ id: RecordIdInput; content: string; relationType?: string }> | null
+        incoming: Array<{ id: RecordIdInput; content: string; relationType?: string }> | null
+      }>(new BoundQuery(sql, { ids: topRefs })),
+    ).pipe(
+      Effect.map((rows) => {
+        const neighborMap = new Map<string, string[]>()
+        for (const row of rows) {
+          const rowId = recordIdToString(row.id, TABLES.MEMORY)
+          const contexts: string[] = []
+          const seen = new Set<string>()
+          for (const neighbor of [...(row.outgoing ?? []), ...(row.incoming ?? [])]) {
+            const neighborId = recordIdToString(neighbor.id, TABLES.MEMORY)
+            if (!neighbor.content || seen.has(neighborId)) continue
+            seen.add(neighborId)
+            const label = neighbor.relationType ? `[${neighbor.relationType}]` : ''
+            const truncated = truncateText(neighbor.content, 200)
+            contexts.push(`${label} ${truncated}`.trim())
+          }
+          if (contexts.length > 0) {
+            neighborMap.set(rowId, contexts)
+          }
+        }
 
-    return results.map((result) => {
-      const neighbors = neighborMap.get(result.id)
-      if (!neighbors) return result
-      return { ...result, metadata: { ...result.metadata, relatedContext: neighbors } }
-    })
+        return results.map((result) => {
+          const neighbors = neighborMap.get(result.id)
+          if (!neighbors) return result
+          return { ...result, metadata: { ...result.metadata, relatedContext: neighbors } }
+        })
+      }),
+    )
   }
 
-  async getStaleMemories(scopeId: string, limit: number = 5): Promise<MemorySearchResult[]> {
-    const results = await databaseService.query<BasicSearchRow>(
-      new BoundQuery(
-        `SELECT id, content, metadata
-       FROM ${MEMORY_TABLE}
-       WHERE scopeId = $scopeId
-         AND needsReview = true
-         AND archivedAt IS NONE
-       ORDER BY updatedAt DESC
-       LIMIT $limit`,
-        { scopeId, limit },
+  enrichWithNeighbors(
+    results: MemorySearchResult[],
+    topN: number = 5,
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return this.enrichWithNeighborsEffect(results, topN)
+  }
+
+  private getStaleMemoriesEffect(
+    scopeId: string,
+    limit: number = 5,
+  ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return tryMemoryStorePromise('Failed to list stale memories.', () =>
+      this.db.query<BasicSearchRow>(
+        new BoundQuery(
+          `SELECT id, content, metadata
+         FROM ${MEMORY_TABLE}
+         WHERE scopeId = $scopeId
+           AND needsReview = true
+           AND archivedAt IS NONE
+         ORDER BY updatedAt DESC
+         LIMIT $limit`,
+          { scopeId, limit },
+        ),
+      ),
+    ).pipe(
+      Effect.map((results) =>
+        results.map((row: BasicSearchRow) => ({
+          id: recordIdToString(row.id, TABLES.MEMORY),
+          content: row.content,
+          score: 0,
+          metadata: { ...row.metadata, needsReview: true },
+        })),
       ),
     )
+  }
 
-    return results.map((row) => ({
-      id: recordIdToString(row.id, TABLES.MEMORY),
-      content: row.content,
-      score: 0,
-      metadata: { ...row.metadata, needsReview: true },
-    }))
+  getStaleMemories(scopeId: string, limit: number = 5): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
+    return this.getStaleMemoriesEffect(scopeId, limit)
   }
 }
 
-let defaultMemoryStore: SurrealMemoryStore | null = null
-
-export function getDefaultMemoryStore(): SurrealMemoryStore {
-  if (!defaultMemoryStore) {
-    defaultMemoryStore = new SurrealMemoryStore(getDefaultEmbeddings())
-  }
-  return defaultMemoryStore
+export function createMemoryStore(
+  db: SurrealDBService,
+  options: { embeddingModel: string; openRouterApiKey?: string },
+  background: BackgroundWorker,
+): SurrealMemoryStore {
+  return new SurrealMemoryStore(
+    db,
+    new ProviderEmbeddings({ modelId: options.embeddingModel, openRouterApiKey: options.openRouterApiKey }),
+    background,
+  )
 }