@lota-sdk/core 0.1.35 → 0.1.37

package/infrastructure/schema/00_workstream.surql

@@ -19,6 +19,7 @@ DEFINE FIELD IF NOT EXISTS lastCompactedMessageId ON TABLE workstream TYPE optio
 DEFINE FIELD IF NOT EXISTS nameGenerated ON TABLE workstream TYPE bool DEFAULT false;
 DEFINE FIELD IF NOT EXISTS isCompacting ON TABLE workstream TYPE bool DEFAULT false;
 DEFINE FIELD IF NOT EXISTS state ON TABLE workstream TYPE option<object> FLEXIBLE;
+DEFINE FIELD IF NOT EXISTS members ON TABLE workstream TYPE option<array<string>> DEFAULT [];
 DEFINE FIELD IF NOT EXISTS turnCount ON TABLE workstream TYPE int DEFAULT 0;
 
 DEFINE INDEX IF NOT EXISTS workstreamOrgIdx ON TABLE workstream COLUMNS organizationId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "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.35",
+    "@lota-sdk/shared": "0.1.37",
     "@mendable/firecrawl-js": "^4.18.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.141",

package/src/config/agent-defaults.ts

@@ -11,12 +11,15 @@ function defaultGetAgentRuntimeConfig(): Record<string, never> {
 // Agent configuration — these are defaults that consumers override via createLotaRuntime config
 export let agentDisplayNames: Record<string, string> = {}
 export let agentShortDisplayNames: Record<string, string> = {}
+export let agentDescriptions: Record<string, string> = {}
+export let managerModelId: string | undefined = undefined
 export let agentRoster: readonly string[] = []
 export let leadAgentId = ''
 export let teamConsultParticipants: readonly string[] = []
 
 export interface CoreWorkstreamProfile {
   config: { coreType: string; agentId: string; title: string }
+  members: readonly string[]
   tools: readonly string[]
   skills: readonly string[]
   instructions: string
@@ -24,6 +27,7 @@ export interface CoreWorkstreamProfile {
 
 export let getCoreWorkstreamProfile: (coreType: string) => CoreWorkstreamProfile = (_coreType) => ({
   config: { coreType: _coreType, agentId: '', title: '' },
+  members: [],
   tools: [],
   skills: [],
   instructions: '',
@@ -34,6 +38,8 @@ export function configureAgents(config: {
   leadAgentId: string
   displayNames: Record<string, string>
   shortDisplayNames?: Record<string, string>
+  descriptions?: Record<string, string>
+  managerModelId?: string
   teamConsultParticipants: readonly string[]
   getCoreWorkstreamProfile?: (coreType: string) => CoreWorkstreamProfile
 }): void {
@@ -45,6 +51,8 @@ export function configureAgents(config: {
   leadAgentId = config.leadAgentId
   agentDisplayNames = config.displayNames
   agentShortDisplayNames = config.shortDisplayNames ?? {}
+  agentDescriptions = config.descriptions ?? {}
+  managerModelId = config.managerModelId
   teamConsultParticipants = config.teamConsultParticipants
   if (config.getCoreWorkstreamProfile) {
     getCoreWorkstreamProfile = config.getCoreWorkstreamProfile

package/src/create-runtime.ts

@@ -250,6 +250,8 @@ export async function createLotaRuntime(config: LotaRuntimeConfig): Promise<Lota
       leadAgentId: runtimeConfig.agents.leadAgentId,
       displayNames: agentDisplayNames,
       shortDisplayNames: runtimeConfig.agents.shortDisplayNames,
+      descriptions: runtimeConfig.agents.descriptions,
+      managerModelId: runtimeConfig.agents.managerModelId,
       teamConsultParticipants: runtimeConfig.agents.teamConsultParticipants,
       getCoreWorkstreamProfile: runtimeConfig.agents.getCoreWorkstreamProfile,
     })

package/src/runtime/runtime-config.ts

@@ -173,6 +173,10 @@ const agentsConfigSchema = z
     shortDisplayNames: z
       .custom<Record<string, string>>(isStringRecord, { error: 'agents.shortDisplayNames must be a string record' })
       .optional(),
+    descriptions: z
+      .custom<Record<string, string>>(isStringRecord, { error: 'agents.descriptions must be a string record' })
+      .optional(),
+    managerModelId: z.string().trim().min(1).optional(),
     teamConsultParticipants: z.array(z.string().trim().min(1)),
     getCoreWorkstreamProfile: z
       .custom<(coreType: string) => CoreWorkstreamProfile>(isFunction, {

package/src/services/global-orchestrator.service.ts

@@ -3,6 +3,7 @@ import type { ConvergenceState, PlanFailureClass } from '@lota-sdk/shared'
 import { serverLogger } from '../config/logger'
 import { recordIdToString } from '../db/record-id'
 import { TABLES } from '../db/tables'
+import { shouldPlanNodeUseVisibleTurn } from '../runtime/execution-plan-visibility'
 
 function classifyDispatchFailure(ownerType: string, error: unknown): PlanFailureClass {
   const errorMessage = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase()
@@ -80,17 +81,48 @@ class GlobalOrchestratorService {
       })
       if (readyNodes.length === 0) break
 
+      // Split into silent (dispatch now) and visible (enqueue heartbeat wake)
+      const silentNodes = readyNodes.filter((nr) => {
+        const ns = nodeSpecs.find((s) => s.nodeId === nr.nodeId)
+        return ns && !shouldPlanNodeUseVisibleTurn(spec, ns)
+      })
+      const visibleNodes = readyNodes.filter((nr) => {
+        const ns = nodeSpecs.find((s) => s.nodeId === nr.nodeId)
+        return ns && shouldPlanNodeUseVisibleTurn(spec, ns)
+      })
+
       // Transition all ready nodes to 'running' BEFORE dispatching
       for (const nodeRun of readyNodes) {
         await planExecutorService.transitionNodeToRunning({ runId: params.runId, nodeId: nodeRun.nodeId })
       }
 
+      // Enqueue heartbeat wakes for visible agent nodes — they need a streaming turn
+      if (visibleNodes.length > 0) {
+        const { enqueuePlanAgentHeartbeatWake } = await import('../queues/plan-agent-heartbeat.queue')
+        const updatedRunForWake = await planRunService.getRunById(params.runId)
+        for (const nodeRun of visibleNodes) {
+          const ns = nodeSpecs.find((s) => s.nodeId === nodeRun.nodeId)
+          if (!ns || ns.owner.executorType !== 'agent') continue
+          await enqueuePlanAgentHeartbeatWake({
+            organizationId: recordIdToString(updatedRunForWake.organizationId, TABLES.ORGANIZATION),
+            workstreamId: recordIdToString(updatedRunForWake.workstreamId, TABLES.WORKSTREAM),
+            runId: recordIdToString(updatedRunForWake.id, TABLES.PLAN_RUN),
+            nodeId: nodeRun.nodeId,
+            agentId: ns.owner.ref,
+            reason: 'graph-full-visible',
+          })
+        }
+      }
+
+      // If no silent nodes to dispatch, break and let heartbeat handle visible ones
+      if (silentNodes.length === 0) break
+
       // Re-fetch run after transitions for accurate state in dispatch context
       const updatedRun = await planRunService.getRunById(params.runId)
 
-      // Dispatch all in parallel with LINEAR mode override (prevents recursion)
+      // Dispatch silent nodes in parallel with LINEAR mode override (prevents recursion)
       const results = await Promise.allSettled(
-        readyNodes.map(async (nodeRun) => {
+        silentNodes.map(async (nodeRun) => {
           const nodeSpecRecord = nodeSpecs.find((ns) => ns.nodeId === nodeRun.nodeId)
           if (!nodeSpecRecord) {
             throw new Error(`Node spec not found for node "${nodeRun.nodeId}".`)
@@ -114,7 +146,7 @@ class GlobalOrchestratorService {
       // Submit results sequentially (each triggers syncRunGraph internally)
       for (let i = 0; i < results.length; i++) {
         const settled = results[i]
-        const nodeRun = readyNodes[i]
+        const nodeRun = silentNodes[i]
         const nodeSpecRecord = nodeSpecs.find((ns) => ns.nodeId === nodeRun.nodeId)
 
         if (settled.status === 'fulfilled') {

package/src/services/plan-agent-query.service.ts

@@ -73,6 +73,34 @@ class PlanAgentQueryService {
 
     for (const run of runs) {
       const spec = await planRunService.getPlanSpecById(run.planSpecId)
+
+      // Graph-full plans can have multiple visible agent nodes running in parallel
+      if (spec.executionMode === 'graph-full') {
+        const [nodeSpecs, nodeRuns] = await Promise.all([
+          planRunService.listNodeSpecs(spec.id),
+          planRunService.listNodeRuns(run.id),
+        ])
+        for (const nodeRun of nodeRuns) {
+          if (!ACTIONABLE_NODE_STATUSES.has(nodeRun.status)) continue
+          const nodeSpec = nodeSpecs.find((ns) => ns.nodeId === nodeRun.nodeId)
+          if (!nodeSpec) continue
+          const visibleTarget = isVisibleAgentNode({ nodeSpec, spec })
+          if (!visibleTarget) continue
+          if (params.agentId && params.agentId !== visibleTarget.agentId) continue
+          actionable.push({
+            organizationId: recordIdToString(run.organizationId, TABLES.ORGANIZATION),
+            workstreamId: recordIdToString(run.workstreamId, TABLES.WORKSTREAM),
+            runId: recordIdToString(run.id, TABLES.PLAN_RUN),
+            nodeId: nodeSpec.nodeId,
+            agentId: visibleTarget.agentId,
+            status: nodeRun.status as 'ready' | 'running',
+            visibility: visibleTarget.visibility,
+          })
+        }
+        continue
+      }
+
+      // Linear plans: only the current node is actionable
       const currentNodeId = run.currentNodeId
       if (!currentNodeId) {
         continue

package/src/services/workstream-turn-preparation.service.ts

@@ -1,9 +1,5 @@
 import {
   WORKSTREAM,
-  baseChatMessageSchema,
-  CONSULT_SPECIALIST_TOOL_NAME,
-  CONSULT_TEAM_TOOL_NAME,
-  ConsultSpecialistArgsSchema,
   dataPartsSchemas,
   messageMetadataSchema,
   PlanNodeResultSubmissionSchema,
@@ -11,7 +7,7 @@ import {
   toTimestamp,
   withMessageCreatedAt,
 } from '@lota-sdk/shared'
-import type { ChatMessage, ConsultSpecialistArgs, MessageMetadata, PlanNodeSpecRecord } from '@lota-sdk/shared'
+import type { ChatMessage, MessageMetadata, PlanNodeSpecRecord } from '@lota-sdk/shared'
 import { convertToModelMessages, stepCountIs, tool as createTool, validateUIMessages } from 'ai'
 import type { PrepareStepFunction, StopCondition, ToolLoopAgent, ToolSet, UIMessageStreamWriter } from 'ai'
 
@@ -32,11 +28,7 @@ import { TABLES } from '../db/tables'
 import { enqueueContextCompaction } from '../queues/context-compaction.queue'
 import { enqueueWorkstreamTitleGeneration } from '../queues/title-generation.queue'
 import { OWNERSHIP_DISPATCH_BLOCKED_TOOL_NAMES } from '../runtime/agent-runtime-policy'
-import {
-  buildSpecialistTaskMessage,
-  createAgentMessageMetadata,
-  createServerRunAbortController,
-} from '../runtime/agent-stream-helpers'
+import { createAgentMessageMetadata, createServerRunAbortController } from '../runtime/agent-stream-helpers'
 import { hasApprovalRespondedParts } from '../runtime/approval-continuation'
 import { buildModelInputMessagesWithUploadMetadata, buildReadableUploadMetadataText } from '../runtime/chat-attachments'
 import { hasMessageContent } from '../runtime/chat-message'
@@ -47,7 +39,6 @@ import { createExecutionPlanInstructionSectionCache } from '../runtime/execution
 import { mergeInstructionSections } from '../runtime/instruction-sections'
 import { runPostTurnSideEffects } from '../runtime/post-turn-side-effects'
 import { getRuntimeAdapters, getToolProviders, getTurnHooks } from '../runtime/runtime-extensions'
-import { runSpecialistSession } from '../runtime/specialist-runner'
 import { finalizeTurnRun } from '../runtime/turn-lifecycle'
 import {
   asRecord,
@@ -67,7 +58,7 @@ import type { WorkstreamState } from '../runtime/workstream-state'
 import { assembleWorkstreamTurnContext } from '../runtime/workstream-turn-context'
 import { chatRunRegistry } from '../services/chat-run-registry.service'
 import type { NormalizedWorkstream, WorkstreamRecord } from '../services/workstream.types'
-import { createTeamThinkTool } from '../tools/team-think.tool'
+import { triageWorkstreamMessage, checkForNextAgent } from '../system-agents/workstream-manager.agent'
 import { safeEnqueue } from '../utils/async'
 import { AppError } from '../utils/errors'
 import { attachmentService } from './attachment.service'
@@ -114,30 +105,6 @@ async function waitForWorkstreamCompactionIfNeeded(workstreamId: RecordIdRef): P
   })
 }
 
-function parseChatMessageCandidate(value: unknown): ChatMessage | undefined {
-  const parsed = baseChatMessageSchema.safeParse(value)
-  if (!parsed.success) return undefined
-  return parsed.data as ChatMessage
-}
-
-function getChatMessageFromToolOutput(output: unknown): ChatMessage | undefined {
-  const directCandidate = parseChatMessageCandidate(output)
-  if (directCandidate) return directCandidate
-
-  if (Array.isArray(output)) {
-    for (let index = output.length - 1; index >= 0; index -= 1) {
-      const candidate = getChatMessageFromToolOutput(output[index])
-      if (candidate) return candidate
-    }
-  }
-
-  if (output && typeof output === 'object' && 'message' in output) {
-    return getChatMessageFromToolOutput((output as { message?: unknown }).message)
-  }
-
-  return undefined
-}
-
 class WorkstreamTurnError extends AppError {
   constructor(
     message: string,
@@ -277,6 +244,7 @@ interface StreamAgentResponseParams {
   stopWhen?: StopCondition<ToolSet> | Array<StopCondition<ToolSet>>
   prepareStep?: PrepareStepFunction<ToolSet>
   abortSignal?: AbortSignal
+  suppressFinish?: boolean
 }
 
 async function streamAgentResponse(
@@ -426,6 +394,15 @@ async function streamAgentResponse(
         firstChunkLogged = true
       }
       if (streamParams.writer) {
+        if (
+          streamParams.suppressFinish &&
+          typeof value === 'object' &&
+          value !== null &&
+          'type' in value &&
+          (value as { type: string }).type === 'finish'
+        ) {
+          continue
+        }
         streamParams.writer.write(value)
       }
     }
@@ -850,6 +827,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
             filterTools?: (tools: ToolSet) => ToolSet
             includeExecutionPlanTools?: boolean
             metadataPatch?: NonNullable<MessageMetadata>
+            suppressFinish?: boolean
           }): Promise<ChatMessage> => {
             const visibleTimer = lotaDebugLogger.timer(`visible:${runParams.agentId}`)
             let runMemoryBlock = memoryBlock
@@ -885,6 +863,7 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               additionalInstructionSections: runParams.additionalInstructionSections,
               includeExecutionPlanTools,
               writer,
+              suppressFinish: runParams.suppressFinish,
             })
 
             visibleTimer.step('stream-agent-response')
@@ -924,107 +903,106 @@ export async function prepareWorkstreamRunCore(params: WorkstreamRunCoreParams):
               metadataPatch: { trigger: 'plan-turn', planRunId: planTurn.runId, planNodeId: planTurn.nodeId },
             })
           } else {
-            const consultSpecialistTool = createTool({
-              description: 'Consult one specialist teammate for domain-specific guidance before replying to the user.',
-              inputSchema: ConsultSpecialistArgsSchema,
-              execute: async function* (
-                { agentId, task }: ConsultSpecialistArgs,
-                { abortSignal: toolAbortSignal }: { abortSignal?: AbortSignal },
-              ) {
-                const specialistTaskMessage = buildSpecialistTaskMessage({ agentId, task })
-                const specialistAbortSignal = toolAbortSignal ?? runAbort.signal
-                const { result: finalMessage, memoryBlock: nextMemoryBlock } = await runSpecialistSession({
-                  initialMemoryBlock: memoryBlock,
-                  buildTools: async ({ memoryBlock: currentMemoryBlock, onAppendMemoryBlock }) =>
-                    (await buildAgentTools(
-                      buildTurnToolParams({
-                        agentId,
-                        mode: 'fixedWorkstreamMode',
-                        memoryBlock: currentMemoryBlock,
-                        onAppendMemoryBlock,
-                        extraMessages: [specialistTaskMessage],
-                        includeExecutionPlanTools: false,
-                      }),
-                    )) as ToolSet,
-                  run: async ({ tools, memoryBlock: currentMemoryBlock }) =>
-                    await streamAgentResponse(
-                      { ...streamCtx, memoryBlock: currentMemoryBlock },
-                      {
-                        agentId,
-                        mode: 'fixedWorkstreamMode',
-                        messages: buildRunInputMessages([specialistTaskMessage]),
-                        tools: { ...tools, ...toolProviders },
-                        observer: createObserver(agentId),
-                        additionalInstructionSections: coreInstructionSections,
-                        includeExecutionPlanTools: false,
-                        abortSignal: specialistAbortSignal,
-                      },
-                    ),
-                })
-                const committedFinalMessage = withMessageCreatedAt(finalMessage, Date.now())
-                memoryBlock = nextMemoryBlock
-                yield committedFinalMessage
-                return committedFinalMessage
-              },
-              toModelOutput: ({ output }) => {
-                const result = getChatMessageFromToolOutput(output)
-                const agentName =
-                  typeof result?.metadata?.agentName === 'string' && result.metadata.agentName.trim().length > 0
-                    ? result.metadata.agentName.trim()
-                    : 'Specialist'
-                const summary = result ? extractMessageText(result).trim() : ''
-                return {
-                  type: 'text',
-                  value: summary ? `${agentName}: ${summary}` : `${agentName} completed the requested task.`,
-                }
-              },
-            })
-
-            const teamThinkTool =
-              workstream.mode === 'group'
-                ? createTeamThinkTool({
-                    historyMessages: currentMessages,
-                    latestUserMessageId: referenceUserMessageId,
-                    orgId: orgRef,
-                    userId: userRef,
-                    workstreamId: workstreamRef,
-                    githubInstalled,
-                    availableUploads: listReadableUploads(),
-                    provideRepoTool: indexedRepoContext.provideRepoTool,
-                    defaultRepoSectionsByAgent: indexedRepoContext.defaultSectionsByAgent as never,
-                    systemWorkspaceDetails: promptContext.systemWorkspaceDetails,
-                    getPreSeededMemoriesSection,
-                    retrievedKnowledgeSection,
-                    additionalInstructionSections: mergeInstructionSections(
-                      coreInstructionSections,
-                      hookInstructionSections,
-                    ),
-                    getAdditionalInstructionSections: getExecutionPlanInstructionSections,
-                    context: buildContextResult,
-                    toolProviders,
-                    abortSignal: runAbort.signal,
-                  })
-                : null
-
             if (workstream.mode === 'direct') {
               if (!workstream.agentId) {
                 throw new WorkstreamTurnError('Direct workstreams require an assigned agent.', 400)
               }
               await runVisibleAgent({ agentId: workstream.agentId, mode: 'direct' })
             } else {
-              await runVisibleAgent({
-                agentId: visibleWorkstreamAgentId ?? defaultLeadAgentId,
-                mode: 'workstreamMode',
-                skills: coreWorkstreamProfile?.skills ? [...coreWorkstreamProfile.skills] : undefined,
-                additionalInstructionSections: mergeInstructionSections(
-                  coreInstructionSections,
-                  hookInstructionSections,
-                ),
-                extraTools: {
-                  [CONSULT_SPECIALIST_TOOL_NAME]: consultSpecialistTool,
-                  ...(teamThinkTool ? { [CONSULT_TEAM_TOOL_NAME]: teamThinkTool } : {}),
-                },
+              // Multi-agent orchestration for group workstreams
+              const wsMembers = (workstream as { members?: string[] }).members ?? []
+              const members = wsMembers.length > 0 ? wsMembers : [visibleWorkstreamAgentId ?? defaultLeadAgentId]
+              const fallbackAgentId = coreWorkstreamProfile?.config.agentId ?? defaultLeadAgentId
+
+              const recentContext = currentMessages
+                .slice(-6)
+                .map((m) => `${m.role}: ${extractMessageText(m).slice(0, 200)}`)
+                .join('\n')
+
+              const triageResult = await triageWorkstreamMessage({
+                workstreamTitle: workstream.title,
+                members,
+                messageText,
+                recentContext,
               })
+
+              const runGroupAgent = async (
+                agentId: string,
+                options?: { routingContext?: string; suppressFinish?: boolean },
+              ) => {
+                const additionalSections = [...(coreInstructionSections ?? []), ...hookInstructionSections]
+                if (options?.routingContext) {
+                  additionalSections.push(`<routing-context>\n${options.routingContext}\n</routing-context>`)
+                }
+                // Multi-agent member protocol: be direct, focus on domain
+                additionalSections.push(
+                  '<multi-agent-protocol>\nYou are responding as part of a multi-agent workstream. Focus on your domain expertise. Be direct and concise — another agent may follow up on different aspects.\n</multi-agent-protocol>',
+                )
+
+                return await runVisibleAgent({
+                  agentId,
+                  mode: 'workstreamMode',
+                  skills: coreWorkstreamProfile?.skills ? [...coreWorkstreamProfile.skills] : undefined,
+                  additionalInstructionSections: additionalSections,
+                  suppressFinish: options?.suppressFinish,
+                })
+              }
+
+              if (!triageResult) {
+                // No specialist match — fallback to owner (core) or chief (non-core), single agent turn
+                await runGroupAgent(fallbackAgentId)
+              } else {
+                // Run first routed agent — suppress finish in case more agents follow
+                const respondedAgents: string[] = []
+                let lastResponse = await runGroupAgent(triageResult.agentId, {
+                  routingContext: triageResult.routingContext,
+                  suppressFinish: true,
+                })
+                respondedAgents.push(triageResult.agentId)
+
+                // Check if more agents should respond (max 3 total)
+                while (respondedAgents.length < 3) {
+                  const lastResponseText = extractMessageText(lastResponse).slice(0, 500)
+                  const checkResult = await checkForNextAgent({
+                    workstreamTitle: workstream.title,
+                    members,
+                    messageText,
+                    respondedAgents,
+                    lastResponseSummary: lastResponseText,
+                  })
+
+                  if (checkResult.done || !checkResult.agentId) break
+
+                  // Insert hidden bridge message between agent turns
+                  const bridgeMessage: ChatMessage = {
+                    id: Bun.randomUUIDv7(),
+                    role: 'user',
+                    parts: [
+                      {
+                        type: 'text',
+                        text: checkResult.routingContext ?? 'Please also provide your perspective on this topic.',
+                      },
+                    ],
+                    metadata: { hidden: true, createdAt: Date.now() } as MessageMetadata,
+                  }
+                  await workstreamMessageService.upsertMessages({
+                    workstreamId: workstreamRef,
+                    messages: [bridgeMessage],
+                  })
+                  currentMessages = upsertChatHistoryMessage(currentMessages, bridgeMessage)
+
+                  lastResponse = await runGroupAgent(checkResult.agentId, {
+                    routingContext: checkResult.routingContext,
+                    suppressFinish: true,
+                  })
+                  respondedAgents.push(checkResult.agentId)
+                }
+
+                // Write final finish chunk so the client knows the turn is complete
+                if (writer) {
+                  writer.write({ type: 'finish', finishReason: 'stop' } as ChatStreamChunk)
+                }
+              }
             }
           }
         } finally {

package/src/services/workstream.service.ts

@@ -1,7 +1,7 @@
 import { WORKSTREAM, sdkWorkstreamStatusSchema } from '@lota-sdk/shared'
 import { BoundQuery, RecordId, StringRecordId, surql } from 'surrealdb'
 
-import { agentDisplayNames, getCoreWorkstreamProfile, isAgentName } from '../config/agent-defaults'
+import { agentDisplayNames, agentRoster, getCoreWorkstreamProfile, isAgentName } from '../config/agent-defaults'
 import { serverLogger } from '../config/logger'
 import { getWorkstreamBootstrapConfig } from '../config/workstream-defaults'
 import { BaseService } from '../db/base.service'
@@ -152,7 +152,14 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
   async createWorkstream(
     userId: RecordIdRef,
     orgId: RecordIdRef,
-    options?: { title?: string; mode?: string; agentId?: string; core?: boolean; coreType?: string },
+    options?: {
+      title?: string
+      mode?: string
+      agentId?: string
+      core?: boolean
+      coreType?: string
+      members?: string[]
+    },
   ): Promise<NormalizedWorkstream> {
     const mode = options?.mode ?? 'group'
     const directAgentId = options?.agentId
@@ -199,6 +206,7 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
         mode,
         core: false,
         agentId,
+        members: [agentId],
         title,
         status: 'regular',
         nameGenerated: true,
@@ -217,6 +225,7 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
         core: true,
         coreType: resolvedCoreType,
         agentId: coreProfile.config.agentId,
+        members: [...coreProfile.members],
         title,
         status: 'regular',
         nameGenerated: true,
@@ -229,6 +238,7 @@ class WorkstreamService extends BaseService<typeof WorkstreamSchema> {
       organizationId: orgId,
       mode,
       core: false,
+      members: options?.members ?? [...agentRoster],
       title,
       status: 'regular',
       nameGenerated: options?.title !== undefined && options.title !== WORKSTREAM.DEFAULT_TITLE,

package/src/system-agents/index.ts

@@ -10,3 +10,4 @@ export * from './researcher.agent'
 export * from './skill-extractor.agent'
 export * from './skill-manager.agent'
 export * from './title-generator.agent'
+export * from './workstream-manager.agent'

package/src/system-agents/workstream-manager.agent.ts

@@ -0,0 +1,152 @@
+import { ToolLoopAgent } from 'ai'
+import { z } from 'zod'
+
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
+import { agentDescriptions, agentDisplayNames, managerModelId } from '../config/agent-defaults'
+import {
+  OPENROUTER_FAST_REASONING_MODEL_ID,
+  OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS,
+  OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
+} from '../config/model-constants'
+
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
+const TriageResultSchema = z.object({ agentId: z.string(), routingContext: z.string() })
+
+const CheckResultSchema = z.object({
+  done: z.boolean(),
+  agentId: z.string().optional(),
+  routingContext: z.string().optional(),
+})
+
+export type ManagerTriageResult = z.infer<typeof TriageResultSchema>
+export type ManagerCheckResult = z.infer<typeof CheckResultSchema>
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function buildMembersDescription(members: readonly string[]): string {
+  return members
+    .map((id) => {
+      const display = agentDisplayNames[id] ?? id
+      const desc = agentDescriptions[id] ?? ''
+      return `- ${display} (id: ${id}): ${desc}`
+    })
+    .join('\n')
+}
+
+function extractJson(text: string): unknown {
+  const match = text.match(/\{[\s\S]*\}/)
+  if (!match) return null
+  try {
+    return JSON.parse(match[0])
+  } catch {
+    return null
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Prompts
+// ---------------------------------------------------------------------------
+
+const TRIAGE_SYSTEM_PROMPT = `You are a workstream message router. Decide which team member should respond to the user message.
+
+Rules:
+- Pick the single best-fit agent from the members list based on domain expertise.
+- If no specialist clearly matches (general chat, greetings, coordination), respond with agentId "".
+- Be decisive. Reply with ONLY a JSON object, no other text.
+
+Format: {"agentId":"<id>","routingContext":"<1-sentence instruction>"}`
+
+const CHECK_SYSTEM_PROMPT = `You decide if another team member should also respond after the previous agent.
+
+Rules:
+- Only add another agent if the user's question has a clearly separate dimension not yet covered.
+- Do NOT add agents for agreement or acknowledgement.
+- Most messages need only one agent. Reply with ONLY a JSON object, no other text.
+
+Format: {"done":true} or {"done":false,"agentId":"<id>","routingContext":"<1-sentence>"}`
+
+// ---------------------------------------------------------------------------
+// Agent functions
+// ---------------------------------------------------------------------------
+
+function createManagerAgent(systemPrompt: string) {
+  const modelId = managerModelId ?? OPENROUTER_FAST_REASONING_MODEL_ID
+  const providerOptions = managerModelId
+    ? OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS
+    : OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS
+  return new ToolLoopAgent({
+    id: 'workstream-manager',
+    model: aiGatewayChatModel(modelId),
+    headers: buildAiGatewayDirectCacheHeaders('workstream-manager'),
+    providerOptions,
+    instructions: systemPrompt,
+    maxOutputTokens: 256,
+  })
+}
+
+export async function triageWorkstreamMessage(params: {
+  workstreamTitle: string
+  members: readonly string[]
+  messageText: string
+  recentContext?: string
+}): Promise<ManagerTriageResult | null> {
+  const membersDesc = buildMembersDescription(params.members)
+  const prompt = [
+    `Workstream: "${params.workstreamTitle}"`,
+    `Members:\n${membersDesc}`,
+    params.recentContext ? `Recent context:\n${params.recentContext}` : '',
+    `User message: "${params.messageText}"`,
+  ]
+    .filter(Boolean)
+    .join('\n\n')
+
+  const agent = createManagerAgent(TRIAGE_SYSTEM_PROMPT)
+  const result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
+
+  const json = extractJson(typeof result.text === 'string' ? result.text : '')
+  const parsed = TriageResultSchema.safeParse(json)
+  if (!parsed.success) return null
+  if (!parsed.data.agentId) return null
+  if (!params.members.includes(parsed.data.agentId)) return null
+
+  return parsed.data
+}
+
+export async function checkForNextAgent(params: {
+  workstreamTitle: string
+  members: readonly string[]
+  messageText: string
+  respondedAgents: string[]
+  lastResponseSummary: string
+}): Promise<ManagerCheckResult> {
+  const remainingMembers = params.members.filter((id) => !params.respondedAgents.includes(id))
+  if (remainingMembers.length === 0) return { done: true }
+
+  const membersDesc = buildMembersDescription(remainingMembers)
+  const respondedList = params.respondedAgents.map((id) => agentDisplayNames[id] ?? id).join(', ')
+
+  const prompt = [
+    `Workstream: "${params.workstreamTitle}"`,
+    `Remaining members:\n${membersDesc}`,
+    `Already responded: ${respondedList}`,
+    `User message: "${params.messageText}"`,
+    `Last response summary: "${params.lastResponseSummary}"`,
+  ].join('\n\n')
+
+  const agent = createManagerAgent(CHECK_SYSTEM_PROMPT)
+  const result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
+
+  const json = extractJson(typeof result.text === 'string' ? result.text : '')
+  const parsed = CheckResultSchema.safeParse(json)
+  if (!parsed.success) return { done: true }
+  if (parsed.data.done) return { done: true }
+  if (!parsed.data.agentId || !remainingMembers.includes(parsed.data.agentId)) return { done: true }
+
+  return parsed.data
+}