0xray 3.1.0 → 3.2.0

package/src/mcps/orchestrator/server.ts

@@ -11,6 +11,7 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
+import * as fs from 'fs';
 import { frameworkLogger } from '../../core/framework-logger.js';
 import { XrayStateManager } from '../../state/state-manager.js';
 import { MultiAgentOrchestrationCoordinator } from '../../orchestrator/multi-agent-orchestration-coordinator.js';
@@ -19,6 +20,16 @@ import { TaskHandler } from './handlers/task-handler.js';
 import { ComplexityHandler } from './handlers/complexity-handler.js';
 import { StatusHandler } from './handlers/status-handler.js';
 import type { OrchestrationTask, OrchestrationResult } from './types.js';
+import {
+  spawnAside,
+  closeAside,
+  closeAllAsides,
+  addObservations,
+  getActiveAsideCount,
+  getActiveAsideIds,
+  getAsideState,
+  extractGovernanceObservations,
+} from './aside-context.js';
 
 /**
  * Orchestrator MCP Server
@@ -233,33 +244,65 @@ export class OrchestratorServer {
         const { name, arguments: args } = request.params;
 
         switch (name) {
-          case 'orchestrate-task':
-            return await this.taskHandler.handleOrchestrateTask(args as {
+          case 'orchestrate-task': {
+            const orchArgs = args as {
               description: string;
               tasks?: OrchestrationTask[];
               sessionId?: string;
               executionMode?: string;
               timeout?: number;
-            }, { taskHistory: this.taskHistory, activeTasks: this.activeTasks });
-            
-          case 'analyze-complexity':
-            return await this.complexityHandler.handleAnalyzeComplexity(args as {
-              tasks: OrchestrationTask[];
+            };
+            const aside = await spawnAside({
+              description: `Orchestration: ${orchArgs.description}`,
+              ...(orchArgs.sessionId ? { sessionId: orchArgs.sessionId } : {}),
+              inheritedContext: { taskCount: orchArgs.tasks?.length ?? 0, executionMode: orchArgs.executionMode ?? 'optimized' },
             });
-            
+            try {
+              const result = await this.taskHandler.handleOrchestrateTask(
+                orchArgs,
+                { taskHistory: this.taskHistory, activeTasks: this.activeTasks, asideId: aside.asideId },
+              );
+              return result;
+            } finally {
+              closeAside(aside.asideId);
+            }
+          }
+          case 'analyze-complexity': {
+            const complexityArgs = args as { tasks: OrchestrationTask[] };
+            const aside = await spawnAside({
+              description: `Complexity analysis: ${complexityArgs.tasks.length} tasks`,
+            });
+            try {
+              return await this.complexityHandler.handleAnalyzeComplexity(complexityArgs, aside.asideId);
+            } finally {
+              closeAside(aside.asideId);
+            }
+          }
           case 'get-orchestration-status':
             return await this.statusHandler.handleGetOrchestrationStatus(args as {
               sessionId?: string;
               detailed?: boolean;
-            }, { taskHistory: this.taskHistory, activeTasks: this.activeTasks });
-            
-          case 'cancel-orchestration':
-            return await this.statusHandler.handleCancelOrchestration(args as {
-              sessionId?: string;
-              taskId?: string;
-              force?: boolean;
-            }, { taskHistory: this.taskHistory, activeTasks: this.activeTasks });
-            
+            }, {
+              taskHistory: this.taskHistory,
+              activeTasks: this.activeTasks,
+              asideCount: getActiveAsideCount(),
+              asideIds: getActiveAsideIds(),
+            });
+          case 'cancel-orchestration': {
+            const cancelArgs = args as { sessionId?: string; taskId?: string; force?: boolean };
+            if (cancelArgs.force || (!cancelArgs.sessionId && !cancelArgs.taskId)) {
+              closeAllAsides();
+            } else if (cancelArgs.sessionId) {
+              const asideIds = getActiveAsideIds().filter(
+                (id) => getAsideState(id)?.sessionId === cancelArgs.sessionId,
+              );
+              for (const id of asideIds) closeAside(id);
+            }
+            return await this.statusHandler.handleCancelOrchestration(cancelArgs, {
+              taskHistory: this.taskHistory,
+              activeTasks: this.activeTasks,
+            });
+          }
           case 'optimize-orchestration':
             return await this.statusHandler.handleOptimizeOrchestration(args as {
               history?: boolean;
@@ -310,26 +353,38 @@ export class OrchestratorServer {
         skipApply: args.skipApply ?? false,
       });
 
-      const result = await cycle.governExternalProposals(args.proposals as any);
+      const aside = await spawnAside({
+        description: `Governance cycle: ${args.proposals.length} proposals`,
+        priorVerdictContext: { proposalCount: args.proposals.length },
+      });
+
+      let result: import('../../inference/inference-cycle.js').InferenceCycleResult;
+      try {
+        result = await cycle.governExternalProposals(args.proposals as any);
+        addObservations(aside.asideId, extractGovernanceObservations(result));
+      } finally {
+        closeAside(aside.asideId);
+      }
 
-      const approved = result.votes.filter((v) => v.decision === 'approve').length;
-      const rejected = result.votes.length - approved;
+      const approved = result!.votes.filter((v) => v.decision === 'approve').length;
+      const rejected = result!.votes.length - approved;
 
       return {
         content: [{
           type: 'text' as const,
           text: JSON.stringify({
-            cycleId: result.cycleId,
+            cycleId: result!.cycleId,
+            asideId: aside.asideId,
             approved,
             rejected,
-            votes: result.votes,
-            proposals: result.proposals.map((p) => ({
+            votes: result!.votes,
+            proposals: result!.proposals.map((p) => ({
               id: p.id,
               title: p.title,
               type: p.type,
               status: p.status,
             })),
-            duration: result.duration,
+            duration: result!.duration,
           }, null, 2),
         }],
       };
@@ -359,6 +414,7 @@ export class OrchestratorServer {
    * Stop the server
    */
   async stop(): Promise<void> {
+    closeAllAsides();
     await frameworkLogger.log('orchestrator.server', 'shutdown', 'info', {
       message: '0xRay Orchestrator MCP Server shutting down',
     });
@@ -377,7 +433,7 @@ export function createOrchestratorServer(): OrchestratorServer {
 }
 
 // Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = createOrchestratorServer();
   server.start().catch((error) => {
     frameworkLogger.log('orchestrator.server', 'fatal-error', 'error', {

package/src/mcps/orchestrator/types.ts

@@ -52,6 +52,41 @@ export interface TaskValidation {
   errors: string[];
 }
 
+export interface ActiveAside {
+  asideId: string;
+  description: string;
+  sessionId?: string;
+  parentAsideId?: string;
+  startedAt: number;
+  inheritedContext?: Record<string, unknown>;
+  priorVerdictContext?: Record<string, unknown>;
+  observations: AsideObservation[];
+}
+
+export interface AsideObservation {
+  key: string;
+  value: string;
+  source: string;
+}
+
+export interface AsideContextOptions {
+  description: string;
+  inheritedContext?: Record<string, unknown>;
+  priorVerdictContext?: Record<string, unknown>;
+  sessionId?: string;
+  parentAsideId?: string;
+}
+
+export interface AsideResult {
+  asideId: string;
+  description: string;
+  success: boolean;
+  duration: number;
+  observations: AsideObservation[];
+  priorVerdictContext?: Record<string, unknown>;
+  error?: string;
+}
+
 export interface OrchestrationStatus {
   activeSessions: number;
   totalTasks: number;
@@ -62,6 +97,8 @@ export interface OrchestrationStatus {
     tasks: number;
     duration: number;
   }>;
+  activeAsideCount?: number;
+  activeAsideIds?: string[];
 }
 
 export interface TaskExecutionContext {

package/src/mcps/orchestrator.server.ts

@@ -7,6 +7,7 @@
  * @deprecated Use src/mcps/orchestrator/server.ts instead
  */
 
+import * as fs from 'fs';
 import { frameworkLogger } from '../core/framework-logger.js';
 
 export { OrchestratorServer, createOrchestratorServer } from './orchestrator/server.js';
@@ -24,7 +25,7 @@ export type {
 } from './orchestrator/types.js';
 
 // Run if called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const { createOrchestratorServer } = await import('./orchestrator/server.js');
   const server = createOrchestratorServer();
   server.start().catch((error) => {

package/src/mcps/performance-analysis.server.ts

@@ -4,17 +4,12 @@
  * Comprehensive metrics analysis for framework integration and optimization
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { frameworkLogger, generateJobId } from "../core/framework-logger.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
 import { execSync } from "child_process";
 import fs from "fs";
 import os from "os";
 import path from "path";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface AnalysisMetrics {
   runtime?: RuntimeMetrics;
@@ -57,23 +52,73 @@ interface ResourceMetrics {
   recommendations: string[];
 }
 
-class XrayPerformanceAnalysisServer {
-  private server: Server;
+class XrayPerformanceAnalysisServer extends XrayKnowledgeSkillBase {
   private startTime: number;
 
   constructor() {
-    this.server = new Server(
+    super("performance-analysis", "3.1.0");
+
+    this.startTime = Date.now();
+
+    this.tools = [
       {
-        name: "performance-analysis", version: "1.22.67",
+        name: "performance-analysis",
+        description:
+          "Comprehensive metrics analysis for framework integration and optimization",
+        inputSchema: {
+          type: "object",
+          properties: {
+            scope: {
+              type: "string",
+              enum: [
+                "full",
+                "runtime",
+                "build",
+                "resources",
+                "bottlenecks",
+              ],
+              default: "full",
+              description: "Scope of performance analysis",
+            },
+            duration: {
+              type: "number",
+              default: 30,
+              description: "Analysis duration in seconds",
+            },
+            detailed: {
+              type: "boolean",
+              default: false,
+              description: "Include detailed metrics and recommendations",
+            },
+          },
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "bottleneck-detection",
+        description:
+          "Identify performance bottlenecks in framework operations",
+        inputSchema: {
+          type: "object",
+          properties: {
+            operation: {
+              type: "string",
+              description: "Specific operation to analyze",
+            },
+            threshold: {
+              type: "number",
+              default: 1000,
+              description: "Performance threshold in milliseconds",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "performance-analysis": async (args) => this.handlePerformanceAnalysis(args as Record<string, unknown> | undefined),
+      "bottleneck-detection": async (args) => this.handleBottleneckDetection(args as Record<string, unknown> | undefined),
+    };
 
-    this.startTime = Date.now();
     this.setupToolHandlers();
     frameworkLogger.log(
       "mcp-performance-analysis",
@@ -82,81 +127,6 @@ class XrayPerformanceAnalysisServer {
     );
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "performance-analysis",
-            description:
-              "Comprehensive metrics analysis for framework integration and optimization",
-            inputSchema: {
-              type: "object",
-              properties: {
-                scope: {
-                  type: "string",
-                  enum: [
-                    "full",
-                    "runtime",
-                    "build",
-                    "resources",
-                    "bottlenecks",
-                  ],
-                  default: "full",
-                  description: "Scope of performance analysis",
-                },
-                duration: {
-                  type: "number",
-                  default: 30,
-                  description: "Analysis duration in seconds",
-                },
-                detailed: {
-                  type: "boolean",
-                  default: false,
-                  description: "Include detailed metrics and recommendations",
-                },
-              },
-            },
-          },
-          {
-            name: "bottleneck-detection",
-            description:
-              "Identify performance bottlenecks in framework operations",
-            inputSchema: {
-              type: "object",
-              properties: {
-                operation: {
-                  type: "string",
-                  description: "Specific operation to analyze",
-                },
-                threshold: {
-                  type: "number",
-                  default: 1000,
-                  description: "Performance threshold in milliseconds",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "performance-analysis":
-          return await this.handlePerformanceAnalysis(args);
-        case "bottleneck-detection":
-          return await this.handleBottleneckDetection(args);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
-
   private async handlePerformanceAnalysis(args: Record<string, unknown> | undefined) {
     const scope = (args?.scope as string) || "full";
     const duration = (args?.duration as number) || 30;
@@ -691,23 +661,10 @@ ${results.recommendations.map((r) => `• 💡 ${r}`).join("\n") || "No recommen
     return report;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    const jobId = generateJobId("mcp-performance-analysis-server");
-    await frameworkLogger.log(
-      "mcp-performance-analysis",
-      "server-started",
-      "success",
-      {},
-      undefined, // sessionId
-      jobId,
-    );
-  }
 }
 
 // Start the server if run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new XrayPerformanceAnalysisServer();
   server.run().catch((error) => frameworkLogger.log("mcps/performance-analysis", "run", "error", { error: String(error) }));
 }

package/src/mcps/processor-pipeline.server.ts

@@ -4,15 +4,11 @@
  * Advanced processor pipeline with codex validation, compliance monitoring, and framework enforcement
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
+import * as fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
 import { CodexLoader } from "../enforcement/loaders/codex-loader.js";
 import type { RuleDefinition, RuleValidationContext } from "../enforcement/types.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface PreProcessorArgs {
   content: string;
@@ -87,8 +83,7 @@ interface FrameworkComplianceResult {
   approved: boolean;
 }
 
-class XrayProcessorPipelineServer {
-  private server: Server;
+class XrayProcessorPipelineServer extends XrayKnowledgeSkillBase {
   private codexLoader: CodexLoader;
   private codexRules: RuleDefinition[] = [];
   private codexTerms: string[] = [
@@ -104,17 +99,80 @@ class XrayProcessorPipelineServer {
   ];
 
   constructor() {
+    super("processor-pipeline", "3.1.0");
     this.codexLoader = new CodexLoader();
-    this.server = new Server(
+
+    this.tools = [
+      {
+        name: "execute-pre-processors",
+        description:
+          "Run pre-execution processors on content with codex validation",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            context: { type: "object" },
+            validateCodex: { type: "boolean", default: true },
+            strictMode: { type: "boolean", default: false },
+          },
+          required: ["content"],
+        },
+      },
+      {
+        name: "execute-post-processors",
+        description:
+          "Run post-execution processors on results with compliance monitoring",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            results: { type: "object" },
+            enforceCompliance: { type: "boolean", default: true },
+            auditTrail: { type: "boolean", default: true },
+          },
+          required: ["content"],
+        },
+      },
       {
-        name: "processor-pipeline", version: "1.22.67",
+        name: "codex-validation",
+        description:
+          "Validate content against Universal Development Codex terms",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            terms: {
+              type: "array",
+              items: { type: "string" },
+              default: ["all"],
+            },
+            strict: { type: "boolean", default: false },
+          },
+          required: ["content"],
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "framework-compliance-check",
+        description:
+          "Check framework compliance and generate enforcement actions",
+        inputSchema: {
+          type: "object",
+          properties: {
+            content: { type: "string" },
+            operation: { type: "string" },
+            context: { type: "object" },
+          },
+          required: ["content", "operation"],
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "execute-pre-processors": async (args) => this.handlePreProcessors(args as PreProcessorArgs),
+      "execute-post-processors": async (args) => this.handlePostProcessors(args as PostProcessorArgs),
+      "codex-validation": async (args) => this.handleCodexValidation(args as CodexValidationArgs),
+      "framework-compliance-check": async (args) => this.handleComplianceCheck(args as ComplianceCheckArgs),
+    };
 
     this.setupToolHandlers();
     this.loadCodexRules();
@@ -142,96 +200,6 @@ class XrayProcessorPipelineServer {
     }
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "execute-pre-processors",
-            description:
-              "Run pre-execution processors on content with codex validation",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                context: { type: "object" },
-                validateCodex: { type: "boolean", default: true },
-                strictMode: { type: "boolean", default: false },
-              },
-              required: ["content"],
-            },
-          },
-          {
-            name: "execute-post-processors",
-            description:
-              "Run post-execution processors on results with compliance monitoring",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                results: { type: "object" },
-                enforceCompliance: { type: "boolean", default: true },
-                auditTrail: { type: "boolean", default: true },
-              },
-              required: ["content"],
-            },
-          },
-          {
-            name: "codex-validation",
-            description:
-              "Validate content against Universal Development Codex terms",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                terms: {
-                  type: "array",
-                  items: { type: "string" },
-                  default: ["all"],
-                },
-                strict: { type: "boolean", default: false },
-              },
-              required: ["content"],
-            },
-          },
-          {
-            name: "framework-compliance-check",
-            description:
-              "Check framework compliance and generate enforcement actions",
-            inputSchema: {
-              type: "object",
-              properties: {
-                content: { type: "string" },
-                operation: { type: "string" },
-                context: { type: "object" },
-              },
-              required: ["content", "operation"],
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "execute-pre-processors":
-          return await this.handlePreProcessors(args as unknown as PreProcessorArgs);
-        case "execute-post-processors":
-          return await this.handlePostProcessors(args as unknown as PostProcessorArgs);
-        case "codex-validation":
-          return await this.handleCodexValidation(args as unknown as CodexValidationArgs);
-        case "framework-compliance-check":
-          return await this.handleComplianceCheck(args as unknown as ComplianceCheckArgs);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
-
   private async handlePreProcessors(args: PreProcessorArgs) {
     const content = args.content;
     const context = args.context || {};
@@ -762,15 +730,10 @@ ${complianceResults.actions.map((a: string) => `• 🔧 ${a}`).join("\n") || "N
     return results;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    // Silent start - no console output
-  }
 }
 
 // Start the server if run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new XrayProcessorPipelineServer();
   server.run().catch((error) => frameworkLogger.log("mcps/processor-pipeline", "run", "error", { error: String(error) }));
 }

package/src/mcps/registry.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.22.67",
+  "version": "3.1.0",
   "description": "0xRay Community MCPs Registry - curated API-focused MCP servers",
   "sources": [
     {