@lota-sdk/core 0.1.23 → 0.1.25

package/src/services/index.ts

@@ -1,12 +1,10 @@
 export * from './adaptive-playbook.service'
 export * from './agent-executor.service'
+export * from './agent-activity.service'
 export * from './artifact-provenance.service'
 export * from './attachment.service'
 export * from './autonomous-job.service'
-export * from './context-enrichment.service'
-export * from './coordination-registry.service'
 export * from './document-chunk.service'
-export * from './domain-agent-executor.service'
 export * from './execution-plan.service'
 export * from './institutional-memory.service'
 export * from './feedback-loop.service'
@@ -27,7 +25,6 @@ export * from './plan-workspace.service'
 export * from './plan-run.service'
 export * from './plan-scheduler.service'
 export * from './plan-template.service'
-export * from './playbook-registry.service'
 export * from './quality-metrics.service'
 export * from './queue-job.service'
 export * from './monitoring-window.service'
@@ -39,6 +36,7 @@ export * from './social-chat-history.service'
 export * from './system-executor.service'
 export * from './user.service'
 export * from './workstream-message.service'
+export * from './workstream.types'
 export * from './workstream-title.service'
 export * from './workstream-turn'
 export * from './workstream-plan-registry.service'

package/src/services/memory.service.ts

@@ -26,8 +26,7 @@ import {
 import { getRuntimeConfig } from '../runtime/runtime-config'
 import { createMemoryRerankerAgent, MEMORY_RERANKER_PROMPT } from '../system-agents/memory-reranker.agent'
 import { createOrgMemoryAgent, ORG_MEMORY_PROMPT } from '../system-agents/memory.agent'
-import { compactWhitespace, truncateText } from '../utils/string'
-import { assessMemoryImportance, clampMemoryImportance } from './memory-assessment.service'
+import { clampImportance, compactWhitespace, truncateText } from '../utils/string'
 import { formatMemoryResults, formatRerankedResults, getCandidateLimit } from './memory-utils'
 
 const ORG_MEMORY_TYPE = 'fact'
@@ -41,11 +40,13 @@ const MAX_CONVERSATION_HISTORY_MESSAGES = 24
 const MAX_CONVERSATION_MESSAGE_CHARS = 1_200
 const MAX_CONVERSATION_MEMORY_BLOCK_CHARS = 2_000
 const MAX_CONVERSATION_ATTACHMENT_CONTEXT_CHARS = 6_000
-const MAX_CONVERSATION_ASSESSMENT_CHARS = 7_000
 const ONBOARDING_MEMORY_MAX_FACTS = 16
 const MAX_ORG_MEMORY_CLIENTS = 128
+const LOW_VALUE_MEMORY_IMPORTANCE_THRESHOLD = 0.45
 const ONBOARDING_MEMORY_EXTRACTION_PROMPT =
   'Onboarding mode is active. Extract multiple concrete startup facts from user-provided context: company mission, product capabilities, customer segments, pricing, traction, go-to-market plans, roadmap, team composition, technical stack, risks, and referenced URLs. Prefer one fact per concrete claim.'
+const DIRECT_MEMORY_ASSESSMENT_PROMPT =
+  'The user is submitting a direct memory candidate. Keep the wording faithful. Return one fact only when the statement is durable enough for memory; otherwise return no facts.'
 
 const helperModelRuntime = createHelperModelRuntime()
 
@@ -225,11 +226,6 @@ class MemoryService {
     return { messages, normalizedInput, sanitizedOutput }
   }
 
-  private buildConversationAssessmentInput(messages: Message[]): string {
-    const lines = messages.map((message, index) => `[${message.role.toUpperCase()} #${index + 1}] ${message.content}`)
-    return this.normalizeConversationText(lines.join('\n\n'), MAX_CONVERSATION_ASSESSMENT_CHARS)
-  }
-
   private async rerankCandidates(
     query: string,
     candidates: MemorySearchResult[],
@@ -307,16 +303,24 @@ class MemoryService {
     memory,
     scopeId,
     memoryType,
+    fastMode = true,
   }: {
     query: string
     memory: Memory
     scopeId: string
     memoryType: MemoryType
+    fastMode?: boolean
   }): Promise<string> {
     const limit = getRuntimeConfig().memory.searchK
-    const candidateLimit = getCandidateLimit(limit)
+    const candidateLimit = fastMode ? limit : getCandidateLimit(limit)
 
-    const candidates = await memory.searchCandidates(query, { scopeId, limit: candidateLimit, memoryType })
+    const candidates = await memory.searchCandidates(query, {
+      scopeId,
+      limit: candidateLimit,
+      memoryType,
+      fastMode,
+      includeNeighborContext: !fastMode,
+    })
 
     aiLogger.debug`Memory search candidates (scopeId: ${scopeId}, candidates: ${candidates.length})`
 
@@ -324,9 +328,9 @@ class MemoryService {
       return 'No stored memories.'
     }
 
-    if (candidates.length <= limit) {
+    if (fastMode || candidates.length <= limit) {
       aiLogger.debug`Skipping reranking (candidates: ${candidates.length} <= limit: ${limit})`
-      return formatMemoryResults(candidates)
+      return formatMemoryResults(candidates.slice(0, limit))
     }
 
     const reranked = await this.rerankCandidates(query, candidates, limit)
@@ -473,7 +477,7 @@ class MemoryService {
     orgId,
     agentName,
     query,
-    fastMode = false,
+    fastMode = true,
     allowMultiScopeRerank = true,
   }: {
     orgId: string
@@ -659,6 +663,38 @@ class MemoryService {
     }
   }
 
+  async assessMemoryCandidate(params: {
+    orgId: string
+    content: string
+  }): Promise<Pick<ExtractedFact, 'classification' | 'durability' | 'importance' | 'rationale'> | null> {
+    const trimmed = compactWhitespace(params.content)
+    if (!trimmed) return null
+
+    const facts = await this.getOrgMemory(params.orgId).extractFactsFromMessages([{ role: 'user', content: trimmed }], {
+      maxFacts: 1,
+      customPrompt: DIRECT_MEMORY_ASSESSMENT_PROMPT,
+    })
+    if (facts.length === 0) return null
+    const fact = facts[0]
+
+    return {
+      classification: fact.classification,
+      durability: fact.durability,
+      importance: clampImportance(fact.importance),
+      rationale: fact.rationale,
+    }
+  }
+
+  private shouldSkipExtractedFacts(facts: ExtractedFact[]): boolean {
+    if (facts.length === 0) return true
+    return facts.every(
+      (fact) =>
+        fact.durability === 'ephemeral' &&
+        fact.importance <= LOW_VALUE_MEMORY_IMPORTANCE_THRESHOLD &&
+        fact.classification !== 'durable',
+    )
+  }
+
   async updateOrganizationMemoryById({
     orgId,
     memoryId,
@@ -761,39 +797,12 @@ class MemoryService {
     aiLogger.debug`addConversationMemories - orgId: "${orgId}", scopeId: "${orgScopeId}", sourceId: ${sourceId ?? 'none'}`
 
     const orgMemory = this.getOrgMemory(orgId)
-    let assessedImportance: number | undefined
-    let assessmentMetadata: Record<string, unknown> | undefined
-
-    try {
-      const assessmentInput = this.buildConversationAssessmentInput(messages)
-      if (assessmentInput) {
-        const assessment = await assessMemoryImportance({
-          content: assessmentInput,
-          targetScope: 'global',
-          tag: 'memory-conversation-assessment',
-        })
-        if (assessment.classification === 'transient' && assessment.durability === 'ephemeral') {
-          aiLogger.debug`Skipping transient conversation memory`
-          return
-        }
-        assessedImportance = Math.round(clampMemoryImportance(assessment.importance) * 100) / 100
-        assessmentMetadata = {
-          importanceSource: 'model_assessed',
-          durability: assessment.durability,
-          classification: assessment.classification,
-          rationale: assessment.rationale,
-        }
-      }
-    } catch (error) {
-      aiLogger.warn`Conversation memory assessment failed; continuing with default scoring: ${error}`
-    }
 
     const scopes: AddOptions[] = [
       {
         scopeId: orgScopeId,
         memoryType: ORG_MEMORY_TYPE,
-        ...(typeof assessedImportance === 'number' ? { importance: assessedImportance } : {}),
-        metadata: { orgId, source, ...(sourceId ? { sourceId } : {}), ...sourceMetadata, ...assessmentMetadata },
+        metadata: { orgId, source, ...(sourceId ? { sourceId } : {}), ...sourceMetadata },
       },
     ]
 
@@ -802,7 +811,6 @@ class MemoryService {
       scopes.push({
         scopeId: agentId,
         memoryType: ORG_MEMORY_TYPE,
-        ...(typeof assessedImportance === 'number' ? { importance: assessedImportance } : {}),
         metadata: {
           orgId,
           agentName: scopedAgentName,
@@ -810,7 +818,6 @@ class MemoryService {
           source,
           ...(sourceId ? { sourceId } : {}),
           ...sourceMetadata,
-          ...assessmentMetadata,
         },
       })
     }
@@ -820,7 +827,10 @@ class MemoryService {
       ? { maxFacts: ONBOARDING_MEMORY_MAX_FACTS, customPrompt: ONBOARDING_MEMORY_EXTRACTION_PROMPT }
       : undefined
     const extractedFacts = await orgMemory.extractFactsFromMessages(messages, extractionConfig)
-    if (extractedFacts.length === 0) return
+    if (this.shouldSkipExtractedFacts(extractedFacts)) {
+      aiLogger.debug`Skipping transient conversation memory`
+      return
+    }
     const preparedUpdates = await orgMemory.prepareFactsToScopes(extractedFacts, scopes)
     if (preparedUpdates.length === 0) return
 

package/src/services/ownership-dispatcher.service.ts

@@ -24,7 +24,6 @@ import { TABLES } from '../db/tables'
 import { resolvePlanNodeExecutionVisibility, shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibility'
 import { getRuntimeAdapters } from '../runtime/runtime-extensions'
 import { agentExecutorService } from './agent-executor.service'
-import { domainAgentExecutorService } from './domain-agent-executor.service'
 import { monitoringWindowService } from './monitoring-window.service'
 import { planExecutorService } from './plan-executor.service'
 import { planRunService } from './plan-run.service'
@@ -106,7 +105,7 @@ class OwnershipDispatcherService {
 
     for (const node of draft.nodes) {
       if (node.owner.executorType === 'agent') {
-        if (!agentRoster.includes(node.owner.ref) && !domainAgentExecutorService.hasAgent(node.owner.ref)) {
+        if (!agentRoster.includes(node.owner.ref)) {
           issues.push({
             severity: 'blocking',
             code: 'agent_executor_missing',
@@ -264,7 +263,7 @@ class OwnershipDispatcherService {
   }
 
   private async shouldAutoDispatch(run: PlanRunRecord): Promise<boolean> {
-    const workspaceProvider = getRuntimeAdapters().services?.workspaceProvider
+    const workspaceProvider = getRuntimeAdapters().workspaceProvider
     if (!workspaceProvider) {
       return true
     }
@@ -365,14 +364,6 @@ class OwnershipDispatcherService {
     }
 
     if (params.nodeSpec.owner.executorType === 'agent') {
-      if (domainAgentExecutorService.hasAgent(params.nodeSpec.owner.ref)) {
-        return domainAgentExecutorService.executeNode({
-          nodeSpec: params.nodeSpec,
-          resolvedInput: params.resolvedInput,
-          inputArtifacts: params.inputArtifacts,
-          context: params.context,
-        })
-      }
       return agentExecutorService.executeNode({
         nodeSpec: params.nodeSpec,
         resolvedInput: params.resolvedInput,
@@ -407,14 +398,6 @@ class OwnershipDispatcherService {
 
       if (resolved.executorType === 'agent') {
         const skillNodeSpec = { ...params.nodeSpec, owner: { executorType: 'agent' as const, ref: resolved.ref } }
-        if (domainAgentExecutorService.hasAgent(resolved.ref)) {
-          return domainAgentExecutorService.executeNode({
-            nodeSpec: skillNodeSpec,
-            resolvedInput: params.resolvedInput,
-            inputArtifacts: params.inputArtifacts,
-            context: params.context,
-          })
-        }
         return agentExecutorService.executeNode({
           nodeSpec: skillNodeSpec,
           resolvedInput: params.resolvedInput,

package/src/services/plan-completion-side-effects.ts

@@ -0,0 +1,80 @@
+import type { PlanNodeOwner, PlanNodeType } from '@lota-sdk/shared'
+import { PlanEventSchema } from '@lota-sdk/shared'
+
+import { aiLogger } from '../config/logger'
+import { ensureRecordId } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { TABLES } from '../db/tables'
+import { feedbackLoopService } from './feedback-loop.service'
+import { institutionalMemoryService } from './institutional-memory.service'
+import { planEventDeliveryService } from './plan-event-delivery.service'
+import { planRunService } from './plan-run.service'
+import type { PlanValidationIssueInput } from './plan-validator.service'
+import { qualityMetricsService } from './quality-metrics.service'
+
+export async function runPlanNodeCompletionSideEffects(params: {
+  runId: string
+  organizationId: string
+  nodeId: string
+  nodeLabel: string
+  nodeOwnerRef: string
+  nodeOwnerType: PlanNodeOwner['executorType']
+  nodeType: PlanNodeType
+  nodeStartedAt?: string | Date | null
+  nodeAttemptCount: number
+  artifactCount: number
+  validationIssues: PlanValidationIssueInput[]
+}): Promise<void> {
+  const executionTimeMs = params.nodeStartedAt ? Date.now() - new Date(params.nodeStartedAt).getTime() : 0
+  await qualityMetricsService.recordNodeMetrics({
+    organizationId: params.organizationId,
+    runId: params.runId,
+    nodeId: params.nodeId,
+    metrics: {
+      executionTimeMs: Math.max(0, executionTimeMs),
+      attemptCount: params.nodeAttemptCount,
+      artifactCount: params.artifactCount,
+      validationIssueCount: params.validationIssues.length,
+      ownerRef: params.nodeOwnerRef,
+      ownerType: params.nodeOwnerType,
+      nodeType: params.nodeType,
+    },
+  })
+}
+
+async function runPlanCompletionSideEffects(params: { runId: string; organizationId: string }): Promise<void> {
+  await qualityMetricsService.recordCycleMetrics({ organizationId: params.organizationId, runId: params.runId })
+
+  const recommendations = await feedbackLoopService.analyzeOutcomes({
+    runId: params.runId,
+    organizationId: params.organizationId,
+  })
+  if (recommendations.length > 0) {
+    const run = await planRunService.getRunById(params.runId)
+    const specRecord = await planRunService.getPlanSpecById(run.planSpecId)
+    const event = await databaseService.create(
+      TABLES.PLAN_EVENT,
+      {
+        planSpecId: ensureRecordId(specRecord.id, TABLES.PLAN_SPEC),
+        runId: ensureRecordId(run.id, TABLES.PLAN_RUN),
+        eventType: 'feedback-analyzed',
+        message: `Feedback analysis produced ${recommendations.length} recommendation(s).`,
+        detail: { recommendations },
+        emittedBy: 'system',
+      },
+      PlanEventSchema,
+    )
+    await planEventDeliveryService.dispatchEvent(event)
+  }
+
+  await institutionalMemoryService.extractPatterns({ organizationId: params.organizationId, runId: params.runId })
+}
+
+export async function runPlanCompletionSideEffectsSafely(params: {
+  runId: string
+  organizationId: string
+}): Promise<void> {
+  await runPlanCompletionSideEffects(params).catch((error) => {
+    aiLogger.warn`Plan completion side effects failed for run ${params.runId}: ${error instanceof Error ? error.message : String(error)}`
+  })
+}

package/src/services/plan-event-delivery.service.ts

@@ -103,7 +103,7 @@ class PlanEventDeliveryService {
   }
 
   private async dispatchAdapterEvent(envelope: LotaRuntimePlanEventEnvelope): Promise<void> {
-    const adapter = getRuntimeAdapters().events?.planEventAdapter
+    const adapter = getRuntimeAdapters().planEventAdapter
     if (!adapter) {
       return
     }