nexus-prime 7.9.23 → 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

@@ -19,6 +19,7 @@ import { recordToolInvocation } from './tool-health.js';
 import { getAsyncGate, withAsyncGate } from './async-gate.js';
 import { getCircuitManager, checkBackpressure } from './circuit.js';
 import { completeRun, createRun, failRun, updateStage } from '../../../engines/orchestrator/store.js';
+import { buildSelectionPlan } from '../../../engines/orchestrator/decision-spine.js';
 function summarizeAsyncMcpResult(toolName, result) {
     const text = result?.content
         ?.map((part) => part?.type === 'text' ? String(part.text ?? '') : '')
@@ -99,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)
@@ -109,6 +113,158 @@ function resolveMaxSyncMs(toolName, args) {
         ?? coerceBoundedWaitMs(args.maxSyncMs)
         ?? (toolName === 'nexus_orchestrate' ? ORCHESTRATE_DEFAULT_MAX_SYNC_MS : DEFAULT_MAX_SYNC_MS);
 }
+function asStringList(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => typeof item === 'string' ? item : (item && typeof item === 'object' ? String(item.name ?? item.id ?? '') : String(item ?? '')))
+            .map((item) => item.trim())
+            .filter(Boolean);
+    }
+    if (typeof value === 'string') {
+        return value.split(',')
+            .map((item) => item.trim())
+            .filter(Boolean);
+    }
+    return [];
+}
+function uniqueList(items, max = 8) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        const value = String(item ?? '').trim();
+        if (!value || seen.has(value))
+            continue;
+        seen.add(value);
+        out.push(value);
+        if (out.length >= max)
+            break;
+    }
+    return out;
+}
+function extractLinkedSelectors(prompt, prefix) {
+    const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`\\[${escaped}([^\\]\\s]+)\\]`, 'g');
+    return Array.from(prompt.matchAll(pattern))
+        .map((match) => match[1]?.trim())
+        .filter(Boolean);
+}
+function inferQueuedOrchestratePreview(args, runId) {
+    const prompt = String(args.prompt ?? args.goal ?? '');
+    const lower = prompt.toLowerCase();
+    const files = uniqueList([
+        ...asStringList(args.files),
+        ...asStringList(args.filePaths),
+    ], 20);
+    const skills = uniqueList([
+        ...asStringList(args.skills),
+        ...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),
+        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),
+        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/)
+        ? '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,
+        intent: lower.match(/fix|bug|broken|doesn.?t|failed/) ? 'bugfix' : 'feature',
+        files,
+        skillNames: skills,
+        workflowSelectors: workflows,
+    };
+    const workerManifests = uniqueList([
+        specialists.length > 0 ? 'worker_coder' : undefined,
+        'worker_verifier',
+    ]).map((workerId, index) => ({
+        workerId,
+        role: index === 0 ? 'coder' : 'verifier',
+        specialistName: index === 0 ? specialists[0] : 'Verification Engineer',
+        actions: index === 0 ? ['inspect', 'patch'] : ['verify'],
+        verifyCommands: index === 1 ? ['npm run lint', 'targeted tests'] : [],
+    }));
+    const run = {
+        runId,
+        requestBrief: {
+            id: `brief_${runId}`,
+            intent: task.intent,
+            risk,
+            confidence: 0.68,
+        },
+        plannerResult: {
+            selectedFiles: files,
+            selectedSkills: skills,
+            selectedWorkflows: workflows,
+            selectedSpecialists: specialists.map((name) => ({ name })),
+            selectedCrew: { name: crew },
+        },
+        workerManifests,
+    };
+    const plan = buildSelectionPlan({ run, task });
+    return { plan, crew, specialists, workflows };
+}
+function formatBudgetRoute(plan) {
+    const total = Number(plan.budgets?.total ?? 0);
+    const code = Number(plan.budgets?.codeBlocks ?? plan.budgets?.codeBlockPolicy?.reservedTokens ?? 0);
+    const cap = Number(plan.executionPolicy?.agentFlow?.maxTaskCostUsd ?? plan.executionPolicy?.budgetCapUsd ?? 0);
+    return `${total.toLocaleString()} tokens · ${code.toLocaleString()} code-block tokens · $${cap.toFixed(2)} task cap`;
+}
+function formatQueuedOrchestrateReceipt(args, receipt) {
+    const preview = inferQueuedOrchestratePreview(args, receipt.runId);
+    const plan = preview.plan;
+    const stages = Array.isArray(plan.executionPolicy?.agentFlow?.stages)
+        ? plan.executionPolicy.agentFlow.stages
+        : [];
+    const selected = plan.selected ?? {};
+    const specialists = uniqueList([...(selected.specialists ?? []), ...preview.specialists], 8);
+    const workflows = uniqueList([...(selected.workflows ?? []), ...preview.workflows], 8);
+    const skills = uniqueList(selected.skills ?? [], 8);
+    const receiptJson = JSON.stringify({ queued: true, runId: receipt.runId, etaMs: receipt.etaMs }, null, 2);
+    const hiredLine = [
+        `crew ${preview.crew}`,
+        specialists.length ? `specialists ${specialists.join(', ')}` : '',
+        workflows.length ? `workflows ${workflows.join(', ')}` : '',
+        skills.length ? `skills ${skills.join(', ')}` : '',
+    ].filter(Boolean).join(' · ');
+    return [
+        'Nexus orchestration queued with hiring preflight.',
+        `Run: ${receipt.runId}`,
+        `ETA: ${receipt.etaMs ? `~${Math.ceil(receipt.etaMs / 1000)}s` : 'background'}`,
+        `Hired/selected: ${hiredLine}`,
+        `Model route: ${plan.modelRoute?.workerTier ?? 'T1'}${plan.modelRoute?.reviewerTier ? ` + reviewer ${plan.modelRoute.reviewerTier}` : ''}`,
+        `Budget route: ${formatBudgetRoute(plan)}`,
+        stages.length ? `AgentFlow gates: ${stages.map((stage) => `${stage.stage}:${stage.ownerRole}`).join(' -> ')}` : '',
+        'Poll progress with nexus_run_status(runId).',
+        '',
+        '```json',
+        receiptJson,
+        '```',
+    ].filter((line) => line !== '').join('\n');
+}
 /**
  * Route a tool call to the appropriate handler group.
  *
@@ -232,8 +388,10 @@ export async function dispatchMcpToolCall(hctx, request, args, ctx) {
                 rawResult = {
                     content: [{
                             type: 'text',
-                            text: JSON.stringify({ queued: true, runId: gated.runId, etaMs: gated.etaMs }, null, 2)
-                                + '\n\nCall nexus_run_status(runId) to check progress.',
+                            text: toolName === 'nexus_orchestrate'
+                                ? formatQueuedOrchestrateReceipt(args, gated)
+                                : JSON.stringify({ queued: true, runId: gated.runId, etaMs: gated.etaMs }, null, 2)
+                                    + '\n\nCall nexus_run_status(runId) to check progress.',
                         }],
                 };
             }

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.23",
+  "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",