@lota-sdk/core 0.4.8 → 0.4.9

package/src/services/graph-full-routing.ts

@@ -0,0 +1,182 @@
+import type {
+  ExecutionMode,
+  PlanFailureClass,
+  PlanNodeResultSubmission,
+  PlanNodeRunRecord,
+  PlanNodeSpecRecord,
+  PlanRunRecord,
+  PlanSpecRecord,
+} from '@lota-sdk/shared'
+import { Effect } from 'effect'
+
+import { serverLogger } from '../config/logger'
+import { recordIdToString } from '../db/record-id'
+import { TABLES } from '../db/tables'
+import { BadRequestError } from '../effect/errors'
+import { shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibility'
+import type { makePlanExecutorService } from './plan/plan-executor.service'
+import type { makePlanRunService } from './plan/plan-run.service'
+
+function classifyDispatchFailure(ownerType: string, error: unknown): PlanFailureClass {
+  const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase()
+  if (errorMessage.includes('timeout')) return 'timeout_exceeded'
+  if (ownerType === 'plugin' || ownerType === 'system') return 'external_system_unavailable'
+  return 'non_recoverable_logic_error'
+}
+
+function formatDispatchError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+const STABLE_RUN_STATUSES = new Set(['pending-approval', 'awaiting-human', 'blocked', 'failed', 'completed', 'aborted'])
+
+interface GraphFullRoutingDeps {
+  dispatchReadyNode(params: {
+    run: PlanRunRecord
+    nodeSpecRecord: PlanNodeSpecRecord
+    nodeRun: PlanNodeRunRecord
+    spec: PlanSpecRecord
+    executionModeOverride?: ExecutionMode
+  }): Effect.Effect<PlanNodeResultSubmission, unknown>
+  planExecutorService: ReturnType<typeof makePlanExecutorService>
+  planRunService: ReturnType<typeof makePlanRunService>
+}
+
+export function routeGraphFullEffect(params: { threadId: string; runId: string }, deps: GraphFullRoutingDeps) {
+  return Effect.gen(function* () {
+    const MAX_ROUNDS = 32
+    const STRUCTURAL_TYPES = new Set(['switch', 'join', 'deliberation-fork'])
+
+    let round = 0
+    for (; round < MAX_ROUNDS; round++) {
+      const run = yield* deps.planRunService.getRunById(params.runId)
+      if (STABLE_RUN_STATUSES.has(run.status)) break
+
+      const spec = yield* deps.planRunService.getPlanSpecById(run.planSpecId)
+      const nodeSpecs = yield* deps.planRunService.listNodeSpecs(spec.id)
+      const nodeRuns = yield* deps.planRunService.listNodeRuns(run.id)
+
+      const readyNodes = nodeRuns.filter((nr: PlanNodeRunRecord) => {
+        if (nr.status !== 'ready') return false
+        const ns = nodeSpecs.find((s: PlanNodeSpecRecord) => s.nodeId === nr.nodeId)
+        return ns && ns.owner.executorType !== 'user' && !STRUCTURAL_TYPES.has(ns.type)
+      })
+      if (readyNodes.length === 0) break
+
+      const silentNodes = readyNodes.filter((nr: PlanNodeRunRecord) => {
+        const ns = nodeSpecs.find((s: PlanNodeSpecRecord) => s.nodeId === nr.nodeId)
+        return ns && !shouldPlanNodeUseVisibleTurn(spec, ns)
+      })
+      const visibleNodes = readyNodes.filter((nr: PlanNodeRunRecord) => {
+        const ns = nodeSpecs.find((s: PlanNodeSpecRecord) => s.nodeId === nr.nodeId)
+        return ns && shouldPlanNodeUseVisibleTurn(spec, ns)
+      })
+
+      yield* Effect.forEach(
+        readyNodes,
+        (nodeRun) =>
+          Effect.tryPromise(() =>
+            deps.planExecutorService.transitionNodeToRunning({ runId: params.runId, nodeId: nodeRun.nodeId }),
+          ),
+        { concurrency: 'unbounded' },
+      )
+
+      if (visibleNodes.length > 0) {
+        const { enqueuePlanAgentHeartbeatWake } = yield* Effect.tryPromise(
+          () => import('../queues/plan-agent-heartbeat.queue'),
+        )
+        const updatedRunForWake = yield* deps.planRunService.getRunById(params.runId)
+        yield* Effect.forEach(
+          visibleNodes,
+          (nodeRun) =>
+            Effect.gen(function* () {
+              const ns = nodeSpecs.find((s: PlanNodeSpecRecord) => s.nodeId === nodeRun.nodeId)
+              if (!ns || ns.owner.executorType !== 'agent') {
+                return
+              }
+
+              yield* Effect.tryPromise(() =>
+                enqueuePlanAgentHeartbeatWake({
+                  organizationId: recordIdToString(updatedRunForWake.organizationId, TABLES.ORGANIZATION),
+                  threadId: recordIdToString(updatedRunForWake.threadId, TABLES.THREAD),
+                  runId: recordIdToString(updatedRunForWake.id, TABLES.PLAN_RUN),
+                  nodeId: nodeRun.nodeId,
+                  agentId: ns.owner.ref,
+                  reason: 'graph-full-visible',
+                }),
+              )
+            }),
+          { concurrency: 'unbounded' },
+        )
+      }
+
+      if (silentNodes.length === 0) break
+
+      const updatedRun = yield* deps.planRunService.getRunById(params.runId)
+
+      const results = yield* Effect.forEach(
+        silentNodes,
+        (nodeRun) =>
+          Effect.matchEffect(
+            Effect.gen(function* () {
+              const nodeSpecRecord = nodeSpecs.find((ns: PlanNodeSpecRecord) => ns.nodeId === nodeRun.nodeId)
+              if (!nodeSpecRecord) {
+                return yield* new BadRequestError({ message: `Node spec not found for node "${nodeRun.nodeId}".` })
+              }
+              const updatedNodeRun = yield* deps.planRunService.getNodeRunByNodeId(updatedRun.id, nodeRun.nodeId)
+              const result = yield* deps.dispatchReadyNode({
+                run: updatedRun,
+                nodeSpecRecord,
+                nodeRun: updatedNodeRun,
+                spec,
+                executionModeOverride: 'linear',
+              })
+              return { nodeId: nodeRun.nodeId, ownerRef: nodeSpecRecord.owner.ref, result }
+            }),
+            {
+              onFailure: (reason: unknown) => Effect.succeed({ status: 'rejected' as const, reason }),
+              onSuccess: (value) => Effect.succeed({ status: 'fulfilled' as const, value }),
+            },
+          ),
+        { concurrency: 'unbounded' },
+      )
+
+      const threadId = recordIdToString(updatedRun.threadId, TABLES.THREAD)
+      const runId = recordIdToString(updatedRun.id, TABLES.PLAN_RUN)
+
+      for (let i = 0; i < results.length; i++) {
+        const settled = results[i]
+        const nodeRun = silentNodes[i]
+        const nodeSpecRecord = nodeSpecs.find((ns) => ns.nodeId === nodeRun.nodeId)
+
+        if (settled.status === 'fulfilled') {
+          yield* Effect.tryPromise(() =>
+            deps.planExecutorService.submitNodeResult({
+              threadId,
+              runId,
+              nodeId: settled.value.nodeId,
+              emittedBy: settled.value.ownerRef,
+              result: settled.value.result,
+            }),
+          )
+        } else {
+          serverLogger.warn`routeGraphFull: dispatch failed for node "${nodeRun.nodeId}": ${settled.reason}`
+          yield* Effect.tryPromise(() =>
+            deps.planExecutorService.blockNodeOnDispatchFailure({
+              threadId,
+              runId,
+              nodeId: nodeRun.nodeId,
+              emittedBy: nodeSpecRecord?.owner.ref ?? 'unknown',
+              message: formatDispatchError(settled.reason),
+              failureClass: classifyDispatchFailure(nodeSpecRecord?.owner.executorType ?? 'agent', settled.reason),
+            }),
+          )
+        }
+      }
+    }
+
+    if (round === MAX_ROUNDS - 1) {
+      serverLogger.warn`graph-full execution reached max rounds (${MAX_ROUNDS}) for run ${params.runId} — possible non-converging graph`
+    }
+  })
+}

package/src/services/index.ts

@@ -1,32 +1,30 @@
-export * from './adaptive-playbook.service'
 export * from './agent-executor.service'
 export * from './agent-activity.service'
 export * from './artifact.service'
-export * from './artifact-provenance.service'
 export * from './attachment.service'
 export * from './autonomous-job.service'
 export * from './document-chunk.service'
-export * from './execution-plan.service'
+export * from './execution-plan/execution-plan.service'
 export * from './institutional-memory.service'
 export * from './feedback-loop.service'
 export * from './global-orchestrator.service'
-export * from './memory.service'
+export * from './memory/memory.service'
 export * from './node-workspace.service'
 export * from './notification.service'
 export * from './ownership-dispatcher.service'
 export * from './organization-member.service'
 export * from './organization.service'
-export * from './rerank.service'
-export * from './plan-coordination.service'
-export * from './plan-cycle.service'
-export * from './plan-deadline.service'
-export * from './plan-agent-query.service'
-export * from './plan-agent-heartbeat.service'
-export * from './plan-event-delivery.service'
-export * from './plan-workspace.service'
-export * from './plan-run.service'
-export * from './plan-scheduler.service'
-export * from './plan-template.service'
+export * from './memory/rerank.service'
+export * from './plan/plan-coordination.service'
+export * from './plan/plan-cycle.service'
+export * from './plan/plan-deadline.service'
+export * from './plan/plan-agent-query.service'
+export * from './plan/plan-agent-heartbeat.service'
+export * from './plan/plan-event-delivery.service'
+export * from './plan/plan-workspace.service'
+export * from './plan/plan-run.service'
+export * from './plan/plan-scheduler.service'
+export * from './plan/plan-template.service'
 export * from './quality-metrics.service'
 export * from './queue-job.service'
 export * from './monitoring-window.service'
@@ -37,10 +35,9 @@ export * from './skill-resolver.service'
 export * from './social-chat-history.service'
 export * from './system-executor.service'
 export * from './user.service'
-export * from './thread-message.service'
-export * from './thread.types'
-export * from './thread-title.service'
-export * from './thread-turn'
-export * from './thread-plan-registry.service'
-export * from './thread.service'
+export * from './thread/thread-message.service'
+export * from './thread/thread.types'
+export * from './thread/thread-title.service'
+export * from './thread/thread-turn'
+export * from './thread/thread.service'
 export * from './write-intent-validator.service'

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

@@ -1,145 +1,242 @@
-import type { InstitutionalMemory, InstitutionalMemoryType } from '@lota-sdk/shared'
+import type {
+  InstitutionalMemory,
+  InstitutionalMemoryType,
+  PlanNodeRunRecord,
+  PlanNodeSpecRecord,
+} from '@lota-sdk/shared'
 import { InstitutionalMemorySchema } from '@lota-sdk/shared'
+import { Context, Schema, Effect, Layer } from 'effect'
 import { BoundQuery } from 'surrealdb'
 
 import { ensureRecordId } from '../db/record-id'
-import { databaseService } from '../db/service'
+import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
+import { DatabaseServiceTag } from '../effect/services'
+import { unsafeDateFrom } from '../utils/date-time'
+import type { makePlanRunService } from './plan/plan-run.service'
+import { PlanRunServiceTag } from './plan/plan-run.service'
+
+interface InstitutionalMemoryDeps {
+  db: SurrealDBService
+  planRunService: ReturnType<typeof makePlanRunService>
+}
 
-class InstitutionalMemoryService {
-  async extractPatterns(params: { organizationId: string; runId: string }): Promise<InstitutionalMemory[]> {
-    const { planRunService } = await import('./plan-run.service')
-
-    const run = await planRunService.getRunById(params.runId)
-    const nodeRuns = await planRunService.listNodeRuns(run.id)
-    const nodeSpecs = await planRunService.listNodeSpecs(run.planSpecId)
-    const nodeSpecsByNodeId = new Map(nodeSpecs.map((n) => [n.nodeId, n]))
-
-    const patterns: InstitutionalMemory[] = []
-    const orgRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
-    const ownerRef = (nodeId: string): string => nodeSpecsByNodeId.get(nodeId)?.owner.ref ?? 'unknown'
-
-    const completedNodes = nodeRuns.filter((nr) => nr.status === 'completed' && nr.startedAt && nr.completedAt)
-    if (completedNodes.length > 0) {
-      const timings = completedNodes.map((nr) => ({
-        nodeId: nr.nodeId,
-        owner: ownerRef(nr.nodeId),
-        durationMs: new Date(nr.completedAt ?? 0).getTime() - new Date(nr.startedAt ?? 0).getTime(),
-      }))
-
-      const record = await this.persistPattern({
-        organizationId: orgRef,
-        type: 'timing-pattern',
-        pattern: { runId: params.runId, timings },
-        confidence: 0.7,
-        sampleCount: completedNodes.length,
-      })
-      patterns.push(record)
-    }
-
-    const failedNodes = nodeRuns.filter((nr) => nr.status === 'failed')
-    if (failedNodes.length > 0) {
-      const failures = failedNodes.map((nr) => ({
-        nodeId: nr.nodeId,
-        owner: ownerRef(nr.nodeId),
-        attemptCount: nr.attemptCount,
-      }))
-
-      const record = await this.persistPattern({
-        organizationId: orgRef,
-        type: 'failure-pattern',
-        pattern: { runId: params.runId, failures },
-        confidence: 0.6,
-        sampleCount: failedNodes.length,
+class InstitutionalMemoryServiceError extends Schema.TaggedErrorClass<InstitutionalMemoryServiceError>()(
+  'InstitutionalMemoryServiceError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
+
+function tryInstitutionalMemoryPromise<A>(
+  message: string,
+  thunk: () => PromiseLike<A> | Effect.Effect<A, unknown>,
+): Effect.Effect<A, InstitutionalMemoryServiceError> {
+  return Effect.suspend(() => {
+    try {
+      const value = thunk()
+      if (Effect.isEffect(value)) {
+        return value.pipe(Effect.mapError((cause) => new InstitutionalMemoryServiceError({ message, cause })))
+      }
+
+      return Effect.tryPromise({
+        try: () => Promise.resolve(value),
+        catch: (cause) => new InstitutionalMemoryServiceError({ message, cause }),
       })
-      patterns.push(record)
-    }
-
-    const agentCompletions = new Map<string, number>()
-    for (const nr of completedNodes) {
-      const owner = ownerRef(nr.nodeId)
-      agentCompletions.set(owner, (agentCompletions.get(owner) ?? 0) + 1)
-    }
-    if (agentCompletions.size > 0) {
-      const record = await this.persistPattern({
-        organizationId: orgRef,
-        type: 'agent-affinity',
-        pattern: { runId: params.runId, completions: Object.fromEntries(agentCompletions) },
-        confidence: 0.5,
-        sampleCount: completedNodes.length,
-      })
-      patterns.push(record)
+    } catch (cause) {
+      return Effect.fail(new InstitutionalMemoryServiceError({ message, cause }))
     }
+  })
+}
 
-    return patterns
-  }
+export function makeInstitutionalMemoryService(deps: InstitutionalMemoryDeps) {
+  const { db, planRunService } = deps
 
-  async queryRelevant(params: {
-    organizationId: string
-    objective: string
-    limit?: number
-  }): Promise<InstitutionalMemory[]> {
-    const orgRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
-    const limit = params.limit ?? 10
-
-    // Fetch a broader set, then rank by relevance to the objective.
-    // SurrealDB does not support full-text scoring on FLEXIBLE object fields,
-    // so we over-fetch and rank in application code.
-    const fetchLimit = Math.max(limit * 3, 30)
-    const records = await databaseService.queryMany(
-      new BoundQuery(
-        `SELECT * FROM ${TABLES.INSTITUTIONAL_MEMORY}
-         WHERE organizationId = $orgId
-         ORDER BY confidence DESC, createdAt DESC
-         LIMIT $fetchLimit`,
-        { orgId: orgRef, fetchLimit },
+  const persistPatternEffect = (params: {
+    organizationId: ReturnType<typeof ensureRecordId>
+    type: InstitutionalMemoryType
+    pattern: Record<string, unknown>
+    confidence: number
+    sampleCount: number
+  }) =>
+    tryInstitutionalMemoryPromise('Failed to persist institutional memory.', () =>
+      db.create(
+        TABLES.INSTITUTIONAL_MEMORY,
+        {
+          organizationId: params.organizationId,
+          type: params.type,
+          pattern: params.pattern,
+          confidence: params.confidence,
+          sampleCount: params.sampleCount,
+        },
+        InstitutionalMemorySchema,
       ),
-      InstitutionalMemorySchema,
     )
 
-    // Score each record by how many objective keywords appear in its pattern JSON
-    const objectiveTerms = params.objective
-      .toLowerCase()
-      .split(/\s+/)
-      .filter((t) => t.length > 2)
+  const extractPatternsEffect = (params: { organizationId: string; runId: string }) =>
+    Effect.gen(function* () {
+      const run = yield* planRunService
+        .getRunById(params.runId)
+        .pipe(
+          Effect.mapError(
+            (cause) => new InstitutionalMemoryServiceError({ message: `Failed to load run ${params.runId}.`, cause }),
+          ),
+        )
+
+      const [nodeRuns, nodeSpecs] = yield* Effect.all([
+        planRunService
+          .listNodeRuns(run.id)
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new InstitutionalMemoryServiceError({
+                  message: `Failed to load node runs for run ${params.runId}.`,
+                  cause,
+                }),
+            ),
+          ),
+        planRunService
+          .listNodeSpecs(run.planSpecId)
+          .pipe(
+            Effect.mapError(
+              (cause) =>
+                new InstitutionalMemoryServiceError({
+                  message: `Failed to load node specs for run ${params.runId}.`,
+                  cause,
+                }),
+            ),
+          ),
+      ])
+
+      const nodeSpecsByNodeId = new Map<string, PlanNodeSpecRecord>(
+        nodeSpecs.map((nodeSpec) => [nodeSpec.nodeId, nodeSpec]),
+      )
+      const orgRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
+      const ownerRef = (nodeId: string): string => nodeSpecsByNodeId.get(nodeId)?.owner.ref ?? 'unknown'
+      const completedNodes = nodeRuns.filter(
+        (nodeRun: PlanNodeRunRecord) => nodeRun.status === 'completed' && nodeRun.startedAt && nodeRun.completedAt,
+      )
+      const failedNodes = nodeRuns.filter((nodeRun: PlanNodeRunRecord) => nodeRun.status === 'failed')
+      const agentCompletions = new Map<string, number>()
+
+      for (const nodeRun of completedNodes) {
+        const owner = ownerRef(nodeRun.nodeId)
+        agentCompletions.set(owner, (agentCompletions.get(owner) ?? 0) + 1)
+      }
+
+      const persistEffects: Array<Effect.Effect<InstitutionalMemory, InstitutionalMemoryServiceError, never>> = []
+
+      if (completedNodes.length > 0) {
+        const timings = completedNodes.map((nodeRun: PlanNodeRunRecord) => ({
+          nodeId: nodeRun.nodeId,
+          owner: ownerRef(nodeRun.nodeId),
+          durationMs:
+            unsafeDateFrom(nodeRun.completedAt ?? 0).getTime() - unsafeDateFrom(nodeRun.startedAt ?? 0).getTime(),
+        }))
+
+        persistEffects.push(
+          persistPatternEffect({
+            organizationId: orgRef,
+            type: 'timing-pattern',
+            pattern: { runId: params.runId, timings },
+            confidence: 0.7,
+            sampleCount: completedNodes.length,
+          }),
+        )
+      }
+
+      if (failedNodes.length > 0) {
+        const failures = failedNodes.map((nodeRun: PlanNodeRunRecord) => ({
+          nodeId: nodeRun.nodeId,
+          owner: ownerRef(nodeRun.nodeId),
+          attemptCount: nodeRun.attemptCount,
+        }))
+
+        persistEffects.push(
+          persistPatternEffect({
+            organizationId: orgRef,
+            type: 'failure-pattern',
+            pattern: { runId: params.runId, failures },
+            confidence: 0.6,
+            sampleCount: failedNodes.length,
+          }),
+        )
+      }
+
+      if (agentCompletions.size > 0) {
+        persistEffects.push(
+          persistPatternEffect({
+            organizationId: orgRef,
+            type: 'agent-affinity',
+            pattern: { runId: params.runId, completions: Object.fromEntries(agentCompletions) },
+            confidence: 0.5,
+            sampleCount: completedNodes.length,
+          }),
+        )
+      }
+
+      return yield* Effect.all(persistEffects)
+    })
 
-    if (objectiveTerms.length === 0) return records.slice(0, limit)
+  const queryRelevantEffect = (params: { organizationId: string; objective: string; limit?: number }) =>
+    Effect.gen(function* () {
+      const orgRef = ensureRecordId(params.organizationId, TABLES.ORGANIZATION)
+      const limit = params.limit ?? 10
+      const fetchLimit = Math.max(limit * 3, 30)
+      const records = yield* tryInstitutionalMemoryPromise(
+        `Failed to query institutional memory for organization ${params.organizationId}.`,
+        () =>
+          db.queryMany(
+            new BoundQuery(
+              `SELECT * FROM ${TABLES.INSTITUTIONAL_MEMORY}
+           WHERE organizationId = $orgId
+           ORDER BY confidence DESC, createdAt DESC
+           LIMIT $fetchLimit`,
+              { orgId: orgRef, fetchLimit },
+            ),
+            InstitutionalMemorySchema,
+          ),
+      )
+
+      const objectiveTerms = params.objective
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((term) => term.length > 2)
+
+      if (objectiveTerms.length === 0) return records.slice(0, limit)
+
+      const scored = records.map((record) => {
+        const patternStr = JSON.stringify(record.pattern).toLowerCase()
+        const matchCount = objectiveTerms.filter((term) => patternStr.includes(term)).length
+        return { record, relevance: matchCount / objectiveTerms.length }
+      })
 
-    const scored = records.map((record) => {
-      const patternStr = JSON.stringify(record.pattern).toLowerCase()
-      const matchCount = objectiveTerms.filter((term) => patternStr.includes(term)).length
-      return { record, relevance: matchCount / objectiveTerms.length }
-    })
+      scored.sort((a, b) => {
+        if (b.relevance !== a.relevance) return b.relevance - a.relevance
+        if (b.record.confidence !== a.record.confidence) return b.record.confidence - a.record.confidence
+        return 0
+      })
 
-    scored.sort((a, b) => {
-      // Primary: relevance score, secondary: confidence, tertiary: recency
-      if (b.relevance !== a.relevance) return b.relevance - a.relevance
-      if (b.record.confidence !== a.record.confidence) return b.record.confidence - a.record.confidence
-      return 0
+      return scored.slice(0, limit).map((item) => item.record)
     })
 
-    return scored.slice(0, limit).map((s) => s.record)
+  const service = {
+    extractPatterns: (params: { organizationId: string; runId: string }) => extractPatternsEffect(params),
+    queryRelevant: (params: { organizationId: string; objective: string; limit?: number }) =>
+      queryRelevantEffect(params),
   }
 
-  private async persistPattern(params: {
-    organizationId: ReturnType<typeof ensureRecordId>
-    type: InstitutionalMemoryType
-    pattern: Record<string, unknown>
-    confidence: number
-    sampleCount: number
-  }): Promise<InstitutionalMemory> {
-    return databaseService.create(
-      TABLES.INSTITUTIONAL_MEMORY,
-      {
-        organizationId: params.organizationId,
-        type: params.type,
-        pattern: params.pattern,
-        confidence: params.confidence,
-        sampleCount: params.sampleCount,
-      },
-      InstitutionalMemorySchema,
-    )
-  }
+  return service
 }
 
-export const institutionalMemoryService = new InstitutionalMemoryService()
+export class InstitutionalMemoryServiceTag extends Context.Service<
+  InstitutionalMemoryServiceTag,
+  ReturnType<typeof makeInstitutionalMemoryService>
+>()('InstitutionalMemoryService') {}
+
+export const InstitutionalMemoryServiceLive = Layer.effect(
+  InstitutionalMemoryServiceTag,
+  Effect.gen(function* () {
+    const db = yield* DatabaseServiceTag
+    const planRunService = yield* PlanRunServiceTag
+    return makeInstitutionalMemoryService({ db, planRunService })
+  }),
+)