@lota-sdk/core 0.1.24 → 0.1.25

package/src/tools/remember-memory.tool.ts

@@ -4,7 +4,6 @@ import { z } from 'zod'
 import type { RecordIdRef } from '../db/record-id'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
-import { assessMemoryImportance, clampMemoryImportance } from '../services/memory-assessment.service'
 import { memoryService } from '../services/memory.service'
 import { safeEnqueue } from '../utils/async'
 
@@ -29,17 +28,15 @@ export function createRememberMemoryTool({ orgId, agentName }: { orgId: RecordId
       const orgIdString = recordIdToString(orgId, TABLES.ORGANIZATION)
       void safeEnqueue(
         async () => {
-          const assessment = await assessMemoryImportance({
-            content: trimmed,
-            targetScope,
-            tag: 'memory-importance-assessment',
-          })
-
+          const assessment = await memoryService.assessMemoryCandidate({ orgId: orgIdString, content: trimmed })
+          if (!assessment) {
+            return
+          }
           if (assessment.classification === 'transient' && assessment.durability === 'ephemeral') {
             return
           }
 
-          const importance = Math.round(clampMemoryImportance(assessment.importance) * 100) / 100
+          const importance = Math.round(assessment.importance * 100) / 100
 
           if (targetScope === 'global') {
             await memoryService.createOrganizationMemory({
@@ -51,7 +48,7 @@ export function createRememberMemoryTool({ orgId, agentName }: { orgId: RecordId
                 source: 'agent_tool',
                 agentName,
                 memoryScope: 'global',
-                importanceSource: 'model_assessed',
+                importanceSource: 'extraction_assessed',
                 durability: assessment.durability,
                 classification: assessment.classification,
                 rationale: assessment.rationale,
@@ -69,7 +66,7 @@ export function createRememberMemoryTool({ orgId, agentName }: { orgId: RecordId
             metadata: {
               source: 'agent_tool',
               memoryScope: 'agent',
-              importanceSource: 'model_assessed',
+              importanceSource: 'extraction_assessed',
               durability: assessment.durability,
               classification: assessment.classification,
               rationale: assessment.rationale,

package/src/tools/research-topic.tool.ts

@@ -12,7 +12,7 @@ import { searchWebTool } from './search-web.tool'
 export const researchTopicTool = createDelegatedAgentTool({
   id: 'researchTopic',
   description:
-    'Delegate a research task to a dedicated research agent that searches the web, fetches pages, and returns a synthesized markdown report. Call multiple instances in parallel for broad research across different topics.',
+    'Delegate a research task to a dedicated research agent that searches the web, fetches pages, and returns a synthesized markdown report.',
   model: () => aiGatewayChatModel(OPENROUTER_WEB_RESEARCH_MODEL_ID),
   providerOptions: OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS,
   headers: buildAiGatewayStrictSemanticCacheHeaders('researchTopic'),

package/src/tools/team-think.tool.ts

@@ -18,7 +18,7 @@ import type { ReadableUploadMetadata } from '../services/attachment.service'
 async function buildTeamThinkAgentTools(
   params: LotaRuntimeTeamThinkToolsParams,
 ): Promise<{ tools: Record<string, unknown> }> {
-  const builder = getRuntimeAdapters().workstream?.buildTeamThinkAgentTools
+  const builder = getRuntimeAdapters().buildTeamThinkAgentTools
   if (!builder) {
     return { tools: {} }
   }

package/src/tools/user-questions.tool.ts

@@ -9,7 +9,7 @@ export const userQuestionsTool = {
   create: () =>
     tool({
       description:
-        'Present structured questions to the user and wait for their response. The chat UI already renders the questions, so do not repeat them as assistant text. Use this when you need clarification or input from the user. Execution stops after this tool is called.',
+        'Ask the user structured questions. UI renders them; do not repeat them in text. Turn ends after this call.',
       inputSchema: UserQuestionsArgsSchema,
       execute: async (_args: UserQuestionsArgs) => {
         return 'Questions have been presented to the user in the chat UI. Do NOT restate them in text, and do NOT generate further text or tool calls. Your turn is complete.'

package/src/utils/autonomous-job-ids.ts

@@ -0,0 +1,7 @@
+export function encodeBullmqId(raw: string): string {
+  return Buffer.from(raw).toString('base64url')
+}
+
+export function buildAutonomousAtJobId(autonomousJobId: string): string {
+  return `autonomous-at-${encodeBullmqId(autonomousJobId)}`
+}

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

@@ -0,0 +1,31 @@
+import type { SandboxedJob } from 'bullmq'
+
+import { serverLogger } from '../config/logger'
+import type { OrganizationLearningJob } from '../queues/organization-learning.queue'
+import { initializeSandboxedWorkerRuntime } from './bootstrap'
+import { runRegularChatMemoryDigest } from './regular-chat-memory-digest.runner'
+import { runSkillExtraction } from './skill-extraction.runner'
+import { toSandboxedWorkerError } from './utils/sandbox-error'
+import { createTracedWorkerProcessor } from './worker-utils'
+
+await initializeSandboxedWorkerRuntime()
+
+// One sandboxed worker handles both organization-learning branches so the
+// queue can dispatch digest and skill jobs without separate worker images.
+const handler = async (job: SandboxedJob<OrganizationLearningJob>) => {
+  try {
+    if (job.data.kind === 'regular-chat-memory-digest') {
+      await runRegularChatMemoryDigest(job.data)
+      return
+    }
+    await runSkillExtraction(job.data)
+  } catch (error) {
+    const message =
+      job.data.kind === 'regular-chat-memory-digest' ? 'Regular chat memory digest failed' : 'Skill extraction failed'
+    const serialized = toSandboxedWorkerError(error, message)
+    serverLogger.error`${serialized.message}`
+    throw serialized
+  }
+}
+
+export default createTracedWorkerProcessor('organization-learning', handler)

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

@@ -9,8 +9,8 @@ import { TABLES } from '../db/tables'
 import {
   clearRegularChatMemoryDigestDeduplicationKey,
   enqueueRegularChatMemoryDigest,
-} from '../queues/regular-chat-memory-digest.queue'
-import type { RegularChatMemoryDigestJob } from '../queues/regular-chat-memory-digest.queue'
+} from '../queues/organization-learning.queue'
+import type { RegularChatMemoryDigestJob } from '../queues/organization-learning.queue'
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import { getRuntimeAdapters, withConfiguredWorkspaceMemoryLock } from '../runtime/runtime-extensions'
 import { memoryService } from '../services/memory.service'
@@ -26,6 +26,9 @@ import {
 } from './utils/workstream-message-query'
 import type { DigestCursor, DigestMessage } from './utils/workstream-message-query'
 
+// Onboarding extracts memory immediately inside the turn flow. This delayed
+// runner handles the regular-chat path after onboarding so longer transcripts
+// can be digested into durable memory and profile projections in the background.
 const StructuredProfilePatchSchema = z.record(z.string(), z.unknown()).default({})
 
 const REGULAR_CHAT_MEMORY_DIGEST_TIMEOUT_MS = 10 * 60 * 1000
@@ -36,6 +39,9 @@ const ExtractedFactSchema = z.object({
   type: z.enum(['fact', 'preference', 'decision']),
   confidence: z.number().min(0).max(1),
   durability: z.enum(['core', 'standard', 'ephemeral']),
+  importance: z.number().min(0).max(1),
+  classification: z.enum(['durable', 'transient', 'uncertain']),
+  rationale: z.string().trim().min(1),
 })
 
 const RegularChatMemoryDigestOutputSchema = z.object({
@@ -151,7 +157,7 @@ export async function runRegularChatMemoryDigest(
 ): Promise<RegularChatDigestRunResult> {
   const orgRef = ensureRecordId(data.orgId, TABLES.ORGANIZATION)
   const orgId = recordIdToString(orgRef, TABLES.ORGANIZATION)
-  const workspaceProvider = getRuntimeAdapters().services?.workspaceProvider
+  const workspaceProvider = getRuntimeAdapters().workspaceProvider
   if (!workspaceProvider) {
     serverLogger.info`Skipping regular chat memory digest for ${orgId}: workspaceProvider is not configured`
     return { skipped: true, processedWorkstreamMessages: 0, processedSocialMessages: 0, followUpScheduled: false }

package/src/workers/skill-extraction.runner.ts

@@ -2,7 +2,7 @@ import { serverLogger } from '../config/logger'
 import { ensureRecordId, recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
 import { getDefaultEmbeddings } from '../embeddings/provider'
-import type { SkillExtractionJob } from '../queues/skill-extraction.queue'
+import type { SkillExtractionJob } from '../queues/organization-learning.queue'
 import { createHelperModelRuntime } from '../runtime/helper-model'
 import { getRuntimeAdapters, withConfiguredWorkspaceMemoryLock } from '../runtime/runtime-extensions'
 import { learnedSkillService } from '../services/learned-skill.service'
@@ -74,7 +74,7 @@ function buildManagerPrompt(params: {
 export async function runSkillExtraction(data: SkillExtractionJob): Promise<SkillExtractionRunResult> {
   const orgRef = ensureRecordId(data.orgId, TABLES.ORGANIZATION)
   const orgId = recordIdToString(orgRef, TABLES.ORGANIZATION)
-  const workspaceProvider = getRuntimeAdapters().services?.workspaceProvider
+  const workspaceProvider = getRuntimeAdapters().workspaceProvider
   const cursorAwareWorkspaceProvider =
     workspaceProvider?.getBackgroundCursor && workspaceProvider.setBackgroundCursor
       ? (workspaceProvider as typeof workspaceProvider & {

package/src/queues/recent-activity-title-refinement.queue.ts

@@ -1,30 +0,0 @@
-import type { Job } from 'bullmq'
-
-import { databaseService } from '../db/service'
-import { recentActivityTitleService } from '../services/recent-activity-title.service'
-import { createQueueFactory } from './queue-factory'
-
-interface RecentActivityTitleRefinementJob {
-  activityId: string
-}
-
-async function processRecentActivityTitleRefinementJob(job: Job<RecentActivityTitleRefinementJob>): Promise<void> {
-  await databaseService.connect()
-  await recentActivityTitleService.refineRecentActivityTitle(job.data.activityId)
-}
-
-const recentActivityTitleRefinement = createQueueFactory<RecentActivityTitleRefinementJob>({
-  name: 'recent-activity-title-refinement',
-  displayName: 'Recent activity title refinement',
-  jobName: 'refine-recent-activity-title',
-  concurrency: 10,
-  lockDuration: 300_000,
-  defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
-  processor: processRecentActivityTitleRefinementJob,
-})
-
-export function enqueueRecentActivityTitleRefinement(job: RecentActivityTitleRefinementJob) {
-  return recentActivityTitleRefinement.enqueue(job, { jobId: `recent-activity-title:${job.activityId}` })
-}
-
-export const startRecentActivityTitleRefinementWorker = recentActivityTitleRefinement.startWorker

package/src/queues/regular-chat-memory-digest.config.ts

@@ -1,12 +0,0 @@
-const REGULAR_CHAT_MEMORY_DIGEST_DELAY_MS = 15 * 60 * 1000
-
-export function buildRegularChatMemoryDigestDeduplicationId(orgId: string): string {
-  return `regular-chat-digest:${orgId}`
-}
-
-export function buildRegularChatMemoryDigestJobOptions(orgId: string) {
-  return {
-    delay: REGULAR_CHAT_MEMORY_DIGEST_DELAY_MS,
-    deduplication: { id: buildRegularChatMemoryDigestDeduplicationId(orgId) },
-  }
-}

package/src/queues/regular-chat-memory-digest.queue.ts

@@ -1,34 +0,0 @@
-import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
-import { createQueueFactory } from './queue-factory'
-import {
-  buildRegularChatMemoryDigestDeduplicationId,
-  buildRegularChatMemoryDigestJobOptions,
-} from './regular-chat-memory-digest.config'
-
-export interface RegularChatMemoryDigestJob {
-  orgId: string
-}
-
-const regularChatMemoryDigest = createQueueFactory<RegularChatMemoryDigestJob>({
-  name: 'regular-chat-memory-digest',
-  displayName: 'Regular chat memory digest',
-  jobName: 'run-digest',
-  concurrency: 1,
-  lockDuration: LONG_JOB_LOCK_DURATION_MS,
-  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
-  processorPath: getWorkerPath('regular-chat-memory-digest.worker.ts'),
-})
-
-export function enqueueRegularChatMemoryDigest(job: RegularChatMemoryDigestJob) {
-  return regularChatMemoryDigest.enqueue(job, buildRegularChatMemoryDigestJobOptions(job.orgId))
-}
-
-export async function clearRegularChatMemoryDigestDeduplicationKey(orgId: string): Promise<void> {
-  await regularChatMemoryDigest.getQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId))
-}
-
-export const startRegularChatMemoryDigestWorker = regularChatMemoryDigest.startWorker
-
-if (import.meta.main) {
-  startRegularChatMemoryDigestWorker()
-}

package/src/queues/skill-extraction.config.ts

@@ -1,9 +0,0 @@
-const SKILL_EXTRACTION_DELAY_MS = 15 * 60 * 1000
-
-export function buildSkillExtractionDeduplicationId(orgId: string): string {
-  return `skill-extraction:${orgId}`
-}
-
-export function buildSkillExtractionJobOptions(orgId: string) {
-  return { delay: SKILL_EXTRACTION_DELAY_MS, deduplication: { id: buildSkillExtractionDeduplicationId(orgId) } }
-}

package/src/queues/skill-extraction.queue.ts

@@ -1,27 +0,0 @@
-import { getWorkerPath } from '../workers/worker-utils'
-import { createQueueFactory } from './queue-factory'
-import { buildSkillExtractionJobOptions } from './skill-extraction.config'
-
-export interface SkillExtractionJob {
-  orgId: string
-}
-
-const skillExtraction = createQueueFactory<SkillExtractionJob>({
-  name: 'skill-extraction',
-  displayName: 'Skill extraction',
-  jobName: 'run-extraction',
-  concurrency: 10,
-  lockDuration: 600_000,
-  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
-  processorPath: getWorkerPath('skill-extraction.worker.ts'),
-})
-
-export function enqueueSkillExtraction(job: SkillExtractionJob) {
-  return skillExtraction.enqueue(job, buildSkillExtractionJobOptions(job.orgId))
-}
-
-export const startSkillExtractionWorker = skillExtraction.startWorker
-
-if (import.meta.main) {
-  startSkillExtractionWorker()
-}

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

@@ -1,33 +0,0 @@
-import type { Job } from 'bullmq'
-
-import { ensureRecordId } from '../db/record-id'
-import { databaseService } from '../db/service'
-import { workstreamTitleService } from '../services/workstream-title.service'
-import { createQueueFactory } from './queue-factory'
-
-interface WorkstreamTitleGenerationJob {
-  workstreamId: string
-  sourceText: string
-}
-
-async function processWorkstreamTitleGenerationJob(job: Job<WorkstreamTitleGenerationJob>): Promise<void> {
-  await databaseService.connect()
-  const workstreamRef = ensureRecordId(job.data.workstreamId)
-  await workstreamTitleService.generateAndPersistTitle(workstreamRef, job.data.sourceText)
-}
-
-const workstreamTitleGeneration = createQueueFactory<WorkstreamTitleGenerationJob>({
-  name: 'workstream-title-generation',
-  displayName: 'Workstream title generation',
-  jobName: 'generate-workstream-title',
-  concurrency: 10,
-  lockDuration: 60_000,
-  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 2_000 } },
-  processor: processWorkstreamTitleGenerationJob,
-})
-
-export function enqueueWorkstreamTitleGeneration(job: WorkstreamTitleGenerationJob) {
-  return workstreamTitleGeneration.enqueue(job, { jobId: `workstream-title:${job.workstreamId}` })
-}
-
-export const startWorkstreamTitleGenerationWorker = workstreamTitleGeneration.startWorker

package/src/services/context-enrichment.service.ts

@@ -1,33 +0,0 @@
-import type { ContextEnrichment } from '@lota-sdk/shared'
-
-import { serverLogger } from '../config/logger'
-import { getRuntimeConfig } from '../runtime/runtime-config'
-
-class ContextEnrichmentService {
-  async enrichForPlanCreation(params: { objective: string; organizationId: string }): Promise<ContextEnrichment[]> {
-    const pluginRuntime = getRuntimeConfig().pluginRuntime ?? {}
-    const enrichers = Object.values(pluginRuntime).flatMap((plugin) => plugin.contextEnrichers ?? [])
-
-    if (enrichers.length === 0) return []
-
-    const results = await Promise.allSettled(
-      enrichers.map((enricher) =>
-        enricher.enrich({ objective: params.objective, organizationId: params.organizationId }),
-      ),
-    )
-
-    const enrichments: ContextEnrichment[] = []
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i]
-      if (result.status === 'fulfilled') {
-        enrichments.push({ domain: enrichers[i].domain, data: result.value.data, confidence: result.value.confidence })
-      } else {
-        serverLogger.warn`Context enricher "${enrichers[i].domain}" failed: ${result.reason}`
-      }
-    }
-
-    return enrichments.sort((a, b) => b.confidence - a.confidence)
-  }
-}
-
-export const contextEnrichmentService = new ContextEnrichmentService()

package/src/services/coordination-registry.service.ts

@@ -1,117 +0,0 @@
-import type { SignalDeclaration } from '@lota-sdk/shared'
-
-import { serverLogger } from '../config/logger'
-import type { LotaPlugin } from '../runtime/plugin-types'
-import { getRuntimeConfig } from '../runtime/runtime-config'
-import type { PlanValidationIssueInput } from './plan-validator.service'
-
-export interface EmittedSignal {
-  signal: string
-  payload: unknown
-  sourcePlugin: string
-  consumers: string[]
-  emittedAt: Date
-}
-
-const MAX_EMITTED_SIGNALS = 1000
-
-class CoordinationRegistryService {
-  private producers = new Map<string, string[]>()
-  private consumers = new Map<string, string[]>()
-  private _emittedSignals: EmittedSignal[] = []
-
-  register(pluginRef: string, signals: SignalDeclaration[]): void {
-    for (const signal of signals) {
-      if (signal.direction === 'produces') {
-        const existing = this.producers.get(signal.signalName) ?? []
-        existing.push(pluginRef)
-        this.producers.set(signal.signalName, existing)
-      } else {
-        const existing = this.consumers.get(signal.signalName) ?? []
-        existing.push(pluginRef)
-        this.consumers.set(signal.signalName, existing)
-      }
-    }
-  }
-
-  async emit(signal: string, payload: unknown, sourcePlugin: string): Promise<void> {
-    const consumers = this.consumers.get(signal) ?? []
-
-    this._emittedSignals.push({ signal, payload, sourcePlugin, consumers: [...consumers], emittedAt: new Date() })
-    if (this._emittedSignals.length > MAX_EMITTED_SIGNALS) {
-      this._emittedSignals.shift()
-    }
-
-    serverLogger.debug(
-      `Signal "${signal}" emitted by "${sourcePlugin}" — ${consumers.length} consumer(s): ${consumers.join(', ') || 'none'}`,
-    )
-
-    if (consumers.length === 0) return
-
-    let pluginRuntime: Record<string, unknown> = {}
-    try {
-      pluginRuntime = getRuntimeConfig().pluginRuntime ?? {}
-    } catch {
-      // Runtime not yet configured — skip plugin dispatch
-    }
-
-    for (const consumerRef of consumers) {
-      const plugin = pluginRuntime[consumerRef] as LotaPlugin | undefined
-      if (plugin?.onSignal) {
-        try {
-          await plugin.onSignal(signal, payload, sourcePlugin)
-        } catch (error) {
-          serverLogger.warn`Signal handler for "${consumerRef}" failed on signal "${signal}": ${error}`
-        }
-      }
-    }
-  }
-
-  getEmittedSignals(signalName?: string): EmittedSignal[] {
-    if (!signalName) return [...this._emittedSignals]
-    return this._emittedSignals.filter((entry) => entry.signal === signalName)
-  }
-
-  getProducers(signalName: string): string[] {
-    return this.producers.get(signalName) ?? []
-  }
-
-  getConsumers(signalName: string): string[] {
-    return this.consumers.get(signalName) ?? []
-  }
-
-  validate(): PlanValidationIssueInput[] {
-    const issues: PlanValidationIssueInput[] = []
-
-    for (const [signalName] of this.producers) {
-      if ((this.consumers.get(signalName) ?? []).length === 0) {
-        issues.push({
-          severity: 'warning',
-          code: 'signal_no_consumer',
-          message: `Signal "${signalName}" is produced but has no consumers.`,
-        })
-      }
-    }
-
-    for (const [signalName] of this.consumers) {
-      if ((this.producers.get(signalName) ?? []).length === 0) {
-        issues.push({
-          severity: 'warning',
-          code: 'signal_no_producer',
-          message: `Signal "${signalName}" is consumed but has no producers.`,
-        })
-      }
-    }
-
-    return issues
-  }
-
-  /** Reset internal state. Intended for testing. */
-  _reset(): void {
-    this.producers.clear()
-    this.consumers.clear()
-    this._emittedSignals = []
-  }
-}
-
-export const coordinationRegistryService = new CoordinationRegistryService()

package/src/services/domain-agent-executor.service.ts

@@ -1,71 +0,0 @@
-import type { OwnershipDispatchContext, PlanArtifactSubmission, PlanNodeResult, PlanNodeSpec } from '@lota-sdk/shared'
-
-import type { LotaPlugin, PluginDomainAgentDefinition } from '../runtime/plugin-types'
-import { getRuntimeConfig } from '../runtime/runtime-config'
-import type { PlanValidationIssueInput } from './plan-validator.service'
-
-class DomainAgentExecutorService {
-  private registry = new Map<string, { pluginRef: string; definition: PluginDomainAgentDefinition }>()
-
-  configure(pluginRuntime: Record<string, LotaPlugin>): void {
-    this.registry.clear()
-    for (const [pluginRef, plugin] of Object.entries(pluginRuntime)) {
-      if (plugin.domainAgents) {
-        for (const def of plugin.domainAgents) {
-          this.registry.set(def.agentId, { pluginRef, definition: def })
-        }
-      }
-    }
-  }
-
-  hasAgent(agentId: string): boolean {
-    return this.registry.has(agentId)
-  }
-
-  validateOwner(agentId: string, nodeId: string): PlanValidationIssueInput[] {
-    if (!this.registry.has(agentId)) {
-      return [
-        {
-          severity: 'blocking',
-          code: 'domain_agent_missing',
-          message: `Node "${nodeId}" references unknown domain agent "${agentId}".`,
-          nodeId,
-        },
-      ]
-    }
-    return []
-  }
-
-  async executeNode(params: {
-    nodeSpec: PlanNodeSpec
-    resolvedInput: Record<string, unknown>
-    inputArtifacts: PlanArtifactSubmission[]
-    context: OwnershipDispatchContext
-  }): Promise<PlanNodeResult> {
-    const entry = this.registry.get(params.nodeSpec.owner.ref)
-    if (!entry) {
-      throw new Error(`Domain agent "${params.nodeSpec.owner.ref}" not registered.`)
-    }
-
-    const plugin = (getRuntimeConfig().pluginRuntime as Record<string, LotaPlugin | undefined> | undefined)?.[
-      entry.pluginRef
-    ]
-    if (!plugin?.nodeExecutor) {
-      throw new Error(`Plugin "${entry.pluginRef}" does not have a nodeExecutor.`)
-    }
-
-    return plugin.nodeExecutor.executeNode({
-      operation: `domain-agent:${entry.definition.agentId}`,
-      nodeSpec: params.nodeSpec,
-      inputs: params.resolvedInput,
-      context: {
-        organizationId: params.context.organizationId,
-        workstreamId: params.context.workstreamId,
-        planId: params.context.planId,
-        nodeId: params.context.nodeId,
-      },
-    })
-  }
-}
-
-export const domainAgentExecutorService = new DomainAgentExecutorService()

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

@@ -1,44 +0,0 @@
-import type { z } from 'zod'
-
-import { MemoryImportanceAssessmentSchema } from '../db/memory-types'
-import { createHelperModelRuntime } from '../runtime/helper-model'
-import { createOrgMemoryAgent } from '../system-agents/memory.agent'
-import { clampImportance } from '../utils/string'
-
-type MemoryImportanceAssessment = z.infer<typeof MemoryImportanceAssessmentSchema>
-const MEMORY_IMPORTANCE_ASSESSMENT_TIMEOUT_MS = 10 * 60 * 1000
-const helperModelRuntime = createHelperModelRuntime()
-
-export function clampMemoryImportance(value: number): number {
-  return clampImportance(Math.max(0.2, Math.min(0.95, value)))
-}
-
-export async function assessMemoryImportance(params: {
-  content: string
-  targetScope: 'agent' | 'global'
-  tag?: string
-}): Promise<MemoryImportanceAssessment> {
-  const prompt = [
-    'Assess whether this memory should be persisted in long-term memory.',
-    `targetScope: ${params.targetScope}`,
-    `memory: ${params.content}`,
-    '',
-    'Rules:',
-    '- importance: number between 0 and 1 for long-term usefulness.',
-    '- durability: core|standard|ephemeral.',
-    '- classification: durable|transient|uncertain.',
-    '- rationale: short and concrete.',
-    '',
-    'The caller enforces a structured output schema.',
-    'Return only schema fields.',
-  ].join('\n')
-
-  return helperModelRuntime.generateHelperStructured({
-    tag: params.tag ?? 'memory-importance-assessment',
-    createAgent: createOrgMemoryAgent,
-    systemPrompt: 'You are a strict long-term memory quality assessor for an AI agent.',
-    messages: [{ role: 'user', content: prompt }],
-    schema: MemoryImportanceAssessmentSchema,
-    timeoutMs: MEMORY_IMPORTANCE_ASSESSMENT_TIMEOUT_MS,
-  })
-}

package/src/services/playbook-registry.service.ts

@@ -1,67 +0,0 @@
-import type { PlanTemplateRecord } from '@lota-sdk/shared'
-
-import type { RecordIdInput } from '../db/record-id'
-import type { PlaybookContribution } from '../runtime/plugin-types'
-import { getRuntimeConfig } from '../runtime/runtime-config'
-import { planTemplateService } from './plan-template.service'
-
-class PlaybookRegistryService {
-  collectPlaybooks(): PlaybookContribution[] {
-    const plugins = getRuntimeConfig().pluginRuntime ?? {}
-    const playbooks: PlaybookContribution[] = []
-    for (const plugin of Object.values(plugins)) {
-      if (plugin.playbookContributor?.playbooks) {
-        playbooks.push(...plugin.playbookContributor.playbooks)
-      }
-    }
-    return playbooks
-  }
-
-  async syncPlaybookTemplates(organizationId: RecordIdInput): Promise<PlanTemplateRecord[]> {
-    const playbooks = this.collectPlaybooks()
-    const templates: PlanTemplateRecord[] = []
-    const existing = await planTemplateService.listTemplates(organizationId, { source: 'playbook' })
-
-    for (const pb of playbooks) {
-      const match = existing.find((t) => t.sourceRef === pb.name)
-      if (match) {
-        const updated = await planTemplateService.updateTemplate(match.id, { draft: pb.draft, tags: pb.tags })
-        templates.push(updated)
-      } else {
-        const created = await planTemplateService.createTemplate({
-          organizationId,
-          name: pb.name,
-          description: pb.description,
-          draft: pb.draft,
-          tags: pb.tags,
-          source: 'playbook',
-          sourceRef: pb.name,
-        })
-        templates.push(created)
-      }
-    }
-
-    return templates
-  }
-
-  async instantiatePlaybook(params: {
-    name: string
-    organizationId: RecordIdInput
-    workstreamId: RecordIdInput
-    leadAgentId: string
-  }): Promise<unknown> {
-    const templates = await planTemplateService.listTemplates(params.organizationId, { source: 'playbook' })
-    const template = templates.find((t) => t.sourceRef === params.name)
-    if (!template) {
-      throw new Error(`Playbook "${params.name}" not found.`)
-    }
-    return planTemplateService.instantiate({
-      templateId: template.id,
-      organizationId: params.organizationId,
-      workstreamId: params.workstreamId,
-      leadAgentId: params.leadAgentId,
-    })
-  }
-}
-
-export const playbookRegistryService = new PlaybookRegistryService()