@lota-sdk/core 0.4.13 → 0.4.15

package/src/workers/memory-consolidation.worker.ts

@@ -8,7 +8,7 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { effectTryPromise } from '../effect/helpers'
+import { ERROR_TAGS } from '../effect/errors'
 import { DatabaseServiceTag } from '../effect/services'
 import type { MemoryConsolidationJob } from '../queues/memory-consolidation.queue'
 import { QueueJobServiceTag } from '../services/queue-job.service'
@@ -18,27 +18,30 @@ import { initializeSandboxedWorkerRuntime } from './bootstrap'
 import { toSandboxedWorkerError } from './utils/sandbox-error'
 import { createTracedWorkerProcessor } from './worker-utils'
 
-class MemoryConsolidationError extends Schema.TaggedErrorClass<MemoryConsolidationError>()('MemoryConsolidationError', {
-  stage: Schema.Literals([
-    'read-memories',
-    'read-neighbors',
-    'archive-memory',
-    'relate-memories',
-    'write-history',
-    'load-stale',
-    'update-stale',
-    'load-middle-nodes',
-    'read-existing-relation',
-    'write-relation',
-    'update-middle-node',
-    'decay-standard',
-    'decay-ephemeral',
-    'cleanup-relations',
-    'load-scope-ids',
-  ]),
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
+class MemoryConsolidationError extends Schema.TaggedErrorClass<MemoryConsolidationError>()(
+  ERROR_TAGS.MemoryConsolidationError,
+  {
+    stage: Schema.Literals([
+      'read-memories',
+      'read-neighbors',
+      'archive-memory',
+      'relate-memories',
+      'write-history',
+      'load-stale',
+      'update-stale',
+      'load-middle-nodes',
+      'read-existing-relation',
+      'write-relation',
+      'update-middle-node',
+      'decay-standard',
+      'decay-ephemeral',
+      'cleanup-relations',
+      'load-scope-ids',
+    ]),
+    message: Schema.String,
+    cause: Schema.Defect,
+  },
+) {}
 
 function toMemoryConsolidationError(
   stage: MemoryConsolidationError['stage'],
@@ -47,13 +50,6 @@ function toMemoryConsolidationError(
   return new MemoryConsolidationError({ stage, message: getErrorMessage(cause), cause })
 }
 
-function tryMemoryConsolidationEffect<A, R = never>(
-  stage: MemoryConsolidationError['stage'],
-  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown, R>,
-): Effect.Effect<A, MemoryConsolidationError, R> {
-  return effectTryPromise(thunk, (cause) => toMemoryConsolidationError(stage, cause))
-}
-
 const runtime = await initializeSandboxedWorkerRuntime()
 
 const memoryConsolidationDatabaseService: SurrealDBService = await runtime.runPromise(
@@ -93,8 +89,8 @@ function isContentSubsumed(shorter: string, longer: string): boolean {
 
 function deduplicateScopeEffect(scopeId: string) {
   return Effect.gen(function* () {
-    const memoryRows = yield* tryMemoryConsolidationEffect('read-memories', () =>
-      db().query<{
+    const memoryRows = yield* db()
+      .query<{
         id: RecordIdInput
         content: string
         importance: number
@@ -110,8 +106,8 @@ function deduplicateScopeEffect(scopeId: string) {
            LIMIT $limit`,
           { scopeId, limit: MAX_MEMORIES_PER_SCOPE },
         ),
-      ),
-    )
+      )
+      .pipe(Effect.mapError((cause) => toMemoryConsolidationError('read-memories', cause)))
 
     const memories = memoryRows.map((row) => ({ ...row, id: toMemoryId(row.id) }))
     if (memories.length < 2) return 0
@@ -123,8 +119,8 @@ function deduplicateScopeEffect(scopeId: string) {
       if (archived.has(memory.id)) continue
 
       const candidateLimit = 20
-      const neighborStatements = yield* tryMemoryConsolidationEffect('read-neighbors', () =>
-        db().queryAll<{
+      const neighborStatements = yield* db()
+        .queryAll<{
           id: RecordIdInput
           content: string
           importance: number
@@ -159,8 +155,8 @@ function deduplicateScopeEffect(scopeId: string) {
              LIMIT ${candidateLimit}`,
             { scopeId, memoryId: ensureRecordId(memory.id, TABLES.MEMORY), embedding: memory.embedding },
           ),
-        ),
-      )
+        )
+        .pipe(Effect.mapError((cause) => toMemoryConsolidationError('read-neighbors', cause)))
 
       const neighbors = (neighborStatements.at(-1) ?? []).map((row) => ({ ...row, id: toMemoryId(row.id) }))
 
@@ -185,31 +181,31 @@ function deduplicateScopeEffect(scopeId: string) {
         const winner = keepMemory ? memory : neighbor
         const loser = keepMemory ? neighbor : memory
 
-        yield* tryMemoryConsolidationEffect('archive-memory', () =>
-          db().query(
+        yield* db()
+          .query(
             new BoundQuery(
               `UPDATE ${MEMORY_TABLE}
                SET archivedAt = time::now(), validUntil = time::now()
                WHERE id = $loserId AND archivedAt IS NONE`,
               { loserId: ensureRecordId(loser.id, TABLES.MEMORY) },
             ),
-          ),
-        )
-        yield* tryMemoryConsolidationEffect('relate-memories', () =>
-          db().relate(
+          )
+          .pipe(Effect.mapError((cause) => toMemoryConsolidationError('archive-memory', cause)))
+        yield* db()
+          .relate(
             ensureRecordId(winner.id, TABLES.MEMORY),
             MEMORY_RELATION_TABLE,
             ensureRecordId(loser.id, TABLES.MEMORY),
             { relationType: RELATION_SUPERSEDES, confidence: 1.0 },
-          ),
-        )
-        yield* tryMemoryConsolidationEffect('write-history', () =>
-          db().insert<Record<string, unknown>>(MEMORY_HISTORY_TABLE, {
+          )
+          .pipe(Effect.mapError((cause) => toMemoryConsolidationError('relate-memories', cause)))
+        yield* db()
+          .insert<Record<string, unknown>>(MEMORY_HISTORY_TABLE, {
             memoryId: ensureRecordId(loser.id, TABLES.MEMORY),
             prevValue: loser.content,
             event: 'DELETE',
-          }),
-        )
+          })
+          .pipe(Effect.mapError((cause) => toMemoryConsolidationError('write-history', cause)))
 
         archived.add(loser.id)
         mergeCount++
@@ -224,8 +220,8 @@ function deduplicateScopeEffect(scopeId: string) {
 
 function pruneStaleMemoriesEffect() {
   return Effect.gen(function* () {
-    const stale = yield* tryMemoryConsolidationEffect('load-stale', () =>
-      db().query<{ id: RecordIdInput }>(
+    const stale = yield* db()
+      .query<{ id: RecordIdInput }>(
         new BoundQuery(
           `SELECT id FROM ${MEMORY_TABLE}
            WHERE accessCount = 0
@@ -234,15 +230,15 @@ function pruneStaleMemoriesEffect() {
              AND importance < 0.5
              LIMIT 200`,
         ),
-      ),
-    )
+      )
+      .pipe(Effect.mapError((cause) => toMemoryConsolidationError('load-stale', cause)))
 
     if (stale.length === 0) return 0
 
     const staleIds = stale.map((row) => ensureRecordId(row.id, TABLES.MEMORY))
-    yield* tryMemoryConsolidationEffect('update-stale', () =>
-      db().updateWhere(MEMORY_TABLE, inside('id', staleIds), { archivedAt: nowDate() }),
-    )
+    yield* db()
+      .updateWhere(MEMORY_TABLE, inside('id', staleIds), { archivedAt: nowDate() })
+      .pipe(Effect.mapError((cause) => toMemoryConsolidationError('update-stale', cause)))
 
     return stale.length
   })
@@ -250,8 +246,8 @@ function pruneStaleMemoriesEffect() {
 
 function collapseSupersededChainEffect() {
   return Effect.gen(function* () {
-    const middleNodes = yield* tryMemoryConsolidationEffect('load-middle-nodes', () =>
-      db().query<{ middleId: RecordIdInput; predecessors: RecordIdInput[]; successors: RecordIdInput[] }>(
+    const middleNodes = yield* db()
+      .query<{ middleId: RecordIdInput; predecessors: RecordIdInput[]; successors: RecordIdInput[] }>(
         new BoundQuery(
           `SELECT
              id AS middleId,
@@ -263,8 +259,8 @@ function collapseSupersededChainEffect() {
              AND count(<-${MEMORY_RELATION_TABLE}[WHERE relationType = '${RELATION_SUPERSEDES}']) > 0
              LIMIT ${MEMORY.MAX_KNN_LIMIT}`,
         ),
-      ),
-    )
+      )
+      .pipe(Effect.mapError((cause) => toMemoryConsolidationError('load-middle-nodes', cause)))
 
     let collapsed = 0
 
@@ -273,33 +269,28 @@ function collapseSupersededChainEffect() {
         for (const succId of node.successors) {
           const predRef = ensureRecordId(predId, TABLES.MEMORY)
           const succRef = ensureRecordId(succId, TABLES.MEMORY)
-          const existing = yield* tryMemoryConsolidationEffect('read-existing-relation', () =>
-            db().query<{ id: RecordIdInput }>(
+          const existing = yield* db()
+            .query<{ id: RecordIdInput }>(
               new BoundQuery(
                 `SELECT id FROM ${MEMORY_RELATION_TABLE}
                  WHERE in = $predId AND out = $succId AND relationType = '${RELATION_SUPERSEDES}'
                  LIMIT 1`,
                 { predId: predRef, succId: succRef },
               ),
-            ),
-          )
+            )
+            .pipe(Effect.mapError((cause) => toMemoryConsolidationError('read-existing-relation', cause)))
 
           if (existing.length === 0) {
-            yield* tryMemoryConsolidationEffect('write-relation', () =>
-              db().relate(predRef, MEMORY_RELATION_TABLE, succRef, {
-                relationType: RELATION_SUPERSEDES,
-                confidence: 1.0,
-              }),
-            )
+            yield* db()
+              .relate(predRef, MEMORY_RELATION_TABLE, succRef, { relationType: RELATION_SUPERSEDES, confidence: 1.0 })
+              .pipe(Effect.mapError((cause) => toMemoryConsolidationError('write-relation', cause)))
           }
         }
       }
 
-      yield* tryMemoryConsolidationEffect('update-middle-node', () =>
-        db().updateWhere(MEMORY_TABLE, eq('id', ensureRecordId(node.middleId, TABLES.MEMORY)), {
-          archivedAt: nowDate(),
-        }),
-      )
+      yield* db()
+        .updateWhere(MEMORY_TABLE, eq('id', ensureRecordId(node.middleId, TABLES.MEMORY)), { archivedAt: nowDate() })
+        .pipe(Effect.mapError((cause) => toMemoryConsolidationError('update-middle-node', cause)))
 
       collapsed++
     }
@@ -311,8 +302,8 @@ function collapseSupersededChainEffect() {
 function decayImportanceEffect() {
   return Effect.gen(function* () {
     const [standardResult, ephemeralResult] = yield* Effect.all([
-      tryMemoryConsolidationEffect('decay-standard', () =>
-        db().query<{ count: number }>(
+      db()
+        .query<{ count: number }>(
           new BoundQuery(
             `UPDATE ${MEMORY_TABLE}
              SET importance = math::max([0.1, importance * 0.95])
@@ -323,10 +314,10 @@ function decayImportanceEffect() {
                AND (durability = 'standard' OR durability IS NONE)
                RETURN count() AS count`,
           ),
-        ),
-      ),
-      tryMemoryConsolidationEffect('decay-ephemeral', () =>
-        db().query<{ count: number }>(
+        )
+        .pipe(Effect.mapError((cause) => toMemoryConsolidationError('decay-standard', cause))),
+      db()
+        .query<{ count: number }>(
           new BoundQuery(
             `UPDATE ${MEMORY_TABLE}
              SET importance = math::max([0.1, importance * 0.85])
@@ -337,8 +328,8 @@ function decayImportanceEffect() {
                AND durability = 'ephemeral'
                RETURN count() AS count`,
           ),
-        ),
-      ),
+        )
+        .pipe(Effect.mapError((cause) => toMemoryConsolidationError('decay-ephemeral', cause))),
     ])
 
     return (standardResult[0]?.count ?? 0) + (ephemeralResult[0]?.count ?? 0)
@@ -347,15 +338,15 @@ function decayImportanceEffect() {
 
 function cleanupOrphanedRelationsEffect() {
   return Effect.gen(function* () {
-    const result = yield* tryMemoryConsolidationEffect('cleanup-relations', () =>
-      db().query<{ count: number }>(
+    const result = yield* db()
+      .query<{ count: number }>(
         new BoundQuery(
           `DELETE ${MEMORY_RELATION_TABLE}
            WHERE in.archivedAt IS NOT NONE OR out.archivedAt IS NOT NONE
            RETURN count() AS count`,
         ),
-      ),
-    )
+      )
+      .pipe(Effect.mapError((cause) => toMemoryConsolidationError('cleanup-relations', cause)))
     return result[0]?.count ?? 0
   })
 }
@@ -369,11 +360,11 @@ const handler = (job: SandboxedJob<MemoryConsolidationJob>) =>
       if (targetScope) {
         totalMerged = yield* deduplicateScopeEffect(targetScope)
       } else {
-        const scopeIds = yield* tryMemoryConsolidationEffect('load-scope-ids', () =>
-          db().query<string>(
+        const scopeIds = yield* db()
+          .query<string>(
             new BoundQuery(`SELECT VALUE scopeId FROM ${MEMORY_TABLE} WHERE archivedAt IS NONE GROUP BY scopeId`),
-          ),
-        )
+          )
+          .pipe(Effect.mapError((cause) => toMemoryConsolidationError('load-scope-ids', cause)))
 
         const results = yield* Effect.forEach(scopeIds, deduplicateScopeEffect, { concurrency: 2 })
         totalMerged = results.reduce((a, b) => a + b, 0)

package/src/workers/organization-learning.worker.ts

@@ -1,9 +1,9 @@
 import type { SandboxedJob } from 'bullmq'
-import { Effect } from 'effect'
+import { Cause, Effect } from 'effect'
 import type { Context } from 'effect'
 
+import { AiGatewayModelsTag } from '../ai-gateway/ai-gateway'
 import { serverLogger } from '../config/logger'
-import { effectTryPromise } from '../effect/helpers'
 import {
   AgentConfigServiceTag,
   DatabaseServiceTag,
@@ -27,9 +27,11 @@ import { createTracedWorkerProcessor } from './worker-utils'
 const runtime = await initializeSandboxedWorkerRuntime()
 const resolve = <I, T>(tag: Context.Key<I, T>): Promise<T> => runtime.runPromise(Effect.service(tag))
 const agentConfig = await resolve(AgentConfigServiceTag)
+const aiGatewayModels = await resolve(AiGatewayModelsTag)
 const queues = await resolve(LotaQueuesServiceTag)
 const regularChatDigestServices: RegularChatDigestServices = {
   agentConfig,
+  aiGatewayModels,
   databaseService: await resolve(DatabaseServiceTag),
   memoryService: await resolve(MemoryServiceTag),
   socialChatHistoryService: await resolve(SocialChatHistoryServiceTag),
@@ -39,12 +41,14 @@ const regularChatDigestServices: RegularChatDigestServices = {
 const workerRuntimeConfig = await resolve(RuntimeConfigServiceTag)
 const skillExtractionServices: SkillExtractionServices = {
   agentConfig,
+  aiGatewayModels,
   databaseService: await resolve(DatabaseServiceTag),
   learnedSkillService: await resolve(LearnedSkillServiceTag),
   socialChatHistoryService: await resolve(SocialChatHistoryServiceTag),
   runtimeAdapters: await resolve(RuntimeAdaptersServiceTag),
   embeddingModel: workerRuntimeConfig.aiGateway.embeddingModel,
   openRouterApiKey: workerRuntimeConfig.aiGateway.openRouterApiKey,
+  runPromise: (effect) => runtime.runPromise(effect),
 }
 const organizationLearningQueueJobService = await resolve(QueueJobServiceTag)
 
@@ -55,11 +59,17 @@ const handler = (job: SandboxedJob<OrganizationLearningJob>) =>
     Effect.gen(function* () {
       if (job.data.kind === 'regular-chat-memory-digest') {
         const digestJob = job.data
-        return yield* effectTryPromise(() => runRegularChatMemoryDigest(digestJob, regularChatDigestServices))
+        return yield* Effect.tryPromise({
+          try: () => runRegularChatMemoryDigest(digestJob, regularChatDigestServices),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
       }
 
       const skillJob = job.data
-      return yield* effectTryPromise(() => runSkillExtraction(skillJob, skillExtractionServices))
+      return yield* Effect.tryPromise({
+        try: () => runSkillExtraction(skillJob, skillExtractionServices),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
     }).pipe(
       Effect.catch((error) =>
         Effect.gen(function* () {

package/src/workers/regular-chat-memory-digest.runner.ts

@@ -1,8 +1,9 @@
-import { Effect, Schema } from 'effect'
+import { Cause, Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 import { BoundQuery } from 'surrealdb'
 import { z } from 'zod'
 
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { isAgentName } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
@@ -10,7 +11,7 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdRef } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { effectTryPromise } from '../effect/helpers'
+import { ERROR_TAGS } from '../effect/errors'
 import type {
   OrganizationLearningQueueRuntime,
   RegularChatMemoryDigestJob,
@@ -19,7 +20,7 @@ import { createHelperModelRuntime } from '../runtime/helper-model'
 import type { LotaRuntimeAdapters, LotaRuntimeBackgroundCursor } from '../runtime/runtime-extensions'
 import type { MemoryServiceTag } from '../services/memory/memory.service'
 import type { SocialChatHistoryServiceTag } from '../services/social-chat-history.service'
-import { createRegularChatMemoryDigestAgent } from '../system-agents/regular-chat-memory-digest.agent'
+import { makeRegularChatMemoryDigestAgentFactory } from '../system-agents/regular-chat-memory-digest.agent'
 import { nowIsoDateTimeString } from '../utils/date-time'
 import { compactWhitespace } from '../utils/string'
 import { buildDigestTranscript, resolveWorkspaceBootstrapCutoff } from './regular-chat-memory-digest.helpers'
@@ -35,8 +36,9 @@ import type { DigestMessage } from './utils/thread-message-query'
 // runner handles the regular-chat path after onboarding so longer transcripts
 // can be digested into durable memory and profile projections in the background.
 const StructuredProfilePatchSchema = z.record(z.string(), z.unknown()).default({})
+const encodeJsonString = Schema.encodeSync(Schema.fromJsonString(Schema.Json))
 
-class MemoryDigestError extends Schema.TaggedErrorClass<MemoryDigestError>()('MemoryDigestError', {
+class MemoryDigestError extends Schema.TaggedErrorClass<MemoryDigestError>()(ERROR_TAGS.MemoryDigestError, {
   message: Schema.String,
   cause: Schema.Defect,
 }) {}
@@ -45,6 +47,7 @@ const REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS = 10 * 60 * 1000
 const WorkspaceMemoryRowSchema = z.object({ content: z.string() })
 export interface RegularChatDigestServices {
   agentConfig: ResolvedAgentConfig
+  aiGatewayModels: AiGatewayModels
   databaseService: SurrealDBService
   memoryService: Context.Service.Shape<typeof MemoryServiceTag>
   socialChatHistoryService: Context.Service.Shape<typeof SocialChatHistoryServiceTag>
@@ -156,7 +159,9 @@ function hasNewEligibleThreadMessages(params: {
           : null
 
       if (!query) return false
-      const rows = yield* effectTryPromise(() => params.db.query<unknown>(query))
+      const rows = yield* params.db
+        .query<unknown>(query)
+        .pipe(Effect.mapError((cause) => new Cause.UnknownError(cause)))
       return rows.length > 0
     }),
   )
@@ -164,20 +169,20 @@ function hasNewEligibleThreadMessages(params: {
 
 function loadExistingOrganizationMemories(db: SurrealDBService, orgId: string): Promise<Array<{ content: string }>> {
   return Effect.runPromise(
-    effectTryPromise(() =>
-      db.queryMany(
+    db
+      .queryMany(
         new BoundQuery(
           `SELECT content, createdAt, id FROM ${TABLES.MEMORY}
-           WHERE metadata.orgId = $orgId
-             AND archivedAt IS NONE
-             AND (validUntil IS NONE OR validUntil > time::now())
-           ORDER BY createdAt DESC, id DESC
-          LIMIT 250`,
+         WHERE metadata.orgId = $orgId
+           AND archivedAt IS NONE
+           AND (validUntil IS NONE OR validUntil > time::now())
+         ORDER BY createdAt DESC, id DESC
+        LIMIT 250`,
           { orgId },
         ),
         WorkspaceMemoryRowSchema,
-      ),
-    ),
+      )
+      .pipe(Effect.mapError((cause) => new Cause.UnknownError(cause))),
   )
 }
 
@@ -196,33 +201,50 @@ function runRegularChatMemoryDigestEffect(
       return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
 
-    const workspace = yield* effectTryPromise(() => workspaceProvider.getWorkspace(orgRef))
+    const workspace = yield* Effect.tryPromise({
+      try: () => workspaceProvider.getWorkspace(orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const lifecycleState = workspaceProvider.getLifecycleState
-      ? yield* effectTryPromise(() => Promise.resolve(workspaceProvider.getLifecycleState?.(workspace)))
+      ? yield* Effect.tryPromise({
+          try: () => Promise.resolve(workspaceProvider.getLifecycleState?.(workspace)),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
       : undefined
     if (lifecycleState?.bootstrapActive ?? false) {
       serverLogger.info`Skipping regular chat memory digest for ${orgId}: onboarding is not completed`
       return { skipped: true, processedThreadMessages: 0, processedSocialMessages: 0, followUpScheduled: false }
     }
     const projectionState = workspaceProvider.readProfileProjectionState
-      ? yield* effectTryPromise(() => Promise.resolve(workspaceProvider.readProfileProjectionState?.(workspace)))
+      ? yield* Effect.tryPromise({
+          try: () => Promise.resolve(workspaceProvider.readProfileProjectionState?.(workspace)),
+          catch: (cause) => new Cause.UnknownError(cause),
+        })
       : undefined
 
-    const existingThreadCursor = yield* effectTryPromise(() => getBackgroundCursor('regular-chat-digest', orgRef))
+    const existingThreadCursor = yield* Effect.tryPromise({
+      try: () => getBackgroundCursor('regular-chat-digest', orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const threadOnboardingCutoff = resolveWorkspaceBootstrapCutoff({
       hasExistingCursor: existingThreadCursor !== null,
       bootstrapCompletedAt: lifecycleState?.bootstrapCompletedAt,
     })
 
-    const threadIds = yield* effectTryPromise(() => listThreadIdsForOrg(services.databaseService, orgRef))
-    const threadMessages = yield* effectTryPromise(() =>
-      listEligibleThreadMessages({
-        db: services.databaseService,
-        threadIds,
-        cursor: existingThreadCursor,
-        onboardingCutoff: threadOnboardingCutoff,
-      }),
-    )
+    const threadIds = yield* Effect.tryPromise({
+      try: () => listThreadIdsForOrg(services.databaseService, orgRef),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
+    const threadMessages = yield* Effect.tryPromise({
+      try: () =>
+        listEligibleThreadMessages({
+          db: services.databaseService,
+          threadIds,
+          cursor: existingThreadCursor,
+          onboardingCutoff: threadOnboardingCutoff,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const existingSocialCursor = yield* services.socialChatHistoryService.getBackgroundCursor(
       'regular-chat-digest',
       orgId,
@@ -247,30 +269,36 @@ function runRegularChatMemoryDigestEffect(
       messages: combinedMessages,
       isKnownAgentName: (value: string) => isAgentName(services.agentConfig, value),
     })
-    const existingMemories = yield* effectTryPromise(() =>
-      loadExistingOrganizationMemories(services.databaseService, orgId),
-    )
-
-    const synthesis = yield* effectTryPromise(() =>
-      helperModelRuntime.generateHelperStructured({
-        tag: 'regular-chat-memory-digest',
-        createAgent: createRegularChatMemoryDigestAgent,
-        timeoutMs: REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS,
-        messages: [
-          {
-            role: 'user',
-            content: buildPrompt({
-              workspaceName: projectionState?.workspaceName || 'Workspace',
-              currentSummaryBlock: projectionState?.summaryBlock ?? '',
-              currentStructuredProfile: JSON.stringify(projectionState?.structuredProfile ?? {}, null, 2),
-              existingMemories: buildMemoryContext(existingMemories),
-              transcript,
-            }),
-          },
-        ],
-        schema: RegularChatMemoryDigestOutputSchema,
-      }),
-    )
+    const existingMemories = yield* Effect.tryPromise({
+      try: () => loadExistingOrganizationMemories(services.databaseService, orgId),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
+    const currentStructuredProfile = yield* Schema.decodeUnknownEffect(Schema.Json)(
+      projectionState?.structuredProfile ?? {},
+    ).pipe(Effect.mapError((cause) => new Cause.UnknownError(cause)))
+
+    const synthesis = yield* Effect.tryPromise({
+      try: () =>
+        helperModelRuntime.generateHelperStructured({
+          tag: 'regular-chat-memory-digest',
+          createAgent: makeRegularChatMemoryDigestAgentFactory(services.aiGatewayModels),
+          timeoutMs: REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS,
+          messages: [
+            {
+              role: 'user',
+              content: buildPrompt({
+                workspaceName: projectionState?.workspaceName || 'Workspace',
+                currentSummaryBlock: projectionState?.summaryBlock ?? '',
+                currentStructuredProfile: encodeJsonString(currentStructuredProfile),
+                existingMemories: buildMemoryContext(existingMemories),
+                transcript,
+              }),
+            },
+          ],
+          schema: RegularChatMemoryDigestOutputSchema,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
 
     const summaryBlock = normalizeBlock(synthesis.summaryBlock)
     if (!summaryBlock) {
@@ -309,25 +337,31 @@ function runRegularChatMemoryDigestEffect(
       })
     }
 
-    yield* effectTryPromise(() =>
-      applyProfileProjection(orgRef, { summaryBlock, structuredPatch: synthesis.structuredProfilePatch }),
-    )
+    yield* Effect.tryPromise({
+      try: () => applyProfileProjection(orgRef, { summaryBlock, structuredPatch: synthesis.structuredProfilePatch }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     if (processedThreadCursor) {
-      yield* effectTryPromise(() => setBackgroundCursor('regular-chat-digest', orgRef, processedThreadCursor))
+      yield* Effect.tryPromise({
+        try: () => setBackgroundCursor('regular-chat-digest', orgRef, processedThreadCursor),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
     }
     if (processedSocialCursor) {
       yield* services.socialChatHistoryService.setBackgroundCursor('regular-chat-digest', orgId, processedSocialCursor)
     }
 
     const threadBoundaryCursor = processedThreadCursor ?? existingThreadCursor
-    const hasMoreThreadMessages = yield* effectTryPromise(() =>
-      hasNewEligibleThreadMessages({
-        db: services.databaseService,
-        threadIds,
-        cursor: threadBoundaryCursor,
-        onboardingCutoff: threadBoundaryCursor ? null : threadOnboardingCutoff,
-      }),
-    )
+    const hasMoreThreadMessages = yield* Effect.tryPromise({
+      try: () =>
+        hasNewEligibleThreadMessages({
+          db: services.databaseService,
+          threadIds,
+          cursor: threadBoundaryCursor,
+          onboardingCutoff: threadBoundaryCursor ? null : threadOnboardingCutoff,
+        }),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
     const socialBoundaryCursor = processedSocialCursor ?? existingSocialCursor
     const hasMoreSocialMessages = yield* services.socialChatHistoryService.hasWorkspaceMessages({
       workspaceId: orgId,
@@ -337,10 +371,14 @@ function runRegularChatMemoryDigestEffect(
 
     const followUpScheduled = hasMoreThreadMessages || hasMoreSocialMessages
     if (followUpScheduled) {
-      yield* effectTryPromise(() =>
-        services.organizationLearningQueue.clearRegularChatMemoryDigestDeduplicationKey(orgId),
-      )
-      yield* effectTryPromise(() => services.organizationLearningQueue.enqueueRegularChatMemoryDigest({ orgId }))
+      yield* Effect.tryPromise({
+        try: () => services.organizationLearningQueue.clearRegularChatMemoryDigestDeduplicationKey(orgId),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
+      yield* Effect.tryPromise({
+        try: () => services.organizationLearningQueue.enqueueRegularChatMemoryDigest({ orgId }),
+        catch: (cause) => new Cause.UnknownError(cause),
+      })
     }
 
     serverLogger.info`Regular chat memory digest completed for ${orgId}: threadMessages=${threadMessages.length}, socialMessages=${socialMessages.length}, facts=${synthesis.facts.length}, followUpScheduled=${followUpScheduled}`