@lota-sdk/core 0.1.24 → 0.1.25

package/src/runtime/memory-pipeline.ts

@@ -9,6 +9,7 @@ const SCORE_WEIGHTS = {
 interface MemoryFactInput {
   content: string
   confidence: number
+  importance?: number
   durability?: string
   type?: string
 }
@@ -23,6 +24,7 @@ interface MemoryImportanceParams {
   text: string
   memoryType: string
   explicitImportance?: number
+  extractedImportanceByKey: Map<string, number>
   confidenceByKey: Map<string, number>
   durabilityByKey: Map<string, string>
   categoryByKey: Map<string, string | undefined>
@@ -30,6 +32,7 @@ interface MemoryImportanceParams {
 }
 
 interface MemoryFactMaps {
+  extractedImportanceByKey: Map<string, number>
   confidenceByKey: Map<string, number>
   durabilityByKey: Map<string, string>
   categoryByKey: Map<string, string | undefined>
@@ -195,18 +198,26 @@ export function postProcessMemoryFacts<T extends MemoryFactInput>(
 }
 
 export function buildMemoryFactMaps<T extends MemoryFactInput>(facts: T[]): MemoryFactMaps {
+  const extractedImportanceByKey = new Map<string, number>()
   const confidenceByKey = new Map<string, number>()
   const durabilityByKey = new Map<string, string>()
   const categoryByKey = new Map<string, string | undefined>()
 
   for (const fact of facts) {
     const key = normalizeMemoryKey(fact.content)
+    const extractedImportance =
+      typeof (fact as T & { importance?: number }).importance === 'number'
+        ? clampImportance((fact as T & { importance: number }).importance)
+        : undefined
+    if (extractedImportance !== undefined) {
+      extractedImportanceByKey.set(key, extractedImportance)
+    }
     confidenceByKey.set(key, fact.confidence)
     durabilityByKey.set(key, fact.durability ?? 'standard')
     categoryByKey.set(key, fact.type)
   }
 
-  return { confidenceByKey, durabilityByKey, categoryByKey }
+  return { extractedImportanceByKey, confidenceByKey, durabilityByKey, categoryByKey }
 }
 
 function toUniqueOrderedIds(value: string[] | undefined, validIds: Set<string>): string[] {
@@ -402,6 +413,56 @@ export function compileMemoryUpdatesFromDelta(params: {
   return { memory: updates }
 }
 
+export function projectMemoryDeltaToScope(params: {
+  delta: MemoryDeltaOutputLike
+  scopeMemoryIds: readonly string[]
+  scopeMemoryIdsByUnionId?: Readonly<Record<string, readonly string[]>>
+}): MemoryDeltaOutputLike {
+  const validExistingIds = new Set(params.scopeMemoryIds)
+  const mapTargetMemoryIds = (targetIds: readonly string[] | undefined): string[] => {
+    if (!targetIds || targetIds.length === 0) return []
+
+    const mappedIds = targetIds.flatMap((targetId) => {
+      const directId = targetId.trim()
+      if (!directId) return []
+
+      const aliasedIds = params.scopeMemoryIdsByUnionId?.[directId]
+      if (aliasedIds && aliasedIds.length > 0) {
+        return aliasedIds.filter((id) => validExistingIds.has(id))
+      }
+
+      return validExistingIds.has(directId) ? [directId] : []
+    })
+
+    return [...new Set(mappedIds)]
+  }
+
+  return {
+    deltas: params.delta.deltas.map((delta) => {
+      const targetMemoryIds = mapTargetMemoryIds(delta.targetMemoryIds)
+      const invalidateTargetIds = mapTargetMemoryIds(delta.invalidateTargetIds).filter((id) =>
+        targetMemoryIds.includes(id),
+      )
+      const relations = (delta.relations ?? []).flatMap((relation) => {
+        if (typeof relation.targetFactIndex === 'number') return [relation]
+        if (typeof relation.targetMemoryId !== 'string') return []
+
+        return mapTargetMemoryIds([relation.targetMemoryId]).map((targetMemoryId) => ({ ...relation, targetMemoryId }))
+      })
+      const hasScopeTarget = targetMemoryIds.length > 0
+
+      return {
+        fact: delta.fact,
+        classification: hasScopeTarget || delta.classification === 'new' ? delta.classification : 'new',
+        targetMemoryIds,
+        invalidateTargetIds,
+        relations,
+        rationale: delta.rationale ?? 'Projected onto the current memory scope.',
+      }
+    }),
+  }
+}
+
 function resolveMemoryImportance(params: MemoryImportanceParams): number {
   if (typeof params.explicitImportance === 'number') {
     return clampImportance(params.explicitImportance)
@@ -412,6 +473,11 @@ function resolveMemoryImportance(params: MemoryImportanceParams): number {
   }
 
   const normalizedText = normalizeMemoryKey(params.text)
+  const extractedImportance = params.extractedImportanceByKey.get(normalizedText)
+  if (extractedImportance !== undefined) {
+    return clampImportance(extractedImportance)
+  }
+
   const aiConfidence = params.confidenceByKey.get(normalizedText)
   if (aiConfidence !== undefined) {
     const durability = params.durabilityByKey.get(normalizedText) ?? 'standard'
@@ -429,6 +495,7 @@ export function createMemoryActionPlan<TRelation extends string = string>(params
   updates: MemoryUpdateOutputLike<TRelation>
   memoryType: string
   explicitImportance?: number
+  extractedImportanceByKey: Map<string, number>
   confidenceByKey: Map<string, number>
   durabilityByKey: Map<string, string>
   categoryByKey: Map<string, string | undefined>
@@ -502,6 +569,7 @@ export function createMemoryActionPlan<TRelation extends string = string>(params
             text,
             memoryType: params.memoryType,
             explicitImportance: params.explicitImportance,
+            extractedImportanceByKey: params.extractedImportanceByKey,
             confidenceByKey: params.confidenceByKey,
             durabilityByKey: params.durabilityByKey,
             categoryByKey: params.categoryByKey,
@@ -524,6 +592,7 @@ export function createMemoryActionPlan<TRelation extends string = string>(params
             text,
             memoryType: params.memoryType,
             explicitImportance: params.explicitImportance,
+            extractedImportanceByKey: params.extractedImportanceByKey,
             confidenceByKey: params.confidenceByKey,
             durabilityByKey: params.durabilityByKey,
             categoryByKey: params.categoryByKey,

package/src/runtime/memory-prompts-fact.ts

@@ -17,12 +17,23 @@ Classification:
 - "preference": Subjective preference or style choice.
 - "decision": Explicit decision, requirement, or policy.
 
+Storage scoring:
+- importance: 0 to 1 for long-term usefulness.
+- classification: durable | transient | uncertain.
+- rationale: short and concrete.
+
 Confidence scoring:
 - 1.0: Explicit, confirmed statements ("We use TypeScript", "I prefer dark mode", "We decided to migrate").
 - 0.8: Strong implications or clearly implied facts.
 - 0.6-0.7: Reasonable inferences with some ambiguity.
 - Below 0.6: Do NOT extract. Skip entirely.
 
+Importance scoring:
+- 0.9-1.0: Foundational business decisions, architecture, durable requirements, critical facts.
+- 0.6-0.8: Stable process or domain knowledge worth reusing later.
+- 0.2-0.5: Low-value or weakly durable memory.
+- Use classification="transient" for low-value facts that should usually be skipped.
+
 Durability classification:
 - "core": Business decisions, technical architecture choices, confirmed requirements, strategic direction. These are foundational and rarely change. Examples: "We use SurrealDB", "We decided to adopt microservices", "Revenue target is $1M ARR".
 - "standard": General facts, moderate inferences, process details. These may evolve over time. Examples: "Team has 5 engineers", "Sprint cycle is 2 weeks", "Using Jest for testing".
@@ -33,10 +44,15 @@ Hard rules:
 - Do NOT extract transient tasks, questions, research requests, or one-off conversation details.
 - Do NOT turn suggestions, brainstorming, or hypotheticals into facts. If something is not confirmed, skip it.
 - Do NOT trust new facts introduced by the agent unless the user explicitly confirms them.
+- Use classification="transient" only when the fact is not worth persisting long-term.
 - Preserve concrete numeric literals and units exactly when present (examples: "6", "50k", "$79", "15%", "Q2 2026").
 - If a statement explicitly marks an older policy/value as deprecated or obsolete, capture both:
   1) the current truth
   2) the deprecation/obsolescence fact
+- For every returned fact, also provide:
+  - importance: 0 to 1
+  - classification: durable | transient | uncertain
+  - rationale: one short sentence
 - Prefer returning fewer items. If uncertain, return an empty list.
 - Max ${maxFacts} facts.
 

package/src/runtime/plugin-resolution.ts

@@ -1,4 +1,5 @@
 import { pluginRuntime } from '../config/agent-defaults'
+import type { LotaRuntimeIndexedRepositoriesContext } from './runtime-extensions'
 import { getRuntimeAdapters } from './runtime-extensions'
 
 export function getPluginService(path: string[]): ((...args: unknown[]) => unknown) | undefined {
@@ -20,8 +21,8 @@ export function getPluginService(path: string[]): ((...args: unknown[]) => unkno
 
 export async function buildIndexedRepositoriesContext(
   organizationId: string,
-): Promise<{ provideRepoTool: boolean; defaultSectionsByAgent: Record<string, unknown>; context: string }> {
-  const buildContext = getRuntimeAdapters().workstream?.buildIndexedRepositoriesContext
+): Promise<LotaRuntimeIndexedRepositoriesContext> {
+  const buildContext = getRuntimeAdapters().buildIndexedRepositoriesContext
   if (!buildContext) {
     return { provideRepoTool: false, defaultSectionsByAgent: {}, context: '' }
   }

package/src/runtime/plugin-types.ts

@@ -1,27 +1,10 @@
-import type {
-  CarryForwardPolicy,
-  CycleSchedule,
-  PlanDraft,
-  PlanNodeResult,
-  PlanNodeSpec,
-  PlanScheduleSpec,
-  SignalDeclaration,
-} from '@lota-sdk/shared'
+import type { PlanNodeResult, PlanNodeSpec } from '@lota-sdk/shared'
 
 import type { RecordIdRef } from '../db/record-id'
 
-export interface PluginContextEnricher {
-  domain: string
-  enrich(params: {
-    objective: string
-    organizationId: string
-  }): Promise<{ data: Record<string, unknown>; confidence: number }>
-}
-
 export interface LotaPluginContributions {
   envKeys: readonly string[]
   schemaFiles: readonly (string | URL)[]
-  signals?: readonly SignalDeclaration[]
 }
 
 export interface PluginNodeExecutorContext {
@@ -50,33 +33,9 @@ export interface SystemNodeExecutor {
   executeNode(params: PluginNodeExecutionParams): Promise<PlanNodeResult>
 }
 
-export interface PlaybookContribution {
-  name: string
-  description: string
-  tags: string[]
-  draft: PlanDraft
-  schedule?: PlanScheduleSpec
-  cycleSchedule?: CycleSchedule
-  carryForwardPolicy?: CarryForwardPolicy
-}
-
-export interface PlaybookContributor {
-  playbooks: readonly PlaybookContribution[]
-}
-
-export interface PluginDomainAgentDefinition {
-  agentId: string
-  displayName: string
-  capabilities: readonly string[]
-}
-
 export interface LotaPlugin<TServices = Record<string, unknown>, TTools = Record<string, unknown>> {
   services: TServices
   nodeExecutor?: PluginNodeExecutor
   tools?: TTools
   contributions: LotaPluginContributions
-  playbookContributor?: PlaybookContributor
-  domainAgents?: readonly PluginDomainAgentDefinition[]
-  contextEnrichers?: readonly PluginContextEnricher[]
-  onSignal?: (signal: string, payload: unknown, source: string) => Promise<void> | void
 }

package/src/runtime/post-turn-side-effects.ts

@@ -0,0 +1,212 @@
+import type { ChatMessage } from '@lota-sdk/shared'
+
+import { agentDisplayNames } from '../config/agent-defaults'
+import type { RecordIdRef } from '../db/record-id'
+import { enqueueMemoryConsolidation } from '../queues/memory-consolidation.queue'
+import { enqueueRegularChatMemoryDigest, enqueueSkillExtraction } from '../queues/organization-learning.queue'
+import { enqueuePostChatMemory } from '../queues/post-chat-memory.queue'
+import { enqueueRecentActivityTitleRefinement } from '../queues/title-generation.queue'
+import {
+  shouldEnqueueMemoryConsolidation,
+  shouldEnqueueMemoryExtraction,
+  shouldEnqueueOnboardingPostChatMemory,
+  shouldEnqueueRegularDigestForWorkstream,
+} from '../runtime/memory-digest-policy'
+import { getRuntimeAdapters } from '../runtime/runtime-extensions'
+import { shouldEnqueueSkillExtraction } from '../runtime/skill-extraction-policy'
+import {
+  appendPersistedWorkstreamContextToHistoryMessages,
+  buildAgentHistoryMessages,
+  buildConversationSummary,
+  buildReadableUploadMetadataContext,
+  extractMessageText,
+  readOptionalString,
+  toHistoryMessages,
+} from '../runtime/workstream-chat-helpers'
+import { recentActivityService } from '../services/recent-activity.service'
+import { workstreamService } from '../services/workstream.service'
+import type { NormalizedWorkstream, WorkstreamRecord } from '../services/workstream.types'
+import { safeEnqueue } from '../utils/async'
+import { toIsoDateTimeString } from '../utils/date-time'
+import type { WorkstreamState } from './workstream-state'
+
+function buildRecentActivityChatDeepLink(params: {
+  workstream: NormalizedWorkstream
+  workstreamId: string
+  visibleAgentId: string
+}): { route: string; search: Record<string, string> } {
+  if (params.workstream.mode === 'direct') {
+    return { route: 'direct-workstream', search: { workstreamId: params.workstreamId, agentId: params.visibleAgentId } }
+  }
+
+  return { route: 'group-workstream', search: { workstreamId: params.workstreamId } }
+}
+
+function buildRecentActivityChatSystemTitle(params: {
+  workstream: NormalizedWorkstream
+  visibleAgentId: string
+}): string {
+  if (params.workstream.mode === 'direct') {
+    return `Conversation with ${agentDisplayNames[params.visibleAgentId]}`
+  }
+
+  return params.workstream.title.trim() || 'Workstream update'
+}
+
+interface PostTurnSideEffectsParams {
+  workstream: NormalizedWorkstream
+  workstreamRef: RecordIdRef
+  orgRef: RecordIdRef
+  userRef: RecordIdRef
+  userName?: string | null
+  orgIdString: string
+  workstreamIdString: string
+  onboardingActive: boolean
+  workspace: unknown
+  allAssistantMessages: ChatMessage[]
+  referenceUserMessage: ChatMessage | undefined
+  referenceUserMessageId: string
+  loadRecentHistory: () => Promise<ChatMessage[]>
+  listReadableUploads: () => Array<{
+    filename: string
+    mediaType: string
+    sizeBytes: number | null
+    storageKey: string
+  }>
+  memoryBlock: string
+  visibleWorkstreamAgentId: string | null | undefined
+  defaultLeadAgentId: string
+  latestWorkstreamRecord: WorkstreamRecord
+  latestPersistedState: WorkstreamState | null
+  isUserTurn: boolean
+}
+
+export async function runPostTurnSideEffects(params: PostTurnSideEffectsParams): Promise<void> {
+  const recentHistory = await params.loadRecentHistory()
+  const turnCount = await workstreamService.incrementTurnCount(params.workstreamRef)
+  const agentMessages = buildAgentHistoryMessages(params.allAssistantMessages)
+  const historyMessagesForMemory = appendPersistedWorkstreamContextToHistoryMessages(toHistoryMessages(recentHistory), {
+    compactionSummary: params.latestWorkstreamRecord.compactionSummary,
+    persistedState: params.latestPersistedState,
+  })
+
+  const userMessageText = params.referenceUserMessage ? extractMessageText(params.referenceUserMessage).trim() : ''
+  const readableUploads = params.listReadableUploads()
+  const attachmentMetadataContext = buildReadableUploadMetadataContext(readableUploads)
+  const hasAttachmentContext = Boolean(attachmentMetadataContext)
+  const shouldExtractMemory = params.onboardingActive
+    ? shouldEnqueueOnboardingPostChatMemory({
+        onboardingActive: params.onboardingActive,
+        userMessageText,
+        hasAttachmentContext,
+        agentMessageCount: agentMessages.length,
+      })
+    : shouldEnqueueMemoryExtraction({ onboardingActive: params.onboardingActive, turnCount }) &&
+      userMessageText.length > 0
+
+  if (shouldExtractMemory) {
+    const memoryUserMessage = userMessageText || 'User uploaded attachment(s).'
+    await safeEnqueue(
+      () =>
+        enqueuePostChatMemory({
+          orgId: params.orgIdString,
+          workstreamId: params.workstreamIdString,
+          sourceId: params.referenceUserMessageId,
+          onboardStatus: readOptionalString((params.workspace as { onboardStatus?: unknown }).onboardStatus),
+          userMessage: memoryUserMessage,
+          historyMessages: historyMessagesForMemory,
+          agentMessages,
+          memoryBlock: params.memoryBlock.trim() ? params.memoryBlock : undefined,
+          attachmentContext: attachmentMetadataContext,
+        }),
+      { operationName: 'post-chat memory extraction enqueue' },
+    )
+  }
+
+  if (params.isUserTurn && params.referenceUserMessage) {
+    const conversationSummary = buildConversationSummary({
+      userMessageText,
+      assistantMessages: params.allAssistantMessages,
+    })
+    if (conversationSummary) {
+      const effectiveAgentId = params.visibleWorkstreamAgentId ?? params.defaultLeadAgentId
+      const recentActivityResult = await recentActivityService.recordEvent({
+        orgId: params.orgRef,
+        userId: params.userRef,
+        source: 'system',
+        event: {
+          sourceEventId: `chat-turn:${params.referenceUserMessageId}`,
+          kind: 'chat.turn.completed',
+          targetKind: 'workstream',
+          targetId: params.workstreamIdString,
+          mergeKey: `workstream:${params.workstreamIdString}`,
+          title: buildRecentActivityChatSystemTitle({
+            workstream: params.workstream,
+            visibleAgentId: effectiveAgentId,
+          }),
+          sourceLabel: agentDisplayNames[effectiveAgentId],
+          deepLink: buildRecentActivityChatDeepLink({
+            workstream: params.workstream,
+            workstreamId: params.workstreamIdString,
+            visibleAgentId: effectiveAgentId,
+          }),
+          metadata: {
+            agentId: effectiveAgentId,
+            agentName: agentDisplayNames[effectiveAgentId],
+            workstreamId: params.workstreamIdString,
+            workstreamTitle: params.latestWorkstreamRecord.title ?? params.workstream.title,
+            workstreamMode: params.workstream.mode,
+            ...(params.workstream.coreType ? { coreType: params.workstream.coreType } : {}),
+            userMessageText,
+            assistantSummary: conversationSummary,
+            messageId: params.referenceUserMessageId,
+          },
+          occurredAt: toIsoDateTimeString(params.referenceUserMessage.metadata?.createdAt ?? Date.now()),
+        },
+      })
+
+      await safeEnqueue(
+        async () => {
+          const enqueuePostChatOrgAction = getRuntimeAdapters().enqueuePostChatOrgAction
+          if (!enqueuePostChatOrgAction) {
+            return
+          }
+          const sourceCreatedAt = params.referenceUserMessage?.metadata?.createdAt ?? Date.now()
+
+          await enqueuePostChatOrgAction({
+            orgId: params.orgIdString,
+            workstreamId: params.workstreamIdString,
+            sourceId: params.referenceUserMessageId,
+            sourceCreatedAt,
+            conversationSummary,
+          })
+        },
+        { operationName: 'post-chat org action enqueue' },
+      )
+
+      if (recentActivityService.isMeaningfulRefinementCandidate(recentActivityResult.item)) {
+        await safeEnqueue(() => enqueueRecentActivityTitleRefinement({ activityId: recentActivityResult.item.id }), {
+          operationName: 'recent activity title refinement enqueue',
+        })
+      }
+    }
+  }
+
+  if (shouldEnqueueRegularDigestForWorkstream({ onboardingActive: params.onboardingActive, turnCount })) {
+    await safeEnqueue(() => enqueueRegularChatMemoryDigest({ orgId: params.orgIdString }), {
+      operationName: 'regular chat memory digest enqueue',
+    })
+  }
+
+  if (shouldEnqueueSkillExtraction({ onboardingActive: params.onboardingActive, turnCount })) {
+    await safeEnqueue(() => enqueueSkillExtraction({ orgId: params.orgIdString }), {
+      operationName: 'skill extraction enqueue',
+    })
+  }
+
+  if (shouldEnqueueMemoryConsolidation({ onboardingActive: params.onboardingActive, turnCount })) {
+    await safeEnqueue(() => enqueueMemoryConsolidation({ scopeId: params.orgIdString }), {
+      operationName: 'memory consolidation enqueue',
+    })
+  }
+}

package/src/runtime/runtime-config.ts

@@ -246,19 +246,6 @@ export const LotaRuntimeConfigSchema = z.object({
     })
     .default({ searchK: 6, embeddingCacheTtlSeconds: 7200 }),
   workstreams: workstreamConfigSchema.default({}),
-  backgroundProcessing: z
-    .object({
-      memoryExtractionFrequency: z.coerce.number().int().positive().default(3),
-      skillExtractionFrequency: z.coerce.number().int().positive().default(5),
-      memoryDigestFrequency: z.coerce.number().int().positive().default(1),
-      memoryConsolidationFrequency: z.coerce.number().int().positive().default(10),
-    })
-    .default({
-      memoryExtractionFrequency: 3,
-      skillExtractionFrequency: 5,
-      memoryDigestFrequency: 1,
-      memoryConsolidationFrequency: 10,
-    }),
   agents: agentsConfigSchema,
   toolProviders: z.custom<Record<string, unknown>>(isToolProviderRecord).optional(),
   extraSchemaFiles: z.array(z.custom<string | URL>(isStringOrUrl)).optional(),

package/src/runtime/runtime-extensions.ts

@@ -184,20 +184,14 @@ export interface LotaRuntimeTurnHooks {
 }
 
 export interface LotaRuntimeAdapters {
-  services?: { workspaceProvider?: LotaRuntimeWorkspaceProvider }
-  events?: { planEventAdapter?: LotaRuntimePlanEventAdapter }
-  workstream?: {
-    buildIndexedRepositoriesContext?: (workspaceId: string) => Promise<LotaRuntimeIndexedRepositoriesContext>
-    buildTeamThinkAgentTools?: (params: LotaRuntimeTeamThinkToolsParams) => Promise<{ tools: ToolSet }>
-  }
-  queues?: {
-    enqueuePostChatOrgAction?: (job: Record<string, unknown>) => Promise<void>
-    enqueueOnboardingRepoIndexFollowUp?: (job: Record<string, unknown>) => Promise<void>
-  }
-  workers?: {
-    connectPluginDatabases?: () => Promise<void>
-    withWorkspaceMemoryLock?: <T>(workspaceId: string, fn: () => Promise<T>) => Promise<T>
-  }
+  workspaceProvider?: LotaRuntimeWorkspaceProvider
+  planEventAdapter?: LotaRuntimePlanEventAdapter
+  buildIndexedRepositoriesContext?: (workspaceId: string) => Promise<LotaRuntimeIndexedRepositoriesContext>
+  buildTeamThinkAgentTools?: (params: LotaRuntimeTeamThinkToolsParams) => Promise<{ tools: ToolSet }>
+  enqueuePostChatOrgAction?: (job: Record<string, unknown>) => Promise<void>
+  enqueueOnboardingRepoIndexFollowUp?: (job: Record<string, unknown>) => Promise<void>
+  connectPluginDatabases?: () => Promise<void>
+  withWorkspaceMemoryLock?: <T>(workspaceId: string, fn: () => Promise<T>) => Promise<T>
 }
 
 interface RuntimeExtensionsState {
@@ -243,11 +237,11 @@ export function getToolProviders(): ToolSet {
 }
 
 export function getConfiguredPluginDatabaseConnector(): (() => Promise<void>) | undefined {
-  return runtimeExtensionsState.adapters.workers?.connectPluginDatabases
+  return runtimeExtensionsState.adapters.connectPluginDatabases
 }
 
 export async function withConfiguredWorkspaceMemoryLock<T>(workspaceId: string, fn: () => Promise<T>): Promise<T> {
-  const adapter = runtimeExtensionsState.adapters.workers?.withWorkspaceMemoryLock
+  const adapter = runtimeExtensionsState.adapters.withWorkspaceMemoryLock
   if (!adapter) {
     return fn()
   }

package/src/runtime/runtime-worker-registry.ts

@@ -2,31 +2,26 @@ import { startAutonomousJobWorker } from '../queues/autonomous-job.queue'
 import { startContextCompactionWorker } from '../queues/context-compaction.queue'
 import { startDelayedNodePromotionWorker } from '../queues/delayed-node-promotion.queue'
 import { scheduleRecurringConsolidation, startMemoryConsolidationWorker } from '../queues/memory-consolidation.queue'
-import { schedulePlanAgentHeartbeatSweep, startPlanAgentHeartbeatWorker } from '../queues/plan-agent-heartbeat.queue'
+import { startOrganizationLearningWorker } from '../queues/organization-learning.queue'
+import { startPlanAgentHeartbeatWorker } from '../queues/plan-agent-heartbeat.queue'
 import { startPlanSchedulerWorker } from '../queues/plan-scheduler.queue'
 import { startPostChatMemoryWorker } from '../queues/post-chat-memory.queue'
-import { startRecentActivityTitleRefinementWorker } from '../queues/recent-activity-title-refinement.queue'
-import { startRegularChatMemoryDigestWorker } from '../queues/regular-chat-memory-digest.queue'
-import { startSkillExtractionWorker } from '../queues/skill-extraction.queue'
-import { startWorkstreamTitleGenerationWorker } from '../queues/workstream-title-generation.queue'
+import { startTitleGenerationWorker } from '../queues/title-generation.queue'
 
 export interface LotaRuntimeWorkerStartRegistry {
   autonomousJob: typeof startAutonomousJobWorker
   contextCompaction: typeof startContextCompactionWorker
   delayedNodePromotion: typeof startDelayedNodePromotionWorker
   memoryConsolidation: typeof startMemoryConsolidationWorker
+  organizationLearning: typeof startOrganizationLearningWorker
   planAgentHeartbeat: typeof startPlanAgentHeartbeatWorker
   planScheduler: typeof startPlanSchedulerWorker
   postChatMemory: typeof startPostChatMemoryWorker
-  regularChatMemoryDigest: typeof startRegularChatMemoryDigestWorker
-  skillExtraction: typeof startSkillExtractionWorker
-  workstreamTitleGeneration: typeof startWorkstreamTitleGenerationWorker
-  recentActivityTitleRefinement: typeof startRecentActivityTitleRefinementWorker
+  titleGeneration: typeof startTitleGenerationWorker
 }
 
 export interface LotaRuntimeWorkerScheduleRegistry {
   recurringConsolidation: typeof scheduleRecurringConsolidation
-  planAgentHeartbeatSweep: typeof schedulePlanAgentHeartbeatSweep
 }
 
 export interface LotaRuntimeWorkers {
@@ -46,19 +41,13 @@ export function buildRuntimeWorkerRegistry(extraWorkers?: LotaRuntimeWorkerExten
       contextCompaction: startContextCompactionWorker,
       delayedNodePromotion: startDelayedNodePromotionWorker,
       memoryConsolidation: startMemoryConsolidationWorker,
+      organizationLearning: startOrganizationLearningWorker,
       planAgentHeartbeat: startPlanAgentHeartbeatWorker,
       planScheduler: startPlanSchedulerWorker,
       postChatMemory: startPostChatMemoryWorker,
-      regularChatMemoryDigest: startRegularChatMemoryDigestWorker,
-      skillExtraction: startSkillExtractionWorker,
-      workstreamTitleGeneration: startWorkstreamTitleGenerationWorker,
-      recentActivityTitleRefinement: startRecentActivityTitleRefinementWorker,
+      titleGeneration: startTitleGenerationWorker,
       ...extraWorkers?.start,
     },
-    schedule: {
-      recurringConsolidation: scheduleRecurringConsolidation,
-      planAgentHeartbeatSweep: schedulePlanAgentHeartbeatSweep,
-      ...extraWorkers?.schedule,
-    },
+    schedule: { recurringConsolidation: scheduleRecurringConsolidation, ...extraWorkers?.schedule },
   }
 }