@lota-sdk/core 0.4.10 → 0.4.12

package/src/queues/title-generation.queue.ts

@@ -5,8 +5,10 @@ import type IORedis from 'ioredis'
 
 import { ensureRecordId } from '../db/record-id'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import { QueueJobServiceTag } from '../services/queue-job.service'
 import { RecentActivityTitleServiceTag } from '../services/recent-activity-title.service'
 import { ThreadTitleServiceTag } from '../services/thread/thread-title.service'
+import type { QueueJobService, WorkerHandle } from '../workers/worker-utils'
 import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
@@ -29,13 +31,13 @@ interface RecentActivityTitleRefinementJob {
 
 type TitleGenerationJob = ThreadTitleGenerationJob | RecentActivityTitleRefinementJob
 
-interface TitleGenerationQueueDeps {
+export interface TitleGenerationWorkerDeps {
   databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
   threadTitleService: Context.Service.Shape<typeof ThreadTitleServiceTag>
   recentActivityTitleService: Context.Service.Shape<typeof RecentActivityTitleServiceTag>
 }
 
-function processTitleGenerationJob(deps: TitleGenerationQueueDeps, job: Job<TitleGenerationJob>): Promise<void> {
+function processTitleGenerationJob(deps: TitleGenerationWorkerDeps, job: Job<TitleGenerationJob>): Promise<void> {
   const { threadTitleService, recentActivityTitleService } = deps
   if (job.data.kind === 'thread-title') {
     return Effect.runPromise(
@@ -46,44 +48,53 @@ function processTitleGenerationJob(deps: TitleGenerationQueueDeps, job: Job<Titl
   return Effect.runPromise(Effect.asVoid(recentActivityTitleService.refineRecentActivityTitle(job.data.activityId)))
 }
 
-const titleGeneration = createQueueFactoryWithDeps<TitleGenerationJob, TitleGenerationQueueDeps>({
-  name: TITLE_GENERATION_QUEUE,
-  displayName: 'Title generation',
-  jobName: 'title-generation',
-  concurrency: 10,
-  lockDuration: 300_000,
-  defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
-  prepare: ({ databaseService }) => databaseService.connect(),
-  processor: processTitleGenerationJob,
-})
-
-export function enqueueThreadTitleGeneration(job: Omit<ThreadTitleGenerationJob, 'kind'>) {
-  return titleGeneration.enqueue({ kind: 'thread-title', ...job }, { jobId: `thread-title:${job.threadId}` })
+export interface TitleGenerationQueueRuntime {
+  enqueueThreadTitleGeneration(job: Omit<ThreadTitleGenerationJob, 'kind'>): Promise<void>
+  enqueueRecentActivityTitleRefinement(job: Omit<RecentActivityTitleRefinementJob, 'kind'>): Promise<void>
+  startWorker(options: { registerSignals?: boolean; deps: TitleGenerationWorkerDeps }): WorkerHandle
 }
 
-export function enqueueRecentActivityTitleRefinement(job: Omit<RecentActivityTitleRefinementJob, 'kind'>) {
-  return titleGeneration.enqueue(
-    { kind: 'recent-activity-title', ...job },
-    { jobId: `recent-activity-title:${job.activityId}` },
-  )
+interface MakeTitleGenerationQueueRuntimeParams {
+  connectionProvider: () => IORedis
+  queueJobService: QueueJobService
 }
 
-export function startTitleGenerationWorker(options: {
-  registerSignals?: boolean
-  connectionProvider: () => IORedis
-  deps: TitleGenerationQueueDeps
-}): ReturnType<typeof titleGeneration.startWorker> {
-  return titleGeneration.startWorker({
-    deps: options.deps,
-    registerSignals: options.registerSignals,
-    connectionProvider: options.connectionProvider,
+export function makeTitleGenerationQueueRuntime(
+  params: MakeTitleGenerationQueueRuntimeParams,
+): TitleGenerationQueueRuntime {
+  const { connectionProvider, queueJobService } = params
+
+  const queue = createQueueFactoryWithDeps<TitleGenerationJob, TitleGenerationWorkerDeps>({
+    name: TITLE_GENERATION_QUEUE,
+    displayName: 'Title generation',
+    jobName: 'title-generation',
+    concurrency: 10,
+    lockDuration: 300_000,
+    defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
+    connectionProvider,
+    queueJobService,
+    prepare: ({ databaseService }) => Effect.runPromise(databaseService.connect()),
+    processor: processTitleGenerationJob,
   })
+
+  return {
+    enqueueThreadTitleGeneration: (job) =>
+      queue.enqueue({ kind: 'thread-title', ...job }, { jobId: `thread-title:${job.threadId}` }),
+    enqueueRecentActivityTitleRefinement: (job) =>
+      queue.enqueue({ kind: 'recent-activity-title', ...job }, { jobId: `recent-activity-title:${job.activityId}` }),
+    startWorker: (options) =>
+      queue.startWorker({ deps: options.deps, registerSignals: options.registerSignals, connectionProvider }),
+  }
 }
 
 runStandaloneQueueWorker((runtime) => {
   const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
-  startTitleGenerationWorker({
-    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
+  const redis = resolve(RedisServiceTag)
+  const titleGenerationQueue = makeTitleGenerationQueueRuntime({
+    connectionProvider: () => redis.getConnectionForBullMQ(),
+    queueJobService: resolve(QueueJobServiceTag),
+  })
+  titleGenerationQueue.startWorker({
     deps: {
       databaseService: resolve(DatabaseServiceTag),
       threadTitleService: resolve(ThreadTitleServiceTag),

package/src/redis/org-memory-lock.ts

@@ -1,12 +1,12 @@
 import { Schema, Effect } from 'effect'
-import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
 import { LockAcquisitionError } from '../effect/errors'
 import type { LockLostError, RedisError } from '../effect/errors'
+import { RedisServiceTag } from '../effect/services'
+import type { RedisConnectionManager } from './connection'
 import { withLeaseLock } from './redis-lease-lock'
 import type { RedisLeaseLockOptions } from './redis-lease-lock'
-import { getRuntimeRedisConnection } from './runtime-connection'
 
 const ORG_MEMORY_LOCK_PREFIX = 'lock:org-memory:org:'
 const ORG_MEMORY_LOCK_TTL_MS = 120_000
@@ -20,9 +20,8 @@ class OrgMemoryLockCallbackError extends Schema.TaggedErrorClass<OrgMemoryLockCa
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 
-function createOrgMemoryLockOptions(redis: IORedis, orgId: string): RedisLeaseLockOptions & { redis: IORedis } {
+function createOrgMemoryLockOptions(orgId: string): RedisLeaseLockOptions {
   return {
-    redis,
     lockKey: `${ORG_MEMORY_LOCK_PREFIX}${orgId}`,
     lockTtlMs: ORG_MEMORY_LOCK_TTL_MS,
     retryDelayMs: ORG_MEMORY_LOCK_RETRY_DELAY_MS,
@@ -44,13 +43,28 @@ function createOrgMemoryLockOptions(redis: IORedis, orgId: string): RedisLeaseLo
   }
 }
 
-export function withOrgMemoryLock<T>(orgId: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+/**
+ * Promise-returning wrapper for hosts that live outside Effect.
+ *
+ * Callers must pass in a `RedisConnectionManager` (usually
+ * `runtime.redis.manager`) so the wrapper can build a standalone Redis layer
+ * instead of relying on an ambient managed runtime.
+ */
+export function withOrgMemoryLock<T>(
+  orgId: string,
+  fn: (signal: AbortSignal) => Promise<T>,
+  redisManager: RedisConnectionManager,
+): Promise<T> {
   return Effect.runPromise(
     withOrgMemoryLockEffect(orgId, (signal) =>
       Effect.tryPromise({
         try: () => fn(signal),
         catch: (cause) => new OrgMemoryLockCallbackError({ message: 'Org memory lock callback failed.', cause }),
       }),
+    ).pipe(
+      // Provide the redis service synchronously so the Effect has no residual
+      // requirements; the outer Promise call edge needs `R = never`.
+      Effect.provideService(RedisServiceTag, redisManager),
     ),
   )
 }
@@ -58,7 +72,7 @@ export function withOrgMemoryLock<T>(orgId: string, fn: (signal: AbortSignal) =>
 export function withOrgMemoryLockEffect<A, E>(
   orgId: string,
   fn: (signal: AbortSignal) => Effect.Effect<A, E>,
-): Effect.Effect<A, E | LockAcquisitionError | LockLostError | RedisError> {
+): Effect.Effect<A, E | LockAcquisitionError | LockLostError | RedisError, RedisServiceTag> {
   const normalizedOrgId = orgId.trim()
 
   if (!normalizedOrgId) {
@@ -70,7 +84,8 @@ export function withOrgMemoryLockEffect<A, E>(
     )
   }
 
-  return Effect.sync(() => getRuntimeRedisConnection()).pipe(
-    Effect.flatMap((redis) => withLeaseLock(createOrgMemoryLockOptions(redis, normalizedOrgId), fn)),
-  )
+  return Effect.gen(function* () {
+    const redis = yield* RedisServiceTag
+    return yield* withLeaseLock({ ...createOrgMemoryLockOptions(normalizedOrgId), redis: redis.getConnection() }, fn)
+  })
 }

package/src/redis/redis-lease-lock.ts

@@ -259,9 +259,16 @@ export function withLeaseLock<A, E, R>(
       Effect.ignore,
     )
 
+    // The refresh fiber races the user's effect against a `lockLost` Deferred
+    // so callers can observe Redis-side expirations. We pass the abort signal
+    // to `fn` so it can cooperatively wind down on lost-lock or external stop,
+    // but do NOT interrupt `fn` via `raceFirst` on `lockLost` — aborting a
+    // turn that has already produced tokens would discard the response. The
+    // caller owns the post-lease cleanup; the signal is enough for anyone who
+    // needs to bail out early.
     return yield* Effect.scoped(
       startRefreshFiber(redis, normalized, lockValue, abortController, lockLost).pipe(
-        Effect.andThen(fn(abortController.signal).pipe(Effect.raceFirst(Deferred.await(lockLost)))),
+        Effect.andThen(fn(abortController.signal)),
         Effect.ensuring(cleanup),
       ),
     )

package/src/runtime/agent-identity-overrides.ts

@@ -1,4 +1,4 @@
-import { getAgentDisplayNames } from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { asRecord, readOptionalString } from './thread-chat-helpers'
 
 interface RuntimeAgentIdentityOverrides {
@@ -52,11 +52,15 @@ export function readRuntimeAgentIdentityOverrides(
   }
 }
 
-export function resolveRuntimeAgentDisplayName(overrides: RuntimeAgentIdentityOverrides, agentId: string): string {
+export function resolveRuntimeAgentDisplayName(
+  agentConfig: ResolvedAgentConfig,
+  overrides: RuntimeAgentIdentityOverrides,
+  agentId: string,
+): string {
   const override = readStringOverride(overrides.displayNamesById, agentId)
   if (override !== undefined) {
     return override
   }
 
-  return getAgentDisplayNames()[agentId] ?? agentId
+  return agentConfig.displayNames[agentId] ?? agentId
 }

package/src/runtime/agent-runtime-policy.ts

@@ -7,7 +7,7 @@ import type {
   PlanNodeSpecRecord,
 } from '@lota-sdk/shared'
 
-import { getLeadAgentId } from '../config/agent-defaults'
+import type { ResolvedThreadBootstrapConfig } from '../config/thread-defaults'
 import { resolveOnboardingOwnerAgentId } from '../config/thread-defaults'
 export interface AgentRuntimeConfig<TAgent extends string> {
   id: TAgent
@@ -162,13 +162,18 @@ export function buildThreadAgentToolPolicy<TAgent extends string, TSkill extends
   linearInstalled: boolean
   githubInstalled: boolean
   provideRepoTool: boolean
-  leadAgentId?: TAgent
+  leadAgentId: TAgent
   onboardingOwnerAgentId?: TAgent
+  threadBootstrapConfig?: ResolvedThreadBootstrapConfig
   getAgentSkills: (agentId: TAgent, mode: ChatMode) => TSkill[]
 }): AgentToolPolicy<TSkill> {
   const resolvedMode = params.mode ?? toChatMode(params.threadType)
-  const leadAgentId = params.leadAgentId ?? (getLeadAgentId() as TAgent)
-  const onboardingOwnerAgentId = params.onboardingOwnerAgentId ?? (resolveOnboardingOwnerAgentId(leadAgentId) as TAgent)
+  const leadAgentId = params.leadAgentId
+  const onboardingOwnerAgentId =
+    params.onboardingOwnerAgentId ??
+    (params.threadBootstrapConfig
+      ? (resolveOnboardingOwnerAgentId(leadAgentId, params.threadBootstrapConfig) as TAgent)
+      : leadAgentId)
   const skills = resolveActiveAgentSkills({
     agentId: params.agentId,
     threadType: params.threadType,

package/src/runtime/agent-stream-helpers.ts

@@ -2,7 +2,7 @@ import type { ChatMessage } from '@lota-sdk/shared'
 import type { LanguageModelUsage, UIMessageStreamOptions } from 'ai'
 import { Duration, Effect, Exit, Scope } from 'effect'
 
-import { getAgentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defaults'
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { nowEpochMillis } from '../utils/date-time'
 import { readRecord as _readRecord } from '../utils/string'
 
@@ -139,9 +139,14 @@ export function createTimedAbortSignal(parentSignal: AbortSignal, timeoutMs: num
   }
 }
 
-export function buildSpecialistTaskMessage(params: { agentId: string; task: string }): ChatMessage {
-  const displayName = getAgentDisplayNames()[params.agentId] ?? params.agentId
-  const leadAgentDisplayName = getLeadAgentDisplayName()
+export function buildSpecialistTaskMessage(params: {
+  agentConfig: ResolvedAgentConfig
+  agentId: string
+  task: string
+}): ChatMessage {
+  const displayName = params.agentConfig.displayNames[params.agentId] ?? params.agentId
+  const leadAgentDisplayName =
+    params.agentConfig.displayNames[params.agentConfig.leadAgentId] ?? params.agentConfig.leadAgentId
   return {
     id: Bun.randomUUIDv7(),
     role: 'user',

package/src/runtime/context-compaction/context-compaction-runtime.ts

@@ -48,33 +48,31 @@ function tryContextCompactionPromise<A>(
   })
 }
 
-function runContextCompacter(helperModelRuntime: HelperModelRuntime, params: ContextCompactionRunnerParams) {
-  return Effect.runPromise(
-    tryContextCompactionPromise('Failed to compact runtime context.', () =>
-      helperModelRuntime.generateHelperStructured({
-        tag: 'context-compaction',
-        createAgent: createContextCompactionAgent,
-        messages: [
-          {
-            role: 'user',
-            content: buildContextCompactionPrompt({
-              previousSummary: params.previousSummary,
-              transcript: params.transcript,
-            }),
-          },
-        ],
-        schema: ContextCompactionOutputSchema,
-        maxOutputTokens: 8_000,
-      }),
-    ).pipe(Effect.flatMap(parseCompactionOutput)),
-  )
+function runContextCompacterEffect(helperModelRuntime: HelperModelRuntime, params: ContextCompactionRunnerParams) {
+  return tryContextCompactionPromise('Failed to compact runtime context.', () =>
+    helperModelRuntime.generateHelperStructured({
+      tag: 'context-compaction',
+      createAgent: createContextCompactionAgent,
+      messages: [
+        {
+          role: 'user',
+          content: buildContextCompactionPrompt({
+            previousSummary: params.previousSummary,
+            transcript: params.transcript,
+          }),
+        },
+      ],
+      schema: ContextCompactionOutputSchema,
+      maxOutputTokens: 8_000,
+    }),
+  ).pipe(Effect.flatMap(parseCompactionOutput))
 }
 
 export function createWiredContextCompactionRuntime(deps: CreateContextCompactionRuntimeDeps) {
   const { helperModelRuntime } = deps
 
   const runtime = createContextCompactionRuntime({
-    runCompacter: (params) => runContextCompacter(helperModelRuntime, params),
+    runCompacter: (params) => runContextCompacterEffect(helperModelRuntime, params),
     now: deps.now,
     randomId: deps.randomId,
     thresholdRatio: CONTEXT_COMPACTION_THRESHOLD_RATIO,
@@ -86,20 +84,18 @@ export function createWiredContextCompactionRuntime(deps: CreateContextCompactio
     includedToolPrefixes: CONTEXT_COMPACTION_INCLUDED_TOOL_PREFIXES,
   })
 
-  function compactMemoryBlockSummary(params: { previousSummary: string; newEntriesText: string }): Promise<string> {
+  function compactMemoryBlockSummary(params: { previousSummary: string; newEntriesText: string }) {
     const previousSummary = params.previousSummary.trim()
     const newEntriesText = params.newEntriesText.trim()
-    if (!previousSummary && !newEntriesText) return Promise.resolve('')
+    if (!previousSummary && !newEntriesText) return Effect.succeed('')
 
-    return Effect.runPromise(
-      tryContextCompactionPromise('Failed to compact memory block summary.', () =>
-        helperModelRuntime.generateHelperText({
-          tag: 'memory-block-compaction',
-          createAgent: createContextCompactionAgent,
-          messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
-          maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
-        }),
-      ),
+    return tryContextCompactionPromise('Failed to compact memory block summary.', () =>
+      helperModelRuntime.generateHelperText({
+        tag: 'memory-block-compaction',
+        createAgent: createContextCompactionAgent,
+        messages: [{ role: 'user', content: buildMemoryBlockCompactionPrompt({ previousSummary, newEntriesText }) }],
+        maxOutputTokens: CONTEXT_COMPACTION_MAX_OUTPUT_TOKENS,
+      }),
     )
   }
 

package/src/runtime/context-compaction/context-compaction.ts

@@ -88,7 +88,9 @@ export interface CompactionOutput {
   summary: string
 }
 
-export type ContextCompactionRunner = (params: ContextCompactionRunnerParams) => Promise<CompactionOutput>
+export type ContextCompactionRunner = (
+  params: ContextCompactionRunnerParams,
+) => Effect.Effect<CompactionOutput, unknown>
 
 export interface CreateContextCompactionRuntimeOptions {
   runCompacter: ContextCompactionRunner
@@ -112,7 +114,7 @@ export interface ContextCompactionRuntime {
     liveMessages: ChatMessage[]
     contextSize?: number
   }) => CompactionAssessment
-  compactHistory: (params: CompactHistoryParams) => Promise<CompactHistoryResult>
+  compactHistory: (params: CompactHistoryParams) => Effect.Effect<CompactHistoryResult, CompactionError>
 }
 
 function estimateTokens(text: string): number {
@@ -348,10 +350,10 @@ export function createContextCompactionRuntime(
           Effect.gen(function* () {
             const chunk = chunks[state.index]
             const transcript = toCompactionTranscript(chunk)
-            const output = yield* Effect.tryPromise({
-              try: () => options.runCompacter({ previousSummary: state.summary, chunk, transcript }),
-              catch: (error: unknown) => new CompactionError({ message: String(error), cause: error }),
-            }).pipe(Effect.retry(COMPACTION_RUNNER_RETRY_OPTIONS))
+            const output = yield* options.runCompacter({ previousSummary: state.summary, chunk, transcript }).pipe(
+              Effect.mapError((error) => new CompactionError({ message: String(error), cause: error })),
+              Effect.retry(COMPACTION_RUNNER_RETRY_OPTIONS),
+            )
             return { summary: normalizeSummary(output.summary), index: state.index + 1 }
           }),
       },
@@ -479,7 +481,7 @@ export function createContextCompactionRuntime(
     prependSummaryMessage,
     estimateThreshold,
     shouldCompactHistory,
-    compactHistory: (params) => Effect.runPromise(compactHistoryEffect(params)),
+    compactHistory: compactHistoryEffect,
   }
 }
 

package/src/runtime/domain-layer.ts

@@ -13,6 +13,7 @@ import { Layer } from 'effect'
 import { AiGatewayLive } from '../ai-gateway/ai-gateway'
 import { EmbeddingCacheLive } from '../ai/embedding-cache'
 import type { buildInfrastructureLayer } from '../effect/layers'
+import { LotaQueuesLive } from '../queues/queues.service'
 import { SharedThreadStreamSubscriberLive } from '../redis/stream-context'
 import { AgentActivityServiceLive } from '../services/agent-activity.service'
 import { AgentExecutorServiceLive } from '../services/agent-executor.service'
@@ -121,7 +122,6 @@ export function buildDomainServiceLayer(infrastructureLayer: InfrastructureLayer
       OrganizationMemberServiceLive,
       PlanApprovalServiceLive,
       PlanRunServiceLive,
-      PlanSchedulerServiceLive,
       PlanWorkspaceServiceLive,
       PluginExecutorServiceLive,
       QualityMetricsServiceLive,
@@ -135,7 +135,18 @@ export function buildDomainServiceLayer(infrastructureLayer: InfrastructureLayer
     ),
     ctx0,
   )
-  const ctx1 = Layer.mergeAll(ctx0, tier1)
+  const ctx1Base = Layer.mergeAll(ctx0, tier1)
+
+  // LotaQueuesLive depends only on Redis + QueueJobService from tier1/infra.
+  // It's threaded in before the tiers that need queue enqueue access so the
+  // service layers that enqueue jobs (AutonomousJobService, plan scheduler,
+  // heartbeat, etc.) can resolve LotaQueuesServiceTag cleanly.
+  const queuesTier = provide(LotaQueuesLive, ctx1Base)
+  const ctx1 = Layer.mergeAll(ctx1Base, queuesTier)
+  // PlanSchedulerServiceLive previously sat in tier1; it now depends on the
+  // queue layer, so it moves to the merged ctx1 context with queues available.
+  const planSchedulerTier = provide(PlanSchedulerServiceLive, ctx1)
+  const ctx1WithScheduler = Layer.mergeAll(ctx1, planSchedulerTier)
 
   const tier2 = provide(
     Layer.mergeAll(
@@ -154,9 +165,9 @@ export function buildDomainServiceLayer(infrastructureLayer: InfrastructureLayer
       SkillResolverServiceLive,
       RecentActivityTitleServiceLive,
     ),
-    ctx1,
+    ctx1WithScheduler,
   )
-  const ctx2 = Layer.mergeAll(ctx1, tier2)
+  const ctx2 = Layer.mergeAll(ctx1WithScheduler, tier2)
 
   const tier3 = provide(Layer.mergeAll(PlanValidatorServiceLive, ThreadServiceLive), ctx2)
   const ctx3 = Layer.mergeAll(ctx2, tier3)

package/src/runtime/execution-plan-visibility.ts

@@ -1,8 +1,10 @@
 import type { PlanExecutionVisibility, PlanNodeSpecRecord, PlanSpecRecord } from '@lota-sdk/shared'
 
+import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { isAgentName } from '../config/agent-defaults'
 
 export function resolvePlanNodeExecutionVisibility(
+  agentConfig: ResolvedAgentConfig,
   plan: Pick<PlanSpecRecord, 'defaultExecutionVisibility'>,
   node: Pick<PlanNodeSpecRecord, 'executionVisibility' | 'owner'>,
 ): PlanExecutionVisibility {
@@ -12,12 +14,13 @@ export function resolvePlanNodeExecutionVisibility(
     return configuredVisibility
   }
 
-  return node.owner.executorType === 'agent' && isAgentName(node.owner.ref) ? 'visible' : 'silent'
+  return node.owner.executorType === 'agent' && isAgentName(agentConfig, node.owner.ref) ? 'visible' : 'silent'
 }
 
 export function shouldPlanNodeUseVisibleTurn(
+  agentConfig: ResolvedAgentConfig,
   plan: Pick<PlanSpecRecord, 'defaultExecutionVisibility'>,
   node: Pick<PlanNodeSpecRecord, 'executionVisibility' | 'owner'>,
 ): boolean {
-  return resolvePlanNodeExecutionVisibility(plan, node) === 'visible'
+  return resolvePlanNodeExecutionVisibility(agentConfig, plan, node) === 'visible'
 }

package/src/runtime/graph-designer.ts

@@ -1,27 +1,5 @@
 import type { GraphDesignRequest, GraphDesignResponse } from '@lota-sdk/shared'
 
-import { resolveOptionalLotaService } from '../effect/runtime'
-import { RuntimeConfigServiceTag } from '../effect/services'
-
 export interface GraphDesigner {
   designGraph(request: GraphDesignRequest): Promise<GraphDesignResponse>
 }
-
-let currentGraphDesigner: GraphDesigner | null = null
-
-export function configureGraphDesigner(graphDesigner: GraphDesigner | null | undefined): void {
-  currentGraphDesigner = graphDesigner ?? null
-}
-
-export function clearGraphDesigner(): void {
-  currentGraphDesigner = null
-}
-
-export function getGraphDesigner(): GraphDesigner | null {
-  if (currentGraphDesigner) {
-    return currentGraphDesigner
-  }
-
-  const runtimeConfig = resolveOptionalLotaService(RuntimeConfigServiceTag)
-  return runtimeConfig?.graphDesigner ?? null
-}

package/src/runtime/index.ts

@@ -2,6 +2,7 @@ export * from './approval-continuation'
 export * from './agent-runtime-policy'
 export * from './agent-stream-helpers'
 export * from './chat-request-routing'
+export * from './chat-run-orchestration'
 export * from './chat-run-registry'
 export * from './context-compaction/context-compaction'
 export * from './execution-plan'
@@ -12,6 +13,7 @@ export * from './instruction-sections'
 export * from './memory/memory-block'
 export * from './memory/memory-digest-policy'
 export * from './memory/memory-scope'
+export * from './live-turn-trace'
 export * from './llm-content'
 export * from './plugin-resolution'
 export * from './plugin-types'

package/src/runtime/indexed-repositories-policy.ts

@@ -1,5 +1,3 @@
-import { getAgentRoster } from '../config/agent-defaults'
-
 export type IndexedRepoAgentName = string
 
 export const REPO_SECTION_NAMES = [
@@ -16,13 +14,11 @@ export type RepoSectionName = (typeof REPO_SECTION_NAMES)[number]
 const ALL_REPO_SECTIONS: RepoSectionName[] = [...REPO_SECTION_NAMES]
 
 export function buildDefaultRepoSectionsByAgent(
-  roster: readonly IndexedRepoAgentName[] = getAgentRoster(),
+  roster: readonly IndexedRepoAgentName[],
 ): Record<IndexedRepoAgentName, RepoSectionName[]> {
   return Object.fromEntries(roster.map((agentId) => [agentId, [...ALL_REPO_SECTIONS]]))
 }
 
-export function emptyAgentContextMap(
-  roster: readonly IndexedRepoAgentName[] = getAgentRoster(),
-): Record<IndexedRepoAgentName, string> {
+export function emptyAgentContextMap(roster: readonly IndexedRepoAgentName[]): Record<IndexedRepoAgentName, string> {
   return Object.fromEntries(roster.map((agentId) => [agentId, '']))
 }