@lota-sdk/core 0.4.13 → 0.4.14

package/src/db/memory-store.ts

@@ -3,8 +3,9 @@ import { Schema, Duration, Effect, Metric, Schedule } from 'effect'
 import { BoundQuery, eq, inside } from 'surrealdb'
 
 import { aiLogger } from '../config/logger'
+import { ERROR_TAGS } from '../effect/errors'
 import { ProviderEmbeddings } from '../embeddings/provider'
-import type { BackgroundWorkService } from '../services/background-work.service'
+import type { BackgroundWorkServiceTag } from '../services/background-work.service'
 import { clampImportance, truncateText } from '../utils/string'
 import { memoryQueryBuilder } from './memory-query-builder'
 import type { RelationCounts } from './memory-store.helpers'
@@ -25,7 +26,7 @@ import type { SurrealDBError } from './service-normalization'
 import { TABLES } from './tables'
 import { isRetriableTransactionConflict } from './transaction-conflict'
 
-type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkService>
+type BackgroundWorker = Context.Service.Shape<typeof BackgroundWorkServiceTag>
 
 const MEMORY_TABLE = TABLES.MEMORY
 const MEMORY_HISTORY_TABLE = TABLES.MEMORY_HISTORY
@@ -45,29 +46,11 @@ const TOUCH_MEMORIES_RETRY_OPTIONS = {
   while: (error: unknown) => isRetriableTransactionConflict(error),
 } as const
 
-class MemoryStoreError extends Schema.TaggedErrorClass<MemoryStoreError>()('MemoryStoreError', {
+class MemoryStoreError extends Schema.TaggedErrorClass<MemoryStoreError>()(ERROR_TAGS.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[]>
 }
@@ -165,8 +148,8 @@ export class SurrealMemoryStore {
       LIMIT $limit
     `
 
-    return tryMemoryStorePromise('Failed to list top memories.', () =>
-      this.db.query<SurrealMemoryRow>(
+    return this.db
+      .query<SurrealMemoryRow>(
         new BoundQuery(sql, {
           scopeId: options.scopeId,
           memoryType: options.memoryType,
@@ -174,8 +157,11 @@ export class SurrealMemoryStore {
           minImportance: options.minImportance,
           limit: options.limit,
         }),
-      ),
-    ).pipe(Effect.map((rows) => rows.map((row: SurrealMemoryRow) => mapRowToMemoryRecord(row))))
+      )
+      .pipe(
+        Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to list top memories.', cause })),
+        Effect.map((rows) => rows.map((row: SurrealMemoryRow) => mapRowToMemoryRecord(row))),
+      )
   }
 
   listTopMemories(options: {
@@ -245,7 +231,10 @@ export class SurrealMemoryStore {
     const normalized = content.trim()
     if (!normalized) return Effect.succeed([])
 
-    return tryMemoryStorePromise('Failed to generate memory embedding.', () => this.embeddings.embedQuery(normalized))
+    return Effect.tryPromise({
+      try: () => this.embeddings.embedQuery(normalized),
+      catch: (cause) => new MemoryStoreError({ message: 'Failed to generate memory embedding.', cause }),
+    })
   }
 
   warmEmbedding(content: string): Effect.Effect<void, MemoryStoreError, never> {
@@ -272,33 +261,34 @@ export class SurrealMemoryStore {
       WHERE id IN $memoryIds
     `
 
-    return tryMemoryStorePromise('Failed to fetch relation counts.', () =>
-      this.db.query<{
+    return 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,
-          })
-        }
+      }>(new BoundQuery(sql, { memoryIds: memoryRefs }))
+      .pipe(
+        Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to fetch relation counts.', cause })),
+        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[]): Effect.Effect<void> {
@@ -331,9 +321,8 @@ export class SurrealMemoryStore {
     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(
+    return this.db.queryAll<unknown>(new BoundQuery(sql, bindVars)).pipe(
+      Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to query memory statements.', cause })),
       Effect.map((statements) => {
         const finalStatement = statements.at(-1)
         return Array.isArray(finalStatement) ? (finalStatement as T[]) : []
@@ -366,9 +355,11 @@ export class SurrealMemoryStore {
         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 }),
-        )
+        const recent = yield* this.listRecentBasic({
+          scopeId: options.scopeId,
+          limit: recentLimit,
+          memoryType: options.memoryType,
+        }).pipe(Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to list recent memories.', cause })))
         if (recent.length === 0) return []
 
         const scoredRows = recent
@@ -425,8 +416,8 @@ export class SurrealMemoryStore {
           return nearDup.id
         }
 
-        const result = yield* tryMemoryStorePromise('Failed to insert memory.', () =>
-          this.db.insert<{ id: RecordIdInput }>(MEMORY_TABLE, {
+        const result = yield* this.db
+          .insert<{ id: RecordIdInput }>(MEMORY_TABLE, {
             content,
             embedding,
             hash,
@@ -435,8 +426,8 @@ export class SurrealMemoryStore {
             metadata,
             importance: normalizedImportance,
             durability,
-          }),
-        )
+          })
+          .pipe(Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to insert memory.', cause })))
         const id = result[0]?.id ? recordIdToString(result[0].id, TABLES.MEMORY) : ''
         yield* this.recordHistoryEffect(id, null, content, 'ADD')
         return id
@@ -456,8 +447,8 @@ export class SurrealMemoryStore {
   }
 
   private getByHashEffect(hash: string): Effect.Effect<MemoryRecord | null, MemoryStoreError, never> {
-    return tryMemoryStorePromise('Failed to query memory by hash.', () =>
-      this.db.query<SurrealMemoryRow>(
+    return this.db
+      .query<SurrealMemoryRow>(
         new BoundQuery(
           `
             SELECT *
@@ -467,13 +458,14 @@ export class SurrealMemoryStore {
           `,
           { hash },
         ),
-      ),
-    ).pipe(
-      Effect.map((rows) => {
-        const row = rows.at(0)
-        return row ? mapRowToMemoryRecord(row) : null
-      }),
-    )
+      )
+      .pipe(
+        Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to query memory by hash.', cause })),
+        Effect.map((rows) => {
+          const row = rows.at(0)
+          return row ? mapRowToMemoryRecord(row) : null
+        }),
+      )
   }
 
   getByHash(hash: string): Effect.Effect<MemoryRecord | null, MemoryStoreError, never> {
@@ -768,9 +760,8 @@ export class SurrealMemoryStore {
 
   private getEffect(id: string): Effect.Effect<MemoryRecord | null, MemoryStoreError, never> {
     const sql = `SELECT * FROM ${MEMORY_TABLE} WHERE id = $id`
-    return tryMemoryStorePromise('Failed to get memory.', () =>
-      this.db.query<SurrealMemoryRow>(new BoundQuery(sql, { id: ensureRecordId(id, TABLES.MEMORY) })),
-    ).pipe(
+    return this.db.query<SurrealMemoryRow>(new BoundQuery(sql, { id: ensureRecordId(id, TABLES.MEMORY) })).pipe(
+      Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to get memory.', cause })),
       Effect.map((results) => {
         const row = results.at(0)
         if (!row) return null
@@ -814,9 +805,9 @@ export class SurrealMemoryStore {
           updatePayload.metadata = metadata
         }
 
-        yield* tryMemoryStorePromise('Failed to update memory.', () =>
-          this.db.updateWhere(MEMORY_TABLE, eq('id', ensureRecordId(id, TABLES.MEMORY)), updatePayload),
-        )
+        yield* this.db
+          .updateWhere(MEMORY_TABLE, eq('id', ensureRecordId(id, TABLES.MEMORY)), updatePayload)
+          .pipe(Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to update memory.', cause })))
         yield* this.recordHistoryEffect(id, existing.content, newContent, 'UPDATE')
       }.bind(this),
     )
@@ -836,7 +827,9 @@ export class SurrealMemoryStore {
         const existing = yield* this.getEffect(id)
         if (!existing) return
 
-        yield* tryMemoryStorePromise('Failed to delete memory.', () => this.db.deleteById(MEMORY_TABLE, id))
+        yield* this.db
+          .deleteById(MEMORY_TABLE, id)
+          .pipe(Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to delete memory.', cause })))
         yield* this.recordHistoryEffect(id, existing.content, null, 'DELETE')
       }.bind(this),
     )
@@ -888,9 +881,10 @@ export class SurrealMemoryStore {
           ${limitClause}
         `
 
-        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))))
+        return yield* this.db.query<SurrealMemoryRow>(new BoundQuery(sql, bindVars)).pipe(
+          Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to list memories.', cause })),
+          Effect.map((results) => results.map((row: SurrealMemoryRow) => mapRowToMemoryRecord(row))),
+        )
       }.bind(this),
     )
   }
@@ -910,19 +904,25 @@ export class SurrealMemoryStore {
     const toRef = ensureRecordId(toId, TABLES.MEMORY)
     return Effect.gen(
       function* (this: SurrealMemoryStore) {
-        yield* tryMemoryStorePromise('Failed to create memory relation.', () =>
-          this.db.relate(fromRef, MEMORY_RELATION_TABLE, toRef, { relationType, confidence: normalizedConfidence }),
-        )
+        yield* this.db
+          .relate(fromRef, MEMORY_RELATION_TABLE, toRef, { relationType, confidence: normalizedConfidence })
+          .pipe(
+            Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to create memory relation.', cause })),
+          )
         if (relationType !== 'supersedes') return
 
-        yield* tryMemoryStorePromise('Failed to update superseded memory validity.', () =>
-          this.db.query(
+        yield* this.db
+          .query(
             new BoundQuery(
               `UPDATE ${MEMORY_TABLE} SET validUntil = time::now() WHERE id = $toId AND validUntil IS NONE`,
               { toId: toRef },
             ),
-          ),
-        )
+          )
+          .pipe(
+            Effect.mapError(
+              (cause) => new MemoryStoreError({ message: 'Failed to update superseded memory validity.', cause }),
+            ),
+          )
         yield* this.flagDependentsForReviewEffect(toRef)
       }.bind(this),
     )
@@ -938,8 +938,8 @@ export class SurrealMemoryStore {
   }
 
   private flagDependentsForReviewEffect(supersededId: RecordIdRef): Effect.Effect<void, MemoryStoreError, never> {
-    return tryMemoryStorePromise('Failed to flag dependent memories for review.', () =>
-      this.db.query<{ id: RecordIdInput }>(
+    return this.db
+      .query<{ id: RecordIdInput }>(
         new BoundQuery(
           `SELECT id FROM ${MEMORY_TABLE}
          WHERE ->${MEMORY_RELATION_TABLE}[WHERE relationType = 'depends_on']->${MEMORY_TABLE} CONTAINS $supersededId
@@ -947,23 +947,27 @@ export class SurrealMemoryStore {
            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`
-            }),
-          ),
-        )
-      }),
-    )
+      )
+      .pipe(
+        Effect.mapError(
+          (cause) => new MemoryStoreError({ message: 'Failed to flag dependent memories for review.', cause }),
+        ),
+        Effect.flatMap((dependents) => {
+          if (dependents.length === 0) return Effect.void
+
+          const ids = dependents.map((d: { id: RecordIdInput }) => ensureRecordId(d.id, TABLES.MEMORY))
+          return this.db.updateWhere(MEMORY_TABLE, inside('id', ids), { needsReview: true }).pipe(
+            Effect.mapError(
+              (cause) => new MemoryStoreError({ message: 'Failed to flag dependent memories for review.', cause }),
+            ),
+            Effect.tap(() =>
+              Effect.sync(() => {
+                aiLogger.debug`Flagged ${dependents.length} dependent memories for review after supersede`
+              }),
+            ),
+          )
+        }),
+      )
   }
 
   getRelatedMemories(
@@ -986,19 +990,20 @@ export class SurrealMemoryStore {
       FROM ONLY $memoryId
     `
 
-    return tryMemoryStorePromise('Failed to get related memories.', () =>
-      this.db.query<{ relatesTo: SurrealMemoryRow[]; relatedBy: SurrealMemoryRow[] }>(
+    return 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)),
-        }
-      }),
-    )
+      )
+      .pipe(
+        Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to get related memories.', cause })),
+        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)),
+          }
+        }),
+      )
   }
 
   findConflicts(
@@ -1019,16 +1024,17 @@ export class SurrealMemoryStore {
         AND count(<-${MEMORY_RELATION_TABLE}[WHERE relationType = 'contradicts']) > 0
     `
 
-    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 this.db
+      .query<SurrealMemoryRow & { contradictedBy: SurrealMemoryRow[] }>(new BoundQuery(sql, { scopeId }))
+      .pipe(
+        Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to find memory conflicts.', cause })),
+        Effect.map((results) =>
+          results.map((row: SurrealMemoryRow & { contradictedBy: SurrealMemoryRow[] }) => ({
+            memory: mapRowToMemoryRecord(row),
+            contradictedBy: row.contradictedBy.map((r: SurrealMemoryRow) => mapRowToMemoryRecord(r)),
+          })),
+        ),
+      )
   }
 
   private graphWalkEffect(
@@ -1057,8 +1063,8 @@ export class SurrealMemoryStore {
 
       return Effect.all(
         frontier.map((nodeId) =>
-          tryMemoryStorePromise('Failed to walk memory graph.', () =>
-            this.db.query<{
+          this.db
+            .query<{
               outEdges: Array<{
                 from: RecordIdInput
                 to: RecordIdInput
@@ -1076,12 +1082,12 @@ export class SurrealMemoryStore {
               ->${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
+          FROM ONLY $nodeId
           `,
                 { nodeId: ensureRecordId(nodeId, TABLES.MEMORY) },
               ),
-            ),
-          ),
+            )
+            .pipe(Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to walk memory graph.', cause }))),
         ),
       ).pipe(
         Effect.flatMap((results) =>
@@ -1152,9 +1158,10 @@ export class SurrealMemoryStore {
       ...(prevValue === null ? {} : { prevValue }),
       ...(newValue === null ? {} : { newValue }),
     }
-    return tryMemoryStorePromise('Failed to record memory history.', () =>
-      this.db.insert<Record<string, unknown>>(MEMORY_HISTORY_TABLE, historyRow),
-    ).pipe(Effect.asVoid)
+    return this.db.insert<Record<string, unknown>>(MEMORY_HISTORY_TABLE, historyRow).pipe(
+      Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to record memory history.', cause })),
+      Effect.asVoid,
+    )
   }
 
   private enrichWithNeighborsEffect(
@@ -1175,39 +1182,42 @@ export class SurrealMemoryStore {
       WHERE id IN $ids
     `
 
-    return tryMemoryStorePromise('Failed to enrich memories with neighbors.', () =>
-      this.db.query<{
+    return 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)
+      }>(new BoundQuery(sql, { ids: topRefs }))
+      .pipe(
+        Effect.mapError(
+          (cause) => new MemoryStoreError({ message: 'Failed to enrich memories with neighbors.', cause }),
+        ),
+        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 } }
+          })
+        }),
+      )
   }
 
   enrichWithNeighbors(
@@ -1221,8 +1231,8 @@ export class SurrealMemoryStore {
     scopeId: string,
     limit: number = 5,
   ): Effect.Effect<MemorySearchResult[], MemoryStoreError, never> {
-    return tryMemoryStorePromise('Failed to list stale memories.', () =>
-      this.db.query<BasicSearchRow>(
+    return this.db
+      .query<BasicSearchRow>(
         new BoundQuery(
           `SELECT id, content, metadata
          FROM ${MEMORY_TABLE}
@@ -1233,17 +1243,18 @@ export class SurrealMemoryStore {
          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 },
-        })),
-      ),
-    )
+      )
+      .pipe(
+        Effect.mapError((cause) => new MemoryStoreError({ message: 'Failed to list stale memories.', cause })),
+        Effect.map((results) =>
+          results.map((row: BasicSearchRow) => ({
+            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> {
@@ -1253,12 +1264,20 @@ export class SurrealMemoryStore {
 
 export function createMemoryStore(
   db: SurrealDBService,
-  options: { embeddingModel: string; openRouterApiKey?: string },
+  options: {
+    embeddingModel: string
+    openRouterApiKey?: string
+    runPromise: <A, E>(effect: Effect.Effect<A, E>) => Promise<A>
+  },
   background: BackgroundWorker,
 ): SurrealMemoryStore {
   return new SurrealMemoryStore(
     db,
-    new ProviderEmbeddings({ modelId: options.embeddingModel, openRouterApiKey: options.openRouterApiKey }),
+    new ProviderEmbeddings({
+      modelId: options.embeddingModel,
+      openRouterApiKey: options.openRouterApiKey,
+      runPromise: options.runPromise,
+    }),
     background,
   )
 }