@lota-sdk/core 0.1.15 → 0.1.16

package/src/runtime/runtime-config.ts

@@ -1,17 +1,17 @@
 import { z } from 'zod'
 
 import type { CoreWorkstreamProfile } from '../config/agent-defaults'
+import type { AgentFactory, AgentRuntimeConfigProvider, AgentToolBuilder } from '../config/agent-types'
 import type { LotaWorkstreamConfig, WorkstreamBootstrapWelcomeConfig } from '../config/workstream-defaults'
-import type { LotaPlugin } from './plugin-types'
+import type { NotificationService } from '../services/notification.service'
+import { isRecord } from '../utils/string'
+import type { GraphDesigner } from './graph-designer'
+import type { LotaPlugin, SystemNodeExecutor } from './plugin-types'
 import type { LotaRuntimeAdapters, LotaRuntimeTurnHooks } from './runtime-extensions'
 import type { LotaRuntimeWorkerExtensions } from './runtime-worker-registry'
 
 const logLevelValues = ['trace', 'debug', 'info', 'warning', 'error', 'fatal'] as const
 
-type LotaAgentFactoryRegistry = Record<string, (...args: unknown[]) => unknown>
-
-const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null
-
 function isStringOrUrl(value: unknown): value is string | URL {
   return typeof value === 'string' || value instanceof URL
 }
@@ -24,7 +24,7 @@ function isStringRecord(value: unknown): value is Record<string, string> {
   return isRecord(value) && Object.values(value).every((entry) => typeof entry === 'string')
 }
 
-function isAgentFactoryRegistry(value: unknown): value is LotaAgentFactoryRegistry {
+function isAgentFactoryRegistry(value: unknown): value is AgentFactory {
   return isRecord(value) && Object.values(value).every((entry) => typeof entry === 'function')
 }
 
@@ -32,10 +32,22 @@ function isPluginRuntimeRecord(value: unknown): value is Record<string, LotaPlug
   return isRecord(value)
 }
 
+function isSystemExecutorRecord(value: unknown): value is Record<string, SystemNodeExecutor> {
+  return isRecord(value)
+}
+
 function isToolProviderRecord(value: unknown): value is Record<string, unknown> {
   return isRecord(value)
 }
 
+function isNotificationService(value: unknown): value is NotificationService {
+  return isRecord(value) && isFunction(value.notify) && isFunction(value.remind) && isFunction(value.escalate)
+}
+
+function isGraphDesigner(value: unknown): value is GraphDesigner {
+  return isRecord(value) && isFunction(value.designGraph)
+}
+
 function isWorkerExtensionRecord(value: unknown): value is LotaRuntimeWorkerExtensions {
   if (!isRecord(value)) return false
 
@@ -85,15 +97,13 @@ const agentsConfigSchema = z
       })
       .optional(),
     createAgent: z
-      .custom<LotaAgentFactoryRegistry>(isAgentFactoryRegistry, {
-        error: 'agents.createAgent must be a function registry',
-      })
+      .custom<AgentFactory>(isAgentFactoryRegistry, { error: 'agents.createAgent must be a function registry' })
       .optional(),
     buildAgentTools: z
-      .custom<(...args: unknown[]) => unknown>(isFunction, { error: 'agents.buildAgentTools must be a function' })
+      .custom<AgentToolBuilder>(isFunction, { error: 'agents.buildAgentTools must be a function' })
       .optional(),
     getAgentRuntimeConfig: z
-      .custom<(...args: unknown[]) => unknown>(isFunction, { error: 'agents.getAgentRuntimeConfig must be a function' })
+      .custom<AgentRuntimeConfigProvider>(isFunction, { error: 'agents.getAgentRuntimeConfig must be a function' })
       .optional(),
   })
   .superRefine((value, ctx) => {
@@ -173,8 +183,11 @@ export const LotaRuntimeConfigSchema = z.object({
   extraSchemaFiles: z.array(z.custom<string | URL>(isStringOrUrl)).optional(),
   extraWorkers: z.custom<LotaRuntimeWorkerExtensions>(isWorkerExtensionRecord).optional(),
   pluginRuntime: z.custom<Record<string, LotaPlugin>>(isPluginRuntimeRecord).optional(),
+  systemExecutors: z.custom<Record<string, SystemNodeExecutor>>(isSystemExecutorRecord).optional(),
+  notificationService: z.custom<NotificationService>(isNotificationService).optional(),
   runtimeAdapters: z.custom<LotaRuntimeAdapters>(isRecord).optional(),
   turnHooks: z.custom<LotaRuntimeTurnHooks>(isRecord).optional(),
+  graphDesigner: z.custom<GraphDesigner>(isGraphDesigner).optional(),
 })
 
 export type LotaRuntimeConfig = z.input<typeof LotaRuntimeConfigSchema>
@@ -235,4 +248,4 @@ export function parseWorkerBootstrapEnv(env: Record<string, string | undefined>)
   return WORKER_BOOTSTRAP_ENV_SCHEMA.parse(env)
 }
 
-export type { LotaAgentFactoryRegistry, LotaWorkstreamConfig }
+export type { LotaWorkstreamConfig }

package/src/runtime/runtime-extensions.ts

@@ -224,8 +224,8 @@ export function getConfiguredPluginDatabaseConnector(): (() => Promise<void>) |
 export async function withConfiguredWorkspaceMemoryLock<T>(workspaceId: string, fn: () => Promise<T>): Promise<T> {
   const adapter = runtimeExtensionsState.adapters.workers?.withWorkspaceMemoryLock
   if (!adapter) {
-    return await fn()
+    return fn()
   }
 
-  return await adapter(workspaceId, fn)
+  return adapter(workspaceId, fn)
 }

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

@@ -1,5 +1,7 @@
 import { startContextCompactionWorker } from '../queues/context-compaction.queue'
+import { startDelayedNodePromotionWorker } from '../queues/delayed-node-promotion.queue'
 import { scheduleRecurringConsolidation, startMemoryConsolidationWorker } from '../queues/memory-consolidation.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'
@@ -8,7 +10,9 @@ import { startWorkstreamTitleGenerationWorker } from '../queues/workstream-title
 
 export interface LotaRuntimeWorkerStartRegistry {
   contextCompaction: typeof startContextCompactionWorker
+  delayedNodePromotion: typeof startDelayedNodePromotionWorker
   memoryConsolidation: typeof startMemoryConsolidationWorker
+  planScheduler: typeof startPlanSchedulerWorker
   postChatMemory: typeof startPostChatMemoryWorker
   regularChatMemoryDigest: typeof startRegularChatMemoryDigestWorker
   skillExtraction: typeof startSkillExtractionWorker
@@ -34,7 +38,9 @@ export function buildRuntimeWorkerRegistry(extraWorkers?: LotaRuntimeWorkerExten
   return {
     start: {
       contextCompaction: startContextCompactionWorker,
+      delayedNodePromotion: startDelayedNodePromotionWorker,
       memoryConsolidation: startMemoryConsolidationWorker,
+      planScheduler: startPlanSchedulerWorker,
       postChatMemory: startPostChatMemoryWorker,
       regularChatMemoryDigest: startRegularChatMemoryDigestWorker,
       skillExtraction: startSkillExtractionWorker,

package/src/runtime/team-consultation-orchestrator.ts

@@ -1,6 +1,6 @@
 import { ConsultTeamArgsSchema, withMessageCreatedAt } from '@lota-sdk/shared'
 import type { ChatMessage, ConsultTeamResultData } from '@lota-sdk/shared'
-import { convertToModelMessages, readUIMessageStream, tool as createTool } from 'ai'
+import { convertToModelMessages, tool as createTool } from 'ai'
 
 import { agentDisplayNames, teamConsultParticipants } from '../config/agent-defaults'
 import { createTimedAbortSignal } from './agent-stream-helpers'
@@ -33,6 +33,28 @@ function getConsultTeamOutput(output: unknown): ConsultTeamResultData | undefine
   return undefined
 }
 
+function findLastUserMessage(
+  messages: ChatMessage[],
+  predicate: (message: ChatMessage) => boolean,
+): ChatMessage | null {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (predicate(message)) {
+      return message
+    }
+  }
+
+  return null
+}
+
+function selectTeamConsultationContextMessages(messages: ChatMessage[], latestUserMessageId: string): ChatMessage[] {
+  const latestUserMessage =
+    findLastUserMessage(messages, (message) => message.id === latestUserMessageId && message.role === 'user') ??
+    findLastUserMessage(messages, (message) => message.role === 'user')
+
+  return latestUserMessage ? [latestUserMessage] : []
+}
+
 interface ParticipantObserver {
   run<T>(fn: () => T | Promise<T>): Promise<T>
   recordError?: (error: unknown) => void
@@ -51,6 +73,7 @@ export interface TeamConsultationParticipantRunner {
     },
   ): Promise<{
     agent: {
+      generate(params: Record<string, unknown>): Promise<{ text: string }>
       stream(
         params: Record<string, unknown>,
       ): Promise<{
@@ -119,16 +142,22 @@ export function createConsultTeamTool(params: CreateConsultTeamToolParams) {
           })
           const modelMessages = await convertToModelMessages(
             buildModelInputMessagesWithUploadMetadata({
-              messages: params.historyMessages,
+              messages: selectTeamConsultationContextMessages(params.historyMessages, params.latestUserMessageId),
               latestUserMessageId: params.latestUserMessageId,
               uploadMetadataText,
             }),
             { ignoreIncompleteToolCalls: true },
           )
 
-          let result: Awaited<ReturnType<typeof agent.stream>>
+          let result: Awaited<ReturnType<typeof agent.generate>>
           try {
-            result = await observer.run(() => agent.stream({ messages: modelMessages, abortSignal: timedAbort.signal }))
+            result = await observer.run(() =>
+              agent.generate({
+                messages: modelMessages,
+                abortSignal: timedAbort.signal,
+                timeout: TEAM_CONSULTATION_TIMEOUT_MS,
+              }),
+            )
           } catch (error) {
             if (params.abortSignal.aborted || timedAbort.signal.aborted) {
               observer.recordAbort?.(error)
@@ -138,33 +167,21 @@ export function createConsultTeamTool(params: CreateConsultTeamToolParams) {
             throw error
           }
 
-          for await (const message of readUIMessageStream<ChatMessage>({
-            stream: result.toUIMessageStream({
-              generateMessageId: () => Bun.randomUUIDv7(),
-              sendReasoning: true,
-              sendSources: true,
-              sendStart: false,
-              sendFinish: false,
-            }) as ReadableStream<never>,
-            onError: (error) => {
-              params.onReadError?.(agentId, error)
-            },
-          })) {
-            latestMessage = withMessageCreatedAt(message)
-            responses[index] = {
-              agentId,
-              agentName,
-              status: 'running',
-              summary: extractMessageText(latestMessage).trim() || undefined,
-              message: latestMessage,
-            }
-            pushSnapshot()
-          }
-
-          if (!latestMessage) {
+          const responseText = result.text.trim()
+          if (!responseText) {
             throw new Error(`Team participant ${agentId} did not produce a response.`)
           }
 
+          latestMessage = withMessageCreatedAt(
+            {
+              id: Bun.randomUUIDv7(),
+              role: 'assistant',
+              parts: [{ type: 'text', text: responseText }],
+              metadata: { agentId, agentName },
+            } satisfies ChatMessage,
+            Date.now(),
+          )
+
           responses[index] = {
             agentId,
             agentName,

package/src/runtime/team-consultation-prompts.ts

@@ -3,12 +3,21 @@ import { agentDisplayNames, getLeadAgentDisplayName } from '../config/agent-defa
 export function buildTeamConsultationResponseGuard(params: { agentId: string; task: string }) {
   const agentName = agentDisplayNames[params.agentId] ?? params.agentId
   const leadAgentDisplayName = getLeadAgentDisplayName()
+  const mentorConstraint =
+    params.agentId === 'mentor'
+      ? ['- As Mentor, answer as an experienced operator reviewing launch discipline, not as a coach or therapist.']
+      : []
   return [
     '<team-consultation-agent-protocol>',
     `- You are participating in a structured internal team consultation led by ${leadAgentDisplayName}.`,
     `- Your role for this response is ${agentName}.`,
-    '- Use markdown when it helps clarity.',
-    '- Make the recommendation, explain key tradeoffs, and note the next decision.',
+    '- Chief is already coordinating this panel. Do not refer the task back to Chief or tell the user to consult another agent.',
+    '- Answer only from your role-specific perspective for the task below.',
+    '- Do not coach the user, ask follow-up questions, or challenge assumptions in this panel response. Give the recommendation directly.',
+    ...mentorConstraint,
+    '- Return exactly 3 short markdown bullets in this order: recommendation, key risk/tradeoff, next decision.',
+    '- Keep the whole response under 120 words.',
+    '- Do not use headings, code fences, XML, evidence blocks, gap lists, or preamble text.',
     '',
     '<team-consultation-task>',
     params.task.trim(),

package/src/runtime/title-helpers.ts

@@ -1,4 +1,4 @@
-import { compactWhitespace } from '../utils/string'
+import { compactWhitespace, truncateText } from '../utils/string'
 
 const TITLE_WORD_LIMIT = 5
 
@@ -8,9 +8,7 @@ export function limitTitleWords(text: string): string {
 }
 
 export function deriveTitle(text: string): string {
-  const trimmed = compactWhitespace(text)
-  if (trimmed.length <= 60) return trimmed
-  return `${trimmed.slice(0, 57)}...`
+  return truncateText(compactWhitespace(text), 60)
 }
 
 export function normalizeTitle(value: string): string {

package/src/runtime/workstream-chat-helpers.ts

@@ -77,7 +77,7 @@ export function appendPersistedWorkstreamContextToHistoryMessages(
     nextHistoryMessages.push({ role: 'agent', content: `Compacted chat summary:\n${compactionSummary}` })
   }
 
-  if (params.persistedState !== undefined && params.persistedState !== null) {
+  if (params.persistedState !== null && params.persistedState !== undefined) {
     nextHistoryMessages.push({
       role: 'agent',
       content: `Structured workstream state:\n${JSON.stringify(params.persistedState)}`,

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

@@ -0,0 +1,152 @@
+import type { PlaybookVersion, Recommendation } from '@lota-sdk/shared'
+import { PlaybookSchema, PlaybookVersionSchema } from '@lota-sdk/shared'
+
+import { ensureRecordId, recordIdToString } from '../db/record-id'
+import { databaseService } from '../db/service'
+import { TABLES } from '../db/tables'
+
+class AdaptivePlaybookService {
+  async refineFromCycle(params: {
+    playbookId: string
+    runId: string
+    recommendations: Recommendation[]
+    organizationId: string
+  }): Promise<PlaybookVersion> {
+    const playbook = await databaseService.findOne(
+      TABLES.PLAYBOOK,
+      { id: ensureRecordId(params.playbookId, TABLES.PLAYBOOK) },
+      PlaybookSchema,
+    )
+    if (!playbook) {
+      throw new Error(`Playbook not found: ${params.playbookId}`)
+    }
+
+    const currentVersion = await databaseService.findOne(
+      TABLES.PLAYBOOK_VERSION,
+      {
+        id: ensureRecordId(
+          recordIdToString(playbook.currentVersionId, TABLES.PLAYBOOK_VERSION),
+          TABLES.PLAYBOOK_VERSION,
+        ),
+      },
+      PlaybookVersionSchema,
+    )
+
+    const nextVersionNumber = currentVersion ? currentVersion.version + 1 : 1
+    const now = new Date()
+
+    const newVersion = await databaseService.create(
+      TABLES.PLAYBOOK_VERSION,
+      {
+        playbookId: ensureRecordId(params.playbookId, TABLES.PLAYBOOK),
+        version: nextVersionNumber,
+        parentVersionId: playbook.currentVersionId,
+        appliedRecommendations: params.recommendations.map((r) => r.description),
+        status: 'testing',
+        createdAt: now,
+      },
+      PlaybookVersionSchema,
+    )
+
+    await databaseService.update(
+      TABLES.PLAYBOOK,
+      ensureRecordId(params.playbookId, TABLES.PLAYBOOK),
+      {
+        currentVersionId: newVersion.id,
+        previousVersionId: playbook.currentVersionId,
+        cycleCount: playbook.cycleCount + 1,
+      },
+      PlaybookSchema,
+    )
+
+    return newVersion
+  }
+
+  evaluateRegression(params: { currentScore: number; previousScore: number; threshold?: number }): {
+    shouldRollback: boolean
+  } {
+    const threshold = params.threshold ?? 0.9
+    if (params.previousScore === 0) return { shouldRollback: false }
+    return { shouldRollback: params.currentScore < params.previousScore * threshold }
+  }
+
+  async rollback(params: {
+    playbookId: string
+    organizationId: string
+    maxLevels?: number
+  }): Promise<PlaybookVersion | null> {
+    const maxLevels = params.maxLevels ?? 3
+    return this.rollbackRecursive(params.playbookId, params.organizationId, maxLevels)
+  }
+
+  private async rollbackRecursive(
+    playbookId: string,
+    organizationId: string,
+    remainingLevels: number,
+  ): Promise<PlaybookVersion | null> {
+    if (remainingLevels <= 0) return null
+
+    const playbook = await databaseService.findOne(
+      TABLES.PLAYBOOK,
+      { id: ensureRecordId(playbookId, TABLES.PLAYBOOK) },
+      PlaybookSchema,
+    )
+    if (!playbook) return null
+
+    const currentVersion = await databaseService.findOne(
+      TABLES.PLAYBOOK_VERSION,
+      {
+        id: ensureRecordId(
+          recordIdToString(playbook.currentVersionId, TABLES.PLAYBOOK_VERSION),
+          TABLES.PLAYBOOK_VERSION,
+        ),
+      },
+      PlaybookVersionSchema,
+    )
+    if (!currentVersion?.parentVersionId) return null
+
+    // Mark current version as rolled-back
+    await databaseService.update(
+      TABLES.PLAYBOOK_VERSION,
+      ensureRecordId(recordIdToString(currentVersion.id, TABLES.PLAYBOOK_VERSION), TABLES.PLAYBOOK_VERSION),
+      { status: 'rolled-back' },
+      PlaybookVersionSchema,
+    )
+
+    // Restore parent version as active
+    const parentVersion = await databaseService.findOne(
+      TABLES.PLAYBOOK_VERSION,
+      {
+        id: ensureRecordId(
+          recordIdToString(currentVersion.parentVersionId, TABLES.PLAYBOOK_VERSION),
+          TABLES.PLAYBOOK_VERSION,
+        ),
+      },
+      PlaybookVersionSchema,
+    )
+    if (!parentVersion) return null
+
+    await databaseService.update(
+      TABLES.PLAYBOOK_VERSION,
+      ensureRecordId(recordIdToString(parentVersion.id, TABLES.PLAYBOOK_VERSION), TABLES.PLAYBOOK_VERSION),
+      { status: 'active' },
+      PlaybookVersionSchema,
+    )
+
+    await databaseService.update(
+      TABLES.PLAYBOOK,
+      ensureRecordId(playbookId, TABLES.PLAYBOOK),
+      { currentVersionId: parentVersion.id, previousVersionId: parentVersion.parentVersionId },
+      PlaybookSchema,
+    )
+
+    // Check if parent version is also regressed (caller can evaluate and re-invoke)
+    if (parentVersion.qualityScore !== undefined && parentVersion.qualityScore < 0.5) {
+      return this.rollbackRecursive(playbookId, organizationId, remainingLevels - 1)
+    }
+
+    return parentVersion
+  }
+}
+
+export const adaptivePlaybookService = new AdaptivePlaybookService()