nexus-prime 7.9.24 → 7.9.25

package/dist/agents/adapters/mcp/definitions.js

@@ -280,9 +280,10 @@ export function buildMcpToolDefinitions() {
                     specialists: { type: 'array', items: { type: 'string' }, description: 'Optional hard specialist selectors' },
                     optimizationProfile: { type: 'string', enum: ['standard', 'max'], description: 'Planner optimization profile override' },
                     executionPreset: { type: 'string', enum: ['fast', 'balanced', 'deep', 'release'], description: 'Optional execution preset that maps orchestration depth, verification strictness, and backend routing' },
-                    background: { type: 'boolean', description: 'When true, return a queued receipt immediately and let the run continue in the async gate.' },
+                    background: { type: 'boolean', description: 'Compatibility flag; nexus_orchestrate already returns a queued hiring preflight by default and continues in the async gate.' },
                     async: { type: 'boolean', description: 'Alias for background; useful for clients that prefer explicit async orchestration.' },
-                    waitMs: { type: 'number', description: 'Optional bounded wait before returning a queued receipt. Clamped to 45 seconds; normal orchestrate calls default to 15 seconds.' }
+                    waitMs: { type: 'number', description: 'Advanced/debug bounded wait for inline execution. Clamped to 45 seconds; normal orchestrate calls return a queued preflight immediately.' },
+                    inline: { type: 'boolean', description: 'Advanced/debug only: wait for inline orchestrate output instead of the default fast queued preflight.' }
                 },
                 required: ['prompt'],
             },

package/dist/agents/adapters/mcp/dispatch.js

@@ -100,6 +100,9 @@ function coerceBoundedWaitMs(value) {
 function shouldReturnQueuedReceipt(toolName, args) {
     if (!SLOW_TOOLS.has(toolName))
         return false;
+    if (toolName === 'nexus_orchestrate') {
+        return !isTruthyFlag(args.inline) && !isTruthyFlag(args.sync) && !isTruthyFlag(args.blocking);
+    }
     return isTruthyFlag(args.background)
         || isTruthyFlag(args.async)
         || isTruthyFlag(args.queue)
@@ -157,29 +160,35 @@ function inferQueuedOrchestratePreview(args, runId) {
         ...asStringList(args.skillNames),
         ...extractLinkedSelectors(prompt, '$'),
     ], 20);
+    const isRuntimeControlPlane = /orchestrat|synapse|architect|runtime|mcp|dispatch|route|routing|queue|queued|scheduler|model routing|worker|hiring|workflow selection|token|budget|memory|lifecycle/.test(lower);
+    const wantsResearch = /research|paper|literature|deep-research|source-grounded|cited/.test(lower);
+    const wantsMemory = /memory|recall|learning|decay|graph|mcp/.test(lower);
+    const wantsPerf = /fast|faster|millisecond|latency|performance|budget|token|optim/i.test(lower);
     const workflows = uniqueList([
         ...asStringList(args.workflows),
         ...asStringList(args.workflowSelectors),
-        lower.match(/orchestrat|route|dispatch|queue|queued/) ? 'orchestration-runtime-workflow' : undefined,
-        lower.match(/synapse|hiring|operative|sortie/) ? 'synapse-mandate-workflow' : undefined,
-        lower.match(/memory|recall|learning|decay|graph/) ? 'memory-lifecycle-workflow' : undefined,
-        lower.match(/token|budget|optim/i) ? 'token-budget-workflow' : undefined,
-        lower.match(/dashboard|board|ui|ux/) ? 'dashboard-observability-workflow' : undefined,
+        isRuntimeControlPlane ? 'orchestration-execution-loop' : undefined,
+        isRuntimeControlPlane ? 'backend-execution-loop' : undefined,
+        isRuntimeControlPlane ? 'testing-execution-loop' : undefined,
+        isRuntimeControlPlane && !wantsResearch ? 'typescript-execution-loop' : undefined,
+        wantsResearch ? 'research-and-implement' : undefined,
+        lower.match(/dashboard|board|ui|ux/) && !isRuntimeControlPlane ? 'frontend-execution-loop' : undefined,
     ], 8);
     const specialists = uniqueList([
         ...asStringList(args.specialists),
-        lower.match(/orchestrat|route|dispatch|queue|queued/) ? 'Orchestrator Runtime Engineer' : undefined,
-        lower.match(/synapse|hiring|operative|sortie/) ? 'Synapse Runtime Engineer' : undefined,
-        lower.match(/memory|recall|learning|decay|graph/) ? 'Memory Systems Engineer' : undefined,
-        lower.match(/token|budget|optim/i) ? 'Token Budget Engineer' : undefined,
-        lower.match(/dashboard|board|ui|ux/) ? 'Dashboard UX Engineer' : undefined,
+        isRuntimeControlPlane ? 'Agents Orchestrator' : undefined,
+        isRuntimeControlPlane ? 'Backend Architect' : undefined,
+        isRuntimeControlPlane ? 'Workflow Optimizer' : undefined,
+        wantsPerf ? 'Performance Benchmarker' : undefined,
+        wantsMemory && !wantsPerf ? 'Backend Architect' : undefined,
+        lower.match(/dashboard|board|ui|ux/) && !isRuntimeControlPlane ? 'Frontend Developer' : undefined,
         lower.match(/test|verify|qa|release|publish/) ? 'Verification Engineer' : undefined,
     ], 8);
     const crew = String(args.crew ?? args.selectedCrew ?? (lower.match(/orchestrat|synapse|runtime|mcp|dispatch|queue|queued/)
-        ? 'Runtime Reliability Crew'
-        : lower.match(/memory|token|dashboard/)
-            ? 'Control Plane Quality Crew'
-            : 'Nexus Implementation Crew'));
+        ? 'Implementation Crew'
+        : lower.match(/research|paper|literature/)
+            ? 'Research Crew'
+            : 'Implementation Crew'));
     const risk = lower.match(/fix|broken|bug|doesn.?t|failed|queued|runtime|synapse|orchestrat/) ? 'high' : 'medium';
     const task = {
         goal: prompt,

package/dist/engines/orchestrator.d.ts

@@ -183,6 +183,8 @@ export declare class OrchestratorEngine {
     private searchIndexedRepoCandidates;
     private toFileRef;
     private resolveSelections;
+    private inferRuntimeCatalogHints;
+    private filterExistingCatalogSelectors;
     private getSkillCatalogItems;
     private getWorkflowCatalogItems;
     private getHookCatalogItems;

package/dist/engines/orchestrator.js

@@ -2382,10 +2382,16 @@ export class OrchestratorEngine {
             limit: 5,
             selector: 'name',
         });
-        const workflowSelection = this.resolveCatalogVotes('workflow', task, intent, options.workflowSelectors?.length ? allWorkflowItems : workflowItems, {
+        const runtimeCatalogHints = this.inferRuntimeCatalogHints(task, intent, {
+            workflows: allWorkflowItems,
+            specialists: allSpecialistItems,
+            crews: allCrewItems,
+        });
+        const workflowSelection = this.resolveCatalogVotes('workflow', task, intent, options.workflowSelectors?.length || runtimeCatalogHints.workflows.length ? allWorkflowItems : workflowItems, {
             explicit: options.workflowSelectors,
             planner: planner.selectedWorkflows,
             knowledge: knowledgeFabric.recommendations.workflows,
+            runtime: runtimeCatalogHints.workflows,
             scorerLimit: 4,
             limit: 4,
             selector: 'name',
@@ -2423,18 +2429,20 @@ export class OrchestratorEngine {
             limit: intent.taskType === 'release' || this.sessionState.repeatedFailures > 0 ? 3 : 2,
             selector: 'name',
         });
-        const specialistSelection = this.resolveCatalogVotes('specialist', task, intent, options.specialistSelectors?.length ? allSpecialistItems : specialistItems, {
+        const specialistSelection = this.resolveCatalogVotes('specialist', task, intent, options.specialistSelectors?.length || runtimeCatalogHints.specialists.length ? allSpecialistItems : specialistItems, {
             explicit: options.specialistSelectors,
             planner: planner.selectedSpecialists.map((specialist) => specialist.specialistId),
             knowledge: knowledgeFabric.recommendations.specialists,
+            runtime: runtimeCatalogHints.specialists,
             scorerLimit: 4,
             limit: 4,
             selector: 'id',
         });
-        const crewSelection = this.resolveCatalogVotes('crew', task, intent, options.crewSelectors?.length ? allCrewItems : crewItems, {
+        const crewSelection = this.resolveCatalogVotes('crew', task, intent, options.crewSelectors?.length || runtimeCatalogHints.crews.length ? allCrewItems : crewItems, {
             explicit: options.crewSelectors,
             planner: planner.selectedCrew ? [planner.selectedCrew.crewId] : [],
             knowledge: knowledgeFabric.recommendations.crews,
+            runtime: runtimeCatalogHints.crews,
             scorerLimit: 2,
             limit: 1,
             selector: 'id',
@@ -2504,6 +2512,47 @@ export class OrchestratorEngine {
             },
         };
     }
+    inferRuntimeCatalogHints(task, intent, catalog) {
+        const lower = task.toLowerCase();
+        const isControlPlane = /\b(orchestrat(?:e|or|ion)|synapse|architects?|mcp|dispatch|routing|route|queued?|queue|scheduler|runtime|control plane|agentflow|worker|hiring|specialist|crew|workflow selection|model routing|token budget|memory hook|memory graph|lifecycle)\b/.test(lower);
+        if (!isControlPlane) {
+            return { workflows: [], specialists: [], crews: [] };
+        }
+        const wantsResearch = /\b(research|papers?|literature|source-grounded|cited|deep-research)\b/.test(lower);
+        const wantsMemory = /\b(memory|recall|learning|decay|graph|mcp)\b/.test(lower);
+        const wantsPerf = /\b(fast|faster|milliseconds?|latency|performance|budget|token|optim(?:i|is|iz))\b/.test(lower);
+        const readOnlyResearch = intent.taskType === 'research'
+            && !/\b(fix|patch|implement|refactor|change|add|wire|ship|deploy|release|mutate|improve)\b/.test(lower);
+        const workflowSelectors = [
+            'orchestration-execution-loop',
+            'backend-execution-loop',
+            'testing-execution-loop',
+            wantsResearch ? 'research-and-implement' : 'typescript-execution-loop',
+        ];
+        const specialistSelectors = [
+            'specialist_specialized-agents-orchestrator',
+            'specialist_engineering-engineering-backend-architect',
+            'specialist_testing-testing-workflow-optimizer',
+            wantsPerf
+                ? 'specialist_testing-testing-performance-benchmarker'
+                : wantsMemory
+                    ? 'specialist_integrations-mcp-memory-backend-architect-with-memory'
+                    : undefined,
+        ];
+        const crewSelectors = [
+            readOnlyResearch ? 'crew_research' : 'crew_implementation',
+        ];
+        return {
+            workflows: this.filterExistingCatalogSelectors(catalog.workflows, workflowSelectors, 'name'),
+            specialists: this.filterExistingCatalogSelectors(catalog.specialists, specialistSelectors, 'id'),
+            crews: this.filterExistingCatalogSelectors(catalog.crews, crewSelectors, 'id'),
+        };
+    }
+    filterExistingCatalogSelectors(items, selectors, selector) {
+        const existing = new Set(items.map((item) => selector === 'id' ? item.id : item.name));
+        return dedupeStrings(selectors.filter((value) => Boolean(value)))
+            .filter((value) => existing.has(value));
+    }
     getSkillCatalogItems() {
         const skills = this.runtime.listSkillsForSelection();
         const signature = skills
@@ -2657,7 +2706,7 @@ export class OrchestratorEngine {
             applyVote(value, 'knowledge-fabric', 0.76, 'medium', 'Knowledge Fabric recommended this artifact from cross-source evidence.');
         });
         (input.runtime ?? []).forEach((value) => {
-            applyVote(value, 'runtime-resolver', 0.84, 'high', 'Runtime resolver matched this artifact against the registered catalog for the active goal.');
+            applyVote(value, 'runtime-resolver', 2.0, 'high', 'Runtime resolver matched this artifact against the registered catalog for the active goal.');
         });
         this.pickCatalogEntries(task, intent, items, input.scorerLimit).forEach((entry) => {
             applyVote(input.selector === 'id' ? entry.item.id : entry.item.name, 'scorer', Math.min(0.7, entry.score / 10), entry.score >= 9 ? 'medium' : 'low', `Keyword scorer matched the task with score ${entry.score}.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexus-prime",
-  "version": "7.9.24",
+  "version": "7.9.25",
   "description": "Local-first MCP control plane for coding agents with bootstrap-orchestrate execution, memory fabric, token budgeting, and worktree-backed swarms",
   "type": "module",
   "main": "dist/index.js",