@lota-sdk/core 0.1.34 → 0.1.36

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.34",
+  "version": "0.1.36",
   "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.34",
+    "@lota-sdk/shared": "0.1.35",
     "@mendable/firecrawl-js": "^4.18.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.141",

package/src/config/agent-defaults.ts

@@ -11,12 +11,14 @@ 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 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 +26,7 @@ export interface CoreWorkstreamProfile {
 
 export let getCoreWorkstreamProfile: (coreType: string) => CoreWorkstreamProfile = (_coreType) => ({
   config: { coreType: _coreType, agentId: '', title: '' },
+  members: [],
   tools: [],
   skills: [],
   instructions: '',
@@ -34,6 +37,7 @@ export function configureAgents(config: {
   leadAgentId: string
   displayNames: Record<string, string>
   shortDisplayNames?: Record<string, string>
+  descriptions?: Record<string, string>
   teamConsultParticipants: readonly string[]
   getCoreWorkstreamProfile?: (coreType: string) => CoreWorkstreamProfile
 }): void {
@@ -45,6 +49,7 @@ export function configureAgents(config: {
   leadAgentId = config.leadAgentId
   agentDisplayNames = config.displayNames
   agentShortDisplayNames = config.shortDisplayNames ?? {}
+  agentDescriptions = config.descriptions ?? {}
   teamConsultParticipants = config.teamConsultParticipants
   if (config.getCoreWorkstreamProfile) {
     getCoreWorkstreamProfile = config.getCoreWorkstreamProfile

package/src/config/model-constants.ts

@@ -12,6 +12,7 @@ export {
   OPENROUTER_TEAM_AGENT_MODEL_ID,
   OPENROUTER_WEB_RESEARCH_MODEL_ID,
   OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS,
+  OPENROUTER_MANAGER_MODEL_ID,
 } from '@lota-sdk/shared'
 
 // Both aliases point to the same underlying model. Keep the names separate so

package/src/create-runtime.ts

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

package/src/runtime/runtime-config.ts

@@ -173,6 +173,9 @@ 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(),
     teamConsultParticipants: z.array(z.string().trim().min(1)),
     getCoreWorkstreamProfile: z
       .custom<(coreType: string) => CoreWorkstreamProfile>(isFunction, {

package/src/services/execution-plan.service.ts

@@ -336,14 +336,9 @@ class ExecutionPlanService {
     input: PlanDraft & { runId: string; reason: string }
   }): Promise<ExecutionPlanToolResultData> {
     const activeRun = await planRunService.getRunById(params.input.runId)
-    if (
-      recordIdToString(activeRun.workstreamId, TABLES.WORKSTREAM) !==
-      recordIdToString(params.workstreamId, TABLES.WORKSTREAM)
-    ) {
-      throw new Error('Execution run belongs to a different workstream.')
-    }
+    const resolvedWorkstreamId = activeRun.workstreamId
 
-    const activeRuns = await planRunService.getActiveRunRecords(params.workstreamId)
+    const activeRuns = await planRunService.getActiveRunRecords(resolvedWorkstreamId)
     if (activeRuns.length === 0) {
       throw new Error('No active execution run exists for this workstream.')
     }
@@ -404,7 +399,7 @@ class ExecutionPlanService {
           .content(
             buildCompiledSpecCreateData({
               organizationId: params.organizationId,
-              workstreamId: params.workstreamId,
+              workstreamId: resolvedWorkstreamId,
               leadAgentId: params.leadAgentId,
               compiled,
               version: supersededSpec.version + 1,
@@ -418,7 +413,7 @@ class ExecutionPlanService {
         runId,
         spec,
         organizationId: params.organizationId,
-        workstreamId: params.workstreamId,
+        workstreamId: resolvedWorkstreamId,
         leadAgentId: params.leadAgentId,
         nodes: compiled.nodes,
         emittedEvents,

package/src/services/plan-executor.service.ts

@@ -986,11 +986,6 @@ class PlanExecutorService {
     emittedBy: string
   }): Promise<ExecutionPlanToolResultData> {
     const run = await planRunService.getRunById(params.runId)
-    if (
-      recordIdToString(run.workstreamId, TABLES.WORKSTREAM) !== recordIdToString(params.workstreamId, TABLES.WORKSTREAM)
-    ) {
-      throw new Error('Execution run belongs to a different workstream.')
-    }
 
     const spec = await planRunService.getPlanSpecById(run.planSpecId)
     const nodeSpecs = await planRunService.listNodeSpecs(spec.id)
@@ -1119,11 +1114,6 @@ class PlanExecutorService {
     failureClass: PlanFailureClass
   }): Promise<SerializableExecutionPlan> {
     const run = await planRunService.getRunById(params.runId)
-    if (
-      recordIdToString(run.workstreamId, TABLES.WORKSTREAM) !== recordIdToString(params.workstreamId, TABLES.WORKSTREAM)
-    ) {
-      throw new Error('Execution run belongs to a different workstream.')
-    }
 
     const spec = await planRunService.getPlanSpecById(run.planSpecId)
     const nodeSpec = await planRunService.getNodeSpecByNodeId(spec.id, params.nodeId)

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,
@@ -924,107 +891,91 @@ 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 members =
+                workstream.members.length > 0 ? workstream.members : [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, routingContext?: string) => {
+                const additionalSections = [...(coreInstructionSections ?? []), ...hookInstructionSections]
+                if (routingContext) {
+                  additionalSections.push(`<routing-context>\n${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,
+                })
+              }
+
+              if (!triageResult) {
+                // No specialist match — fallback to owner (core) or chief (non-core)
+                await runGroupAgent(fallbackAgentId)
+              } else {
+                // Run first routed agent
+                const respondedAgents: string[] = []
+                let lastResponse = await runGroupAgent(triageResult.agentId, triageResult.routingContext)
+                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() },
+                  }
+                  await workstreamMessageService.upsertMessages({
+                    workstreamId: workstreamRef,
+                    messages: [bridgeMessage],
+                  })
+                  currentMessages = upsertChatHistoryMessage(currentMessages, bridgeMessage)
+
+                  lastResponse = await runGroupAgent(checkResult.agentId, checkResult.routingContext)
+                  respondedAgents.push(checkResult.agentId)
+                }
+              }
             }
           }
         } 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,153 @@
+import { Output, ToolLoopAgent } from 'ai'
+import { z } from 'zod'
+
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
+import { agentDescriptions, agentDisplayNames } from '../config/agent-defaults'
+import { OPENROUTER_MANAGER_MODEL_ID, OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS } from '../config/model-constants'
+
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+
+const TriageResultSchema = z.object({
+  agentId: z.string().describe('The agent ID that should respond next'),
+  routingContext: z.string().describe('Brief instruction for the selected agent about what to focus on'),
+})
+
+const CheckResultSchema = z.object({
+  done: z.boolean().describe('true if no more agents need to respond'),
+  agentId: z.string().optional().describe('Next agent ID if done is false'),
+  routingContext: z.string().optional().describe('Brief instruction for the next agent if done is false'),
+})
+
+export type ManagerTriageResult = z.infer<typeof TriageResultSchema>
+export type ManagerCheckResult = z.infer<typeof CheckResultSchema>
+
+// ---------------------------------------------------------------------------
+// Prompt builders
+// ---------------------------------------------------------------------------
+
+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')
+}
+
+const TRIAGE_SYSTEM_PROMPT = `You are a workstream message router. Your job is to decide which team member should respond to a user message.
+
+<rules>
+- Pick the single best-fit agent from the members list.
+- Consider the agent's domain expertise against the user's question.
+- If the message is clearly about a specific domain (marketing, tech, product, finance, etc.), route to the domain specialist.
+- If multiple domains are equally relevant, pick the most relevant one — a follow-up check will decide if another agent should also respond.
+- If no specialist clearly matches (general chat, greetings, coordination), respond with an empty agentId to signal fallback.
+- Be decisive. Do not overthink.
+</rules>
+
+<output-format>
+Respond with JSON only: { "agentId": "<agent-id>", "routingContext": "<1-sentence instruction>" }
+If no specialist matches, respond: { "agentId": "", "routingContext": "" }
+</output-format>`
+
+const CHECK_SYSTEM_PROMPT = `You are a workstream conversation reviewer. After an agent has responded to a user message, you decide if another team member should also respond.
+
+<rules>
+- Only add another agent if the user's question has a clearly separate dimension that the previous agent(s) did not cover.
+- Do NOT add agents just for acknowledgement or agreement.
+- Do NOT repeat the same domain. If the CTO already covered tech, don't add another tech perspective.
+- Most messages need only one agent. Multi-agent responses should be the exception, not the rule.
+- Maximum 3 total agent responses per user message.
+</rules>
+
+<output-format>
+Respond with JSON only: { "done": true } or { "done": false, "agentId": "<agent-id>", "routingContext": "<1-sentence instruction>" }
+</output-format>`
+
+// ---------------------------------------------------------------------------
+// Agent functions
+// ---------------------------------------------------------------------------
+
+function createManagerAgent(systemPrompt: string, schema: z.ZodSchema) {
+  return new ToolLoopAgent({
+    id: 'workstream-manager',
+    model: aiGatewayChatModel(OPENROUTER_MANAGER_MODEL_ID),
+    headers: buildAiGatewayDirectCacheHeaders('workstream-manager'),
+    providerOptions: OPENROUTER_XHIGH_REASONING_PROVIDER_OPTIONS,
+    instructions: systemPrompt,
+    output: Output.object({ schema }),
+    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}"`,
+    `\nMembers:\n${membersDesc}`,
+    params.recentContext ? `\nRecent context:\n${params.recentContext}` : '',
+    `\nUser message: "${params.messageText}"`,
+  ]
+    .filter(Boolean)
+    .join('\n')
+
+  const agent = createManagerAgent(TRIAGE_SYSTEM_PROMPT, TriageResultSchema)
+  const result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 15_000 } })
+
+  const parsed = TriageResultSchema.safeParse(result.output)
+  if (!parsed.success) return null
+
+  // Empty agentId = no specialist match, fallback to owner/chief
+  if (!parsed.data.agentId) return null
+
+  // Validate agent is in members list
+  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}"`,
+    `\nRemaining members:\n${membersDesc}`,
+    `\nAlready responded: ${respondedList}`,
+    `\nUser message: "${params.messageText}"`,
+    `\nLast response summary: "${params.lastResponseSummary}"`,
+  ].join('\n')
+
+  const agent = createManagerAgent(CHECK_SYSTEM_PROMPT, CheckResultSchema)
+  const result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 15_000 } })
+
+  const parsed = CheckResultSchema.safeParse(result.output)
+  if (!parsed.success) return { done: true }
+
+  if (parsed.data.done) return { done: true }
+
+  // Validate next agent is in remaining members
+  if (!parsed.data.agentId || !remainingMembers.includes(parsed.data.agentId)) {
+    return { done: true }
+  }
+
+  return parsed.data
+}