@lota-sdk/core 0.1.24 → 0.1.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,7 +32,7 @@
     "@chat-adapter/slack": "^4.23.0",
     "@chat-adapter/state-ioredis": "^4.23.0",
     "@logtape/logtape": "^2.0.5",
-    "@lota-sdk/shared": "0.1.24",
+    "@lota-sdk/shared": "0.1.26",
     "@mendable/firecrawl-js": "^4.18.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.141",

package/src/ai/definitions.ts

@@ -296,65 +296,11 @@ export const memr3Rule = defineRule({
   name: 'memr3',
   instructions: `# MemR3 Evidence-Gap Protocol
 
-Use the MemR3 retrieval loop for every request.
-
-## Evidence-Gap Tracker
-
-- Maintain two explicit lists:
-  - **Evidence**: a fenced code block starting with \`evidence\`.
-  - **Gaps**: a fenced code block starting with \`gaps\`.
-- Evidence must be grounded; never speculate or include missing info in the evidence block.
-
-## What Counts As A Gap
-
-Treat the \`gaps\` block as **specific, queryable blocking gaps only**: missing information that materially changes the
-recommendation, action, or confidence level, or makes an answer unsafe/unreliable.
-
-- Each gap should be atomic enough to resolve with one targeted retrieval query or one user question.
-- If you can provide a useful answer with reasonable startup-stage assumptions and the remaining unknowns would not
-  materially change it, set \`gaps\` to \`- None\` and proceed.
-- Non-blocking unknowns should be handled as:
-  - explicit assumptions in the answer, and/or
-  - 1-3 follow-up questions at the end (do not block the main recommendation).
-
-## Retrieval Loop
-
-1. **Recall**: Use internal knowledge and the current conversation.
-2. **Retrieve**: If a retrieval tool is available, call it to fill gaps.
-   - Prefer \`memorySearch\` for stored memories (semantic retrieval + graph expansion).
-   - If retrieved memory context is already provided in-system for this turn and blocking gaps are already closed, you
-     may skip \`memorySearch\`.
-   - If any blocking gap remains after reviewing provided context, retrieval is mandatory.
-   - Use web tools only if you have them.
-   - If multiple gaps are independent, issue multiple tool calls concurrently in the same turn.
-   - For web research, call multiple \`researchTopic\` instances in parallel for different sub-questions.
-3. **Reflect**: Update the evidence and gaps blocks.
-   - Remove resolved gaps.
-   - Split vague gaps into smaller, searchable gaps.
-   - Drop gaps that no longer matter because the answer is robust under explicit assumptions.
-4. **Iterate**: If the gaps block still contains blocking items, issue targeted new queries in parallel and repeat.
-   - Keep queries short (5-15 tokens) and specific.
-   - Limit to 3 retrieve/reflect cycles unless the user explicitly asks for deeper research.
-   - Stop early once remaining unknowns are non-material; do not retrieve for completeness alone.
-5. **Answer**: Answer once blocking gaps are \`None\`.
-   - If retrieval returns no useful evidence and the answer is still robust under stated assumptions, proceed and make
-     those assumptions explicit rather than stalling.
-   - Do not say "memory search yielded nothing" or mention tool names; translate it into plain-language uncertainty.
-
-## Output Format
-
-\`\`\`evidence
-- ...
-\`\`\`
-
-\`\`\`gaps
-- ... (or "None")
-\`\`\`
-
-- Provide your response using your normal response format.
-- Never output raw tool payloads (JSON, object dumps, or memory IDs like \`memory:...\`) in the final answer; summarize
-  them in plain language.
-- If blocking gaps remain after the loop, do not answer; ask for the missing information instead.`,
+When a factual answer depends on information you may not have:
+1. Search memory and knowledge before responding.
+2. Cite retrieved evidence; state remaining gaps explicitly.
+3. Never fabricate facts; say "I don't have information on that" when appropriate.
+4. Ask the user only for missing information that would materially change the answer.`,
 })
 
 export const domainReasoningFallbackRule = defineRule({

package/src/ai-gateway/ai-gateway.ts

@@ -5,7 +5,7 @@ import type { LanguageModelMiddleware } from 'ai'
 
 import { getRuntimeConfig } from '../runtime/runtime-config'
 import { isRecord, readString } from '../utils/string'
-import { buildAiGatewayCacheHeaders } from './cache-headers'
+import { buildAiGatewayCacheHeaders, toAiGatewayCacheKeyPart } from './cache-headers'
 
 type AiGatewayLanguageModel = Parameters<typeof wrapLanguageModel>[0]['model']
 type AiGatewayExtraParams = Record<string, unknown>
@@ -29,15 +29,6 @@ const OPENROUTER_RESPONSE_HEALING_EXTRA_PARAMS = {
   plugins: [{ id: 'response-healing' }],
 } as const satisfies AiGatewayExtraParams
 
-function toAiGatewayCacheKeyPart(value: string): string {
-  const normalized = value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9:_-]+/g, '-')
-    .replace(/-+/g, '-')
-  return normalized.replace(/^-+|-+$/g, '') || 'request'
-}
-
 function mergeAiGatewayHeaders(
   existingHeaders: AiGatewayCallOptions['headers'] | undefined,
   additionalHeaders: Record<string, string>,
@@ -64,16 +55,6 @@ function parseAiGatewayJsonRequestBody(body: BodyInit | null | undefined): Recor
   return isRecord(parsed) ? parsed : null
 }
 
-function isAiGatewayOpenAIModelRequest(body: BodyInit | null | undefined): boolean {
-  const parsed = parseAiGatewayJsonRequestBody(body)
-  return readString(parsed?.model)?.startsWith('openai/') ?? false
-}
-
-function hasAiGatewayPromptCacheRetention(body: BodyInit | null | undefined): boolean {
-  const parsed = parseAiGatewayJsonRequestBody(body)
-  return readString(parsed?.prompt_cache_retention) !== null
-}
-
 function withDefaultAiGatewayCacheHeaders(params: AiGatewayCallOptions, modelId: string): AiGatewayCallOptions {
   return {
     ...params,
@@ -343,22 +324,49 @@ export function injectAiGatewayOpenAIPromptCacheRetentionRequestBody(
 
 function createAiGatewayFetch(extraParams?: AiGatewayExtraParams): typeof fetch {
   const fetchWithMutations = (input: RequestInfo | URL, init?: RequestInit | BunFetchRequestInit) => {
-    const bodyWithPromptCacheRetention = injectAiGatewayOpenAIPromptCacheRetentionRequestBody(init?.body)
-    const body =
-      extraParams !== undefined
-        ? injectAiGatewayExtraParamsRequestBody(bodyWithPromptCacheRetention, extraParams)
-        : bodyWithPromptCacheRetention
+    const parsedBody = parseAiGatewayJsonRequestBody(init?.body)
+    let nextBody = init?.body
+    let nextParsedBody = parsedBody
+
+    if (
+      nextParsedBody &&
+      readString(nextParsedBody.model)?.startsWith('openai/') &&
+      !readString(nextParsedBody.prompt_cache_retention)
+    ) {
+      nextParsedBody = { ...nextParsedBody, prompt_cache_retention: OPENAI_PROMPT_CACHE_RETENTION }
+      nextBody = JSON.stringify(nextParsedBody)
+    }
+
+    if (nextParsedBody && extraParams !== undefined) {
+      nextParsedBody = {
+        ...nextParsedBody,
+        extra_params: isRecord(nextParsedBody.extra_params)
+          ? { ...nextParsedBody.extra_params, ...extraParams }
+          : { ...extraParams },
+      }
+      nextBody = JSON.stringify(nextParsedBody)
+    }
 
     const headers = new Headers(init?.headers)
-    if (extraParams !== undefined || (isAiGatewayOpenAIModelRequest(body) && hasAiGatewayPromptCacheRetention(body))) {
+    if (
+      extraParams !== undefined ||
+      (readString(nextParsedBody?.model)?.startsWith('openai/') &&
+        readString(nextParsedBody?.prompt_cache_retention) !== null)
+    ) {
       // Bifrost only forwards provider-specific extra params when passthrough is enabled.
       headers.set(AI_GATEWAY_EXTRA_PARAMS_HEADER, 'true')
     }
 
-    return globalThis.fetch(input, { ...init, headers, body })
+    return globalThis.fetch(input, { ...init, headers, body: nextBody })
+  }
+
+  const preconnect = globalThis.fetch.preconnect
+
+  if (typeof preconnect !== 'function') {
+    return fetchWithMutations as typeof fetch
   }
 
-  return Object.assign(fetchWithMutations, { preconnect: globalThis.fetch.preconnect.bind(globalThis.fetch) })
+  return Object.assign(fetchWithMutations, { preconnect: preconnect.bind(globalThis.fetch) })
 }
 
 function createAiGatewayProvider(extraParams?: AiGatewayExtraParams) {

package/src/ai-gateway/cache-headers.ts

@@ -7,6 +7,15 @@ export const AI_GATEWAY_STRICT_SEMANTIC_CACHE_THRESHOLD = 0.975
 
 export type AiGatewayCacheType = 'direct' | 'semantic'
 
+export function toAiGatewayCacheKeyPart(value: string): string {
+  const normalized = value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9:_-]+/g, '-')
+    .replace(/-+/g, '-')
+  return normalized.replace(/^-+|-+$/g, '') || 'request'
+}
+
 export function buildAiGatewayCacheHeaders(
   cacheKey: string,
   ttl?: string,

package/src/config/model-constants.ts

@@ -2,15 +2,19 @@ export {
   AI_GATEWAY_REASONING_SUMMARY_LEVEL,
   OPENAI_HIGH_REASONING_PROVIDER_OPTIONS,
   OPENAI_REASONING_MODEL_ID,
-  OPENROUTER_DELEGATED_REASONING_MODEL_ID,
   OPENROUTER_FAST_REASONING_MODEL_ID,
+  OPENROUTER_GEMINI_FLASH_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
   OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
   OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS,
   OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
-  OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_STRUCTURED_REASONING_MODEL_ID,
   OPENROUTER_TEAM_AGENT_MODEL_ID,
   OPENROUTER_WEB_RESEARCH_MODEL_ID,
   OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS,
 } from '@lota-sdk/shared'
+
+// Both aliases point to the same underlying model. Keep the names separate so
+// SDK system agents and host delegated agents can diverge independently later.
+export { OPENROUTER_GEMINI_FLASH_MODEL_ID as OPENROUTER_STRUCTURED_HELPER_MODEL_ID } from '@lota-sdk/shared'
+export { OPENROUTER_GEMINI_FLASH_MODEL_ID as OPENROUTER_DELEGATED_REASONING_MODEL_ID } from '@lota-sdk/shared'

package/src/create-runtime.ts

@@ -33,10 +33,8 @@ import type { attachmentService } from './services/attachment.service'
 import { attachmentService as attachmentServiceSingleton } from './services/attachment.service'
 import type { autonomousJobService } from './services/autonomous-job.service'
 import { autonomousJobService as autonomousJobServiceSingleton } from './services/autonomous-job.service'
-import { coordinationRegistryService as coordinationRegistryServiceSingleton } from './services/coordination-registry.service'
 import type { documentChunkService } from './services/document-chunk.service'
 import { documentChunkService as documentChunkServiceSingleton } from './services/document-chunk.service'
-import { domainAgentExecutorService } from './services/domain-agent-executor.service'
 import type { executionPlanService } from './services/execution-plan.service'
 import { executionPlanService as executionPlanServiceSingleton } from './services/execution-plan.service'
 import type { memoryService } from './services/memory.service'
@@ -50,7 +48,6 @@ import type { organizationService } from './services/organization.service'
 import { organizationService as organizationServiceSingleton } from './services/organization.service'
 import type { planAgentQueryService } from './services/plan-agent-query.service'
 import { planAgentQueryService as planAgentQueryServiceSingleton } from './services/plan-agent-query.service'
-import { playbookRegistryService } from './services/playbook-registry.service'
 import type { recentActivityTitleService } from './services/recent-activity-title.service'
 import { recentActivityTitleService as recentActivityTitleServiceSingleton } from './services/recent-activity-title.service'
 import type { recentActivityService } from './services/recent-activity.service'
@@ -143,7 +140,6 @@ export interface LotaRuntime {
     isApprovalContinuationRequest: typeof isApprovalContinuationRequest
     runWorkstreamTurnInBackground: typeof runWorkstreamTurnInBackground
     triggerPlanNodeTurn: typeof triggerPlanNodeTurn
-    syncPlaybookTemplates: typeof playbookRegistryService.syncPlaybookTemplates
   }
   lota: {
     organizations: {
@@ -237,7 +233,7 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
     const redisManager = createRedisConnectionManager({ url: runtimeConfig.redis.url })
     setRedisConnectionManager(redisManager)
     configureEmbeddingCache(redisManager.getConnection(), runtimeConfig.memory.embeddingCacheTtlSeconds)
-    configureBackgroundProcessing(runtimeConfig.backgroundProcessing)
+    configureBackgroundProcessing()
     configureSocialChatHistory({ keyPrefix: runtimeConfig.socialChat?.historyRedisKeyPrefix })
 
     const socialChatAgentId = runtimeConfig.socialChat?.agentId?.trim() || 'socialChat'
@@ -273,21 +269,10 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
     })
 
     const pluginRuntime = runtimeConfig.pluginRuntime ?? {}
-    domainAgentExecutorService.configure(pluginRuntime)
     if (runtimeConfig.graphDesigner) {
       configureGraphDesigner(runtimeConfig.graphDesigner)
     }
 
-    for (const [pluginRef, plugin] of Object.entries(pluginRuntime)) {
-      const signals = plugin.contributions.signals
-      if (signals && signals.length > 0) {
-        coordinationRegistryServiceSingleton.register(pluginRef, [...signals])
-      }
-    }
-    coordinationRegistryServiceSingleton.validate()
-    // Collect playbook contributions early to fail fast on misconfiguration
-    playbookRegistryService.collectPlaybooks()
-
     const pluginContributions = Object.values(pluginRuntime).map((plugin) => plugin.contributions)
     const schemaFiles = [...getBuiltInSchemaFiles(), ...(runtimeConfig.extraSchemaFiles ?? [])]
     const hostContributionSchemaFiles = pluginContributions.flatMap((plugin) => plugin.schemaFiles)
@@ -417,7 +402,6 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
         isApprovalContinuationRequest: isApprovalContinuationRequestSingleton,
         runWorkstreamTurnInBackground: runWorkstreamTurnInBackgroundSingleton,
         triggerPlanNodeTurn: triggerPlanNodeTurnSingleton,
-        syncPlaybookTemplates: playbookRegistryService.syncPlaybookTemplates.bind(playbookRegistryService),
       },
       lota,
       redis: {

package/src/db/memory-types.ts

@@ -14,6 +14,9 @@ export type MemoryType = z.infer<typeof MemoryTypeSchema>
 export const DurabilitySchema = z.enum(['core', 'standard', 'ephemeral'])
 export type Durability = z.infer<typeof DurabilitySchema>
 
+export const MemoryImportanceClassificationSchema = z.enum(['durable', 'transient', 'uncertain'])
+export type MemoryImportanceClassification = z.infer<typeof MemoryImportanceClassificationSchema>
+
 export const MemoryEventSchema = z.enum(['ADD', 'UPDATE', 'DELETE', 'NONE'])
 export type MemoryEvent = z.infer<typeof MemoryEventSchema>
 
@@ -103,6 +106,15 @@ const ExtractedFactSchema = z.object({
     .describe(
       'core: business decisions, technical architecture, confirmed requirements. standard: general facts, moderate inferences. ephemeral: preferences, one-off interactions, formatting choices.',
     ),
+  importance: z
+    .number()
+    .min(0)
+    .max(1)
+    .describe('Long-term usefulness score from 0 to 1 for storing this fact as memory.'),
+  classification: MemoryImportanceClassificationSchema.describe(
+    'Whether this fact is durable enough for long-term memory.',
+  ),
+  rationale: z.string().min(1).describe('Concise rationale for the importance and classification.'),
 })
 
 export type ExtractedFact = z.infer<typeof ExtractedFactSchema>
@@ -186,14 +198,7 @@ const MemoryDeltaItemSchema = z
 export const MemoryDeltaSchema = z
   .object({ deltas: z.array(MemoryDeltaItemSchema).describe('Classification output for each new fact.') })
   .strict()
-export const MemoryImportanceAssessmentSchema = z
-  .object({
-    importance: z.number().min(0).max(1).describe('Long-term usefulness score from 0 to 1 for storing this memory.'),
-    durability: DurabilitySchema.describe('Expected durability for this memory.'),
-    classification: z.enum(['durable', 'transient', 'uncertain']).describe('Durability classification for storage.'),
-    rationale: z.string().min(1).describe('Concise rationale for the score/classification.'),
-  })
-  .strict()
+export type MemoryDeltaOutput = z.infer<typeof MemoryDeltaSchema>
 export interface Message {
   role: 'user' | 'agent'
   content: string

package/src/db/memory.ts

@@ -1,3 +1,5 @@
+import type { z } from 'zod'
+
 import { aiLogger } from '../config/logger'
 import type { CreateHelperAgentFn } from '../runtime/helper-model'
 import { createHelperModelRuntime } from '../runtime/helper-model'
@@ -7,6 +9,7 @@ import {
   compileMemoryUpdatesFromDelta,
   createMemoryActionPlan,
   postProcessMemoryFacts,
+  projectMemoryDeltaToScope,
 } from '../runtime/memory-pipeline'
 import { getFactRetrievalMessages } from '../runtime/memory-prompts-fact'
 import { parseMessages } from '../runtime/memory-prompts-parse'
@@ -50,6 +53,12 @@ interface PreparedScopeUpdate {
   existingMemories: Array<{ id: string; text: string }>
 }
 
+interface ScopedExistingMemories {
+  options: AddOptions
+  existingMemories: Array<{ id: string; text: string }>
+  scopeMemoryIdsByUnionId: Record<string, string[]>
+}
+
 export class Memory {
   private store: SurrealMemoryStore
   private createAgent: CreateHelperAgentFn
@@ -72,6 +81,12 @@ export class Memory {
     return sections.join('\n\n')
   }
 
+  private buildMemoryUnionId(text: string): string | null {
+    const normalized = this.normalizeMemoryDeltaText(text, MEMORY_DELTA_MEMORY_TEXT_MAX_CHARS)
+    if (!normalized) return null
+    return `union_${new Bun.CryptoHasher('sha256').update(normalized).digest('hex')}`
+  }
+
   async insert(
     content: string,
     options: {
@@ -166,33 +181,6 @@ export class Memory {
     return this.store.getStaleMemories(scopeId, limit)
   }
 
-  async add(
-    messages: Message[],
-    options: AddOptions,
-    extractionOptions?: { customPrompt?: string; maxFacts?: number },
-  ): Promise<void> {
-    const facts = await this.extractFactsFromMessages(messages, extractionOptions)
-    if (facts.length === 0) return
-
-    aiLogger.debug`Extracted ${facts.length} facts from conversation`
-
-    await this.applyFactsToScope(facts, options)
-  }
-
-  async addMultiScope(
-    messages: Message[],
-    scopes: AddOptions[],
-    extractionOptions?: { customPrompt?: string; maxFacts?: number },
-  ): Promise<void> {
-    if (scopes.length === 0) return
-    const facts = await this.extractFactsFromMessages(messages, extractionOptions)
-    if (facts.length === 0) return
-
-    aiLogger.debug`Extracted ${facts.length} facts, applying to ${scopes.length} scopes`
-
-    await this.applyFactsToScopes(facts, scopes)
-  }
-
   async extractFactsFromMessages(
     messages: Message[],
     extractionOptions?: { customPrompt?: string; maxFacts?: number },
@@ -220,11 +208,52 @@ export class Memory {
   async prepareFactsToScopes(facts: ExtractedFact[], scopes: AddOptions[]): Promise<PreparedScopeUpdate[]> {
     if (facts.length === 0 || scopes.length === 0) return []
 
-    const prepared: PreparedScopeUpdate[] = []
-    for (const scopeOptions of scopes) {
-      prepared.push(await this.prepareFactsForScope(facts, scopeOptions))
+    const factMaps = buildMemoryFactMaps(facts)
+    const factContents = facts.map((fact) => fact.content)
+    const scopePayloads: ScopedExistingMemories[] = await Promise.all(
+      scopes.map(async (scopeOptions) => {
+        const existingMemories = await this.store.list({
+          scopeId: scopeOptions.scopeId,
+          memoryType: scopeOptions.memoryType,
+        })
+        const normalizedMemories = existingMemories.map((memory) => ({ id: memory.id, text: memory.content }))
+        const scopeMemoryIdsByUnionId: Record<string, string[]> = {}
+        for (const memory of normalizedMemories) {
+          const unionId = this.buildMemoryUnionId(memory.text)
+          if (!unionId) continue
+          ;(scopeMemoryIdsByUnionId[unionId] ??= []).push(memory.id)
+        }
+        return { options: scopeOptions, existingMemories: normalizedMemories, scopeMemoryIdsByUnionId }
+      }),
+    )
+    const unionMemories = new Map<string, { id: string; text: string }>()
+    for (const scopePayload of scopePayloads) {
+      for (const memory of scopePayload.existingMemories) {
+        const unionId = this.buildMemoryUnionId(memory.text)
+        if (!unionId || unionMemories.has(unionId)) continue
+        const normalizedText = this.normalizeMemoryDeltaText(memory.text, MEMORY_DELTA_MEMORY_TEXT_MAX_CHARS)
+        if (!normalizedText) continue
+        unionMemories.set(unionId, { id: unionId, text: normalizedText })
+      }
     }
-    return prepared
+
+    const delta = await this.determineDelta([...unionMemories.values()], factContents)
+    return scopePayloads.map(({ options, existingMemories, scopeMemoryIdsByUnionId }) => ({
+      options,
+      updates: MemoryUpdateSchema.parse(
+        compileMemoryUpdatesFromDelta({
+          existingMemories,
+          newFacts: factContents,
+          delta: projectMemoryDeltaToScope({
+            delta,
+            scopeMemoryIds: existingMemories.map((memory) => memory.id),
+            scopeMemoryIdsByUnionId,
+          }),
+        }),
+      ),
+      factMaps,
+      existingMemories,
+    }))
   }
 
   async applyPreparedScopeUpdates(prepared: PreparedScopeUpdate[]): Promise<void> {
@@ -235,23 +264,6 @@ export class Memory {
     }
   }
 
-  private async applyFactsToScope(facts: ExtractedFact[], options: AddOptions): Promise<void> {
-    const prepared = await this.prepareFactsForScope(facts, options)
-    await this.applyPreparedScopeUpdates([prepared])
-  }
-
-  private async prepareFactsForScope(facts: ExtractedFact[], options: AddOptions): Promise<PreparedScopeUpdate> {
-    const factMaps = buildMemoryFactMaps(facts)
-
-    const existingMemories = await this.store.list({ scopeId: options.scopeId, memoryType: options.memoryType })
-    const memoryDeltaInput = existingMemories.map((m) => ({ id: m.id, text: m.content }))
-
-    const factContents = facts.map((f) => f.content)
-    const updates = await this.determineUpdates(memoryDeltaInput, factContents)
-
-    return { options, updates, factMaps, existingMemories: memoryDeltaInput }
-  }
-
   private async extractFacts(
     parsedMessages: string,
     extractionOptions?: { customPrompt?: string; maxFacts?: number },
@@ -284,12 +296,21 @@ export class Memory {
     }
   }
 
-  private async determineUpdates(
+  private async determineDelta(
     existingMemories: { id: string; text: string }[],
     newFacts: string[],
-  ): Promise<MemoryUpdateOutput> {
+  ): Promise<{ deltas: Array<z.infer<typeof MemoryDeltaSchema>['deltas'][number]> }> {
     if (existingMemories.length === 0) {
-      return { memory: newFacts.map((fact, index) => ({ id: `new_${index}`, text: fact, event: 'ADD' as const })) }
+      return {
+        deltas: newFacts.map((fact) => ({
+          fact,
+          classification: 'new' as const,
+          targetMemoryIds: [],
+          invalidateTargetIds: [],
+          relations: [],
+          rationale: 'No existing memories in scope.',
+        })),
+      }
     }
 
     const candidateMemories = this.selectDeltaCandidateMemories(existingMemories, newFacts)
@@ -306,8 +327,7 @@ export class Memory {
         messages: [{ role: 'user', content: userPrompt }],
         schema: MemoryDeltaSchema,
       })
-      const compiled = compileMemoryUpdatesFromDelta({ existingMemories, newFacts, delta: deltas })
-      return MemoryUpdateSchema.parse(compiled)
+      return deltas
     } catch (error) {
       aiLogger.error`Failed to determine memory updates: ${error}`
       throw error
@@ -431,6 +451,7 @@ export class Memory {
       updates,
       memoryType: options.memoryType,
       explicitImportance: options.importance,
+      extractedImportanceByKey: factMaps.extractedImportanceByKey,
       confidenceByKey: factMaps.confidenceByKey,
       durabilityByKey: factMaps.durabilityByKey,
       categoryByKey: factMaps.categoryByKey,

package/src/queues/autonomous-job.queue.ts

@@ -5,6 +5,7 @@ import { serverLogger } from '../config/logger'
 import { databaseService } from '../db/service'
 import { autonomousJobService } from '../services/autonomous-job.service'
 import { queueJobService } from '../services/queue-job.service'
+import { buildAutonomousAtJobId } from '../utils/autonomous-job-ids'
 import type { WorkerHandle } from '../workers/worker-utils'
 import { DEFAULT_JOB_RETENTION } from '../workers/worker-utils'
 import { createQueueFactory } from './queue-factory'
@@ -43,14 +44,6 @@ function buildAutonomousSchedulerId(autonomousJobId: string): string {
   return `autonomous:${autonomousJobId}`
 }
 
-function encodeBullmqId(raw: string): string {
-  return Buffer.from(raw).toString('base64url')
-}
-
-export function buildAutonomousAtJobId(autonomousJobId: string): string {
-  return `autonomous-at-${encodeBullmqId(autonomousJobId)}`
-}
-
 export async function enqueueAutonomousJobRun(params: {
   payload: AutonomousJobQueuePayload
   delayMs?: number

package/src/queues/context-compaction.queue.ts

@@ -18,11 +18,11 @@ async function processContextCompactionJob(job: Job<ContextCompactionJob>): Prom
 
   const { entityId, contextSize } = job.data
   const workstreamRef = ensureRecordId(entityId, TABLES.WORKSTREAM)
-  await workstreamService.markCompacting(workstreamRef)
+  await workstreamService.setCompacting(workstreamRef, true)
   try {
     await contextCompactionService.compactWorkstreamHistory({ workstreamId: workstreamRef, contextSize })
   } finally {
-    await workstreamService.clearCompacting(workstreamRef)
+    await workstreamService.setCompacting(workstreamRef, false)
   }
 }
 

package/src/queues/index.ts

@@ -4,12 +4,8 @@ export * from './context-compaction.queue'
 export * from './delayed-node-promotion.queue'
 export * from './document-processor.queue'
 export * from './memory-consolidation.queue'
+export * from './organization-learning.queue'
 export * from './plan-agent-heartbeat.queue'
 export * from './plan-scheduler.queue'
 export * from './post-chat-memory.queue'
-export * from './recent-activity-title-refinement.queue'
-export * from './regular-chat-memory-digest.config'
-export * from './regular-chat-memory-digest.queue'
-export * from './skill-extraction.config'
-export * from './skill-extraction.queue'
-export * from './workstream-title-generation.queue'
+export * from './title-generation.queue'

package/src/queues/organization-learning.queue.ts

@@ -0,0 +1,78 @@
+import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
+import { createQueueFactory } from './queue-factory'
+
+export const ORGANIZATION_LEARNING_QUEUE = 'organization-learning'
+
+const ORGANIZATION_LEARNING_DELAY_MS = 15 * 60 * 1000
+
+// This queue merges the two organization-scoped background learning jobs:
+// delayed regular-chat memory digestion and skill extraction.
+
+export interface RegularChatMemoryDigestJob {
+  kind: 'regular-chat-memory-digest'
+  orgId: string
+}
+
+export interface SkillExtractionJob {
+  kind: 'skill-extraction'
+  orgId: string
+}
+
+export type OrganizationLearningJob = RegularChatMemoryDigestJob | SkillExtractionJob
+
+function buildOrganizationLearningDeduplicationId(kind: OrganizationLearningJob['kind'], orgId: string): string {
+  return kind === 'regular-chat-memory-digest' ? `regular-chat-digest:${orgId}` : `skill-extraction:${orgId}`
+}
+
+export function buildRegularChatMemoryDigestDeduplicationId(orgId: string): string {
+  return buildOrganizationLearningDeduplicationId('regular-chat-memory-digest', orgId)
+}
+
+export function buildRegularChatMemoryDigestJobOptions(orgId: string) {
+  return {
+    delay: ORGANIZATION_LEARNING_DELAY_MS,
+    deduplication: { id: buildRegularChatMemoryDigestDeduplicationId(orgId) },
+  }
+}
+
+export function buildSkillExtractionDeduplicationId(orgId: string): string {
+  return buildOrganizationLearningDeduplicationId('skill-extraction', orgId)
+}
+
+export function buildSkillExtractionJobOptions(orgId: string) {
+  return { delay: ORGANIZATION_LEARNING_DELAY_MS, deduplication: { id: buildSkillExtractionDeduplicationId(orgId) } }
+}
+
+const organizationLearningQueue = createQueueFactory<OrganizationLearningJob>({
+  name: ORGANIZATION_LEARNING_QUEUE,
+  displayName: 'Organization learning',
+  jobName: 'organization-learning',
+  concurrency: 4,
+  lockDuration: LONG_JOB_LOCK_DURATION_MS,
+  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 5_000 } },
+  processorPath: getWorkerPath('organization-learning.worker.ts'),
+})
+
+export function enqueueRegularChatMemoryDigest(job: Omit<RegularChatMemoryDigestJob, 'kind'>) {
+  return organizationLearningQueue.enqueue(
+    { kind: 'regular-chat-memory-digest', ...job },
+    buildRegularChatMemoryDigestJobOptions(job.orgId),
+  )
+}
+
+export function enqueueSkillExtraction(job: Omit<SkillExtractionJob, 'kind'>) {
+  return organizationLearningQueue.enqueue(
+    { kind: 'skill-extraction', ...job },
+    buildSkillExtractionJobOptions(job.orgId),
+  )
+}
+
+export async function clearRegularChatMemoryDigestDeduplicationKey(orgId: string): Promise<void> {
+  await organizationLearningQueue.getQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId))
+}
+
+export const startOrganizationLearningWorker = organizationLearningQueue.startWorker
+
+if (import.meta.main) {
+  startOrganizationLearningWorker()
+}