0xray 3.1.1 → 3.3.0

package/src/mcps/lint.server.ts

@@ -4,15 +4,10 @@
  * Comprehensive ESLint validation and automated code quality checking
  */
 
-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 { execFileSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface LintArgs {
   files?: string[];
@@ -33,20 +28,63 @@ interface LintResults {
   details: string[];
 }
 
-class XrayLintServer {
-  private server: Server;
-
+class XrayLintServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
+    super("lint", "3.1.0");
+
+    this.tools = [
       {
-        name: "lint", version: "3.1.0",
+        name: "lint",
+        description:
+          "Comprehensive ESLint validation and automated code quality checking",
+        inputSchema: {
+          type: "object",
+          properties: {
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Specific files to lint (optional - lints all if empty)",
+            },
+            fix: {
+              type: "boolean",
+              default: false,
+              description:
+                "Automatically fix linting issues where possible",
+            },
+            strict: {
+              type: "boolean",
+              default: false,
+              description: "Use strict linting rules",
+            },
+          },
+        },
       },
       {
-        capabilities: {
-          tools: {},
+        name: "lint-check",
+        description: "Check code quality without making changes",
+        inputSchema: {
+          type: "object",
+          properties: {
+            files: {
+              type: "array",
+              items: { type: "string" },
+              description: "Files to check",
+            },
+            rules: {
+              type: "array",
+              items: { type: "string" },
+              description: "Specific ESLint rules to check",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "lint": async (args) => this.handleLint(args as LintArgs),
+      "lint-check": async (args) => this.handleLintCheck(args as LintCheckArgs),
+    };
 
     this.setupToolHandlers();
     void frameworkLogger.log(
@@ -57,87 +95,6 @@ class XrayLintServer {
     );
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "lint",
-            description:
-              "Comprehensive ESLint validation and automated code quality checking",
-            inputSchema: {
-              type: "object",
-              properties: {
-                files: {
-                  type: "array",
-                  items: { type: "string" },
-                  description:
-                    "Specific files to lint (optional - lints all if empty)",
-                },
-                fix: {
-                  type: "boolean",
-                  default: false,
-                  description:
-                    "Automatically fix linting issues where possible",
-                },
-                strict: {
-                  type: "boolean",
-                  default: false,
-                  description: "Use strict linting rules",
-                },
-              },
-            },
-          },
-          {
-            name: "lint-check",
-            description: "Check code quality without making changes",
-            inputSchema: {
-              type: "object",
-              properties: {
-                files: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "Files to check",
-                },
-                rules: {
-                  type: "array",
-                  items: { type: "string" },
-                  description: "Specific ESLint rules to check",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      try {
-        switch (name) {
-          case "lint":
-            return await this.handleLint(args as unknown as LintArgs);
-          case "lint-check":
-            return await this.handleLintCheck(args as unknown as LintCheckArgs);
-          default:
-            throw new Error(`Unknown tool: ${name}`);
-        }
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `❌ Tool execution failed: ${error instanceof Error ? error.message : String(error)}`,
-            },
-          ],
-        };
-      }
-    });
-  }
-
   private async handleLint(args: LintArgs) {
     const files = args.files || [];
     const fix = args.fix || false;
@@ -462,16 +419,6 @@ ${checkResults.details.map((d) => `• ${d}`).join("\n")}
 - Fixed: ${results.issues.fixed}`;
   }
 
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    await frameworkLogger.log(
-      "lint.server",
-      "-xray-lint-mcp-server-started-",
-      "info",
-      { message: "0xRay Lint MCP Server started" },
-    );
-  }
 }
 
 // Start the server if run directly

package/src/mcps/model-health-check.server.ts

@@ -4,16 +4,11 @@
  * Advanced model compatibility validation and dynamic health assessment
  */
 
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { modelRouter } from "../core/model-router.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
 import { execSync } from "child_process";
 import fs from "fs";
 import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
 
 interface ModelHealthCheckArgs {
   models?: string[];
@@ -36,73 +31,47 @@ interface ModelHealthReportData {
   summary: { total: number; healthy: number; issues: number };
 }
 
-class XrayModelHealthCheckServer {
-  private server: Server;
-
+class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
   constructor() {
-    this.server = new Server(
-      {
-        name: "model-health-check", version: "3.1.0",
-      },
+    super("model-health-check", "3.1.0");
+
+    this.tools = [
       {
-        capabilities: {
-          tools: {},
+        name: "model-health-check",
+        description:
+          "Advanced model compatibility validation and dynamic health assessment",
+        inputSchema: {
+          type: "object",
+          properties: {
+            models: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Specific models to check (optional - checks all configured if empty)",
+            },
+            compatibility: {
+              type: "boolean",
+              default: true,
+              description: "Include compatibility matrix in results",
+            },
+            performance: {
+              type: "boolean",
+              default: true,
+              description: "Include performance metrics in results",
+            },
+          },
         },
       },
-    );
+    ];
+
+    this.handlers = {
+      "model-health-check": async (args) => this.handleModelHealthCheck((args || {}) as ModelHealthCheckArgs),
+    };
 
     this.setupToolHandlers();
     frameworkLogger.log("mcps/model-health-check", "initialize", "info");
   }
 
-  private setupToolHandlers() {
-    // List available tools
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "model-health-check",
-            description:
-              "Advanced model compatibility validation and dynamic health assessment",
-            inputSchema: {
-              type: "object",
-              properties: {
-                models: {
-                  type: "array",
-                  items: { type: "string" },
-                  description:
-                    "Specific models to check (optional - checks all configured if empty)",
-                },
-                compatibility: {
-                  type: "boolean",
-                  default: true,
-                  description: "Include compatibility matrix in results",
-                },
-                performance: {
-                  type: "boolean",
-                  default: true,
-                  description: "Include performance metrics in results",
-                },
-              },
-            },
-          },
-        ],
-      };
-    });
-
-    // Handle tool calls
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-
-      switch (name) {
-        case "model-health-check":
-          return await this.handleModelHealthCheck((args || {}) as unknown as ModelHealthCheckArgs);
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-  }
-
   private async handleModelHealthCheck(args: ModelHealthCheckArgs) {
     const models = args.models || [modelRouter.getValidatedModel()];
     const includeCompatibility = args.compatibility !== false;
@@ -276,17 +245,12 @@ class XrayModelHealthCheckServer {
     return report;
   }
 
-  public async start() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    frameworkLogger.log("mcps/model-health-check", "start", "info");
-  }
 }
 
 // Start the server if this file is run directly
 if (import.meta.url === `file://${fs.realpathSync(process.argv[1]!)}`) {
   const server = new XrayModelHealthCheckServer();
-  server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
+  server.run().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
 }
 
 export default XrayModelHealthCheckServer;

package/src/mcps/orchestrator/aside-context.ts

@@ -0,0 +1,245 @@
+/**
+ * AsideContext — bounded subcontext for depth, continuity, and layered exploration
+ *
+ * Enables the orchestrator to spawn sub-investigations that inherit session context,
+ * accumulate structured observations from v3 subsystems (governance, orchestration,
+ * complexity analysis), and feed results back into the governance loop.
+ */
+
+import { frameworkLogger } from "../../core/framework-logger.js";
+import type {
+  AsideContextOptions,
+  AsideObservation,
+  AsideResult,
+  ActiveAside,
+} from "./types.js";
+import type { InferenceCycleResult } from "../../inference/inference-cycle.js";
+import type { OrchestrationResult, ComplexityAnalysis } from "./types.js";
+
+let asideCounter = 0;
+const activeAsides = new Map<string, ActiveAside>();
+
+export function getActiveAsideCount(): number {
+  return activeAsides.size;
+}
+
+export function getActiveAsideIds(): string[] {
+  return Array.from(activeAsides.keys());
+}
+
+export function getAsideState(asideId: string): ActiveAside | undefined {
+  return activeAsides.get(asideId);
+}
+
+export function addObservations(
+  asideId: string,
+  observations: AsideObservation[],
+): boolean {
+  const aside = activeAsides.get(asideId);
+  if (!aside) return false;
+  aside.observations.push(...observations);
+  return true;
+}
+
+export function extractGovernanceObservations(
+  result: InferenceCycleResult,
+): AsideObservation[] {
+  const obs: AsideObservation[] = [];
+  obs.push({
+    key: "governanceCycleId",
+    value: result.cycleId,
+    source: "inference/inference-cycle.ts",
+  });
+  obs.push({
+    key: "governanceVoteCount",
+    value: String(result.votes.length),
+    source: "inference/inference-cycle.ts",
+  });
+  const approved = result.votes.filter((v) => v.decision === "approve").length;
+  const rejected = result.votes.filter((v) => v.decision === "reject").length;
+  obs.push({
+    key: "governanceApprovedCount",
+    value: String(approved),
+    source: "inference/inference-cycle.ts",
+  });
+  obs.push({
+    key: "governanceRejectedCount",
+    value: String(rejected),
+    source: "inference/inference-cycle.ts",
+  });
+  if (result.corpusSummary) {
+    obs.push({
+      key: "corpusSessionCount",
+      value: String(result.corpusSummary.sessions),
+      source: "inference/inference-cycle.ts",
+    });
+    obs.push({
+      key: "corpusPatternCount",
+      value: String(result.corpusSummary.recurringPatterns),
+      source: "inference/inference-cycle.ts",
+    });
+  }
+  return obs;
+}
+
+export function extractOrchestrationObservations(
+  result: OrchestrationResult,
+): AsideObservation[] {
+  const obs: AsideObservation[] = [];
+  obs.push({
+    key: "orchestrationSuccess",
+    value: String(result.success),
+    source: "mcps/orchestrator/types.ts",
+  });
+  obs.push({
+    key: "tasksCompleted",
+    value: String(result.completedTasks),
+    source: "mcps/orchestrator/types.ts",
+  });
+  obs.push({
+    key: "tasksFailed",
+    value: String(result.failedTasks),
+    source: "mcps/orchestrator/types.ts",
+  });
+  obs.push({
+    key: "orchestrationDuration",
+    value: `${result.duration}ms`,
+    source: "mcps/orchestrator/types.ts",
+  });
+  for (const b of result.bottlenecks) {
+    obs.push({
+      key: "bottleneck",
+      value: b.substring(0, 200),
+      source: "mcps/orchestrator/types.ts",
+    });
+  }
+  for (const r of result.recommendations) {
+    obs.push({
+      key: "recommendation",
+      value: r.substring(0, 200),
+      source: "mcps/orchestrator/types.ts",
+    });
+  }
+  return obs;
+}
+
+export function extractComplexityObservations(
+  analysis: ComplexityAnalysis,
+): AsideObservation[] {
+  const obs: AsideObservation[] = [];
+  obs.push({
+    key: "complexityScore",
+    value: String(analysis.overallComplexity),
+    source: "mcps/orchestrator/execution/execution-planner.ts",
+  });
+  obs.push({
+    key: "recommendedStrategy",
+    value: analysis.recommendedStrategy,
+    source: "mcps/orchestrator/execution/execution-planner.ts",
+  });
+  obs.push({
+    key: "parallelPotential",
+    value: String(analysis.parallelPotential),
+    source: "mcps/orchestrator/execution/execution-planner.ts",
+  });
+  obs.push({
+    key: "estimatedDuration",
+    value: `${analysis.estimatedDuration}ms`,
+    source: "mcps/orchestrator/execution/execution-planner.ts",
+  });
+  for (const tc of analysis.taskComplexity) {
+    obs.push({
+      key: `taskComplexity`,
+      value: `${tc.complexity} (${tc.category})`,
+      source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+  }
+  return obs;
+}
+
+export async function spawnAside(
+  options: AsideContextOptions,
+): Promise<AsideResult> {
+  const asideId = options.parentAsideId
+    ? `${options.parentAsideId}.aside-${++asideCounter}`
+    : `aside-${++asideCounter}-${Date.now()}`;
+  const startTime = Date.now();
+
+  const aside: ActiveAside = {
+    asideId,
+    description: options.description,
+    startedAt: startTime,
+    observations: [],
+    ...(options.inheritedContext !== undefined ? { inheritedContext: options.inheritedContext } : {}),
+    ...(options.parentAsideId !== undefined ? { parentAsideId: options.parentAsideId } : {}),
+    ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
+    ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+  };
+
+  activeAsides.set(asideId, aside);
+
+  frameworkLogger.log("aside-context", "aside-spawn", "info", {
+    asideId,
+    description: options.description,
+    sessionId: options.sessionId,
+    parentAsideId: options.parentAsideId,
+    activeAsideCount: activeAsides.size,
+  });
+
+  if (options.priorVerdictContext) {
+    const decision = options.priorVerdictContext["decision"];
+    if (decision) {
+      aside.observations.push({
+        key: "governanceDecision",
+        value: String(decision),
+        source: "priorVerdictContext",
+      });
+    }
+  }
+
+  const duration = Date.now() - startTime;
+
+  const result: AsideResult = {
+    asideId,
+    description: options.description,
+    success: true,
+    duration,
+    observations: aside.observations,
+    ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+  };
+
+  frameworkLogger.log("aside-context", "aside-complete", "info", {
+    asideId,
+    duration,
+    observationCount: aside.observations.length,
+    activeAsideCount: activeAsides.size,
+  });
+
+  return result;
+}
+
+export function closeAside(asideId: string): boolean {
+  const aside = activeAsides.get(asideId);
+  if (!aside) return false;
+  activeAsides.delete(asideId);
+  frameworkLogger.log("aside-context", "aside-closed", "info", {
+    asideId,
+    duration: Date.now() - aside.startedAt,
+    remainingActive: activeAsides.size,
+  });
+  return true;
+}
+
+export function closeAllAsides(): number {
+  const count = activeAsides.size;
+  activeAsides.clear();
+  frameworkLogger.log("aside-context", "aside-close-all", "info", {
+    closedCount: count,
+  });
+  return count;
+}
+
+export function resetAsideContext(): void {
+  activeAsides.clear();
+  asideCounter = 0;
+}

package/src/mcps/orchestrator/config/agent-capabilities.ts

@@ -1,11 +1,18 @@
 /**
  * Agent Capabilities Configuration
- * 
- * Centralized agent capability definitions for orchestration decisions
+ *
+ * Centralized agent capability definitions for orchestration decisions.
+ * Enriched at runtime by the active MemoryRoutingProvider (Repertoire, etc.).
  */
 
 import type { AgentCapability } from '../types.js';
 import { AGENT_REGISTRY } from "../../../agents/registry.js";
+import { initializeMemoryRouting } from '../../../memory-routing/index.js';
+import {
+  getProvider,
+  toMemoryCapabilityMap,
+  fromMemoryCapabilityMap,
+} from './memory-routing-bridge.js';
 
 const DEFAULT_AGENT_CAPABILITIES: Record<string, AgentCapability> = Object.fromEntries(
   Object.entries(AGENT_REGISTRY).map(([name, entry]) => [
@@ -18,18 +25,31 @@ const DEFAULT_AGENT_CAPABILITIES: Record<string, AgentCapability> = Object.fromE
   ]),
 );
 
+initializeMemoryRouting();
+
 /**
  * Agent Capabilities Manager
  * Manages agent capabilities for orchestration decisions
  */
 export class AgentCapabilitiesManager {
   private capabilities: Map<string, AgentCapability> = new Map();
+  private enriched = false;
 
   constructor() {
-    // Initialize with default capabilities
     Object.entries(DEFAULT_AGENT_CAPABILITIES).forEach(([agent, config]) => {
       this.capabilities.set(agent, config);
     });
+    this.applyMemoryRoutingEnrichment();
+  }
+
+  private applyMemoryRoutingEnrichment(): void {
+    const provider = getProvider();
+    if (provider.id === 'null') return;
+
+    const memoryCaps = toMemoryCapabilityMap(this.capabilities);
+    const enriched = provider.enhanceAgentCapabilities(memoryCaps);
+    this.capabilities = fromMemoryCapabilityMap(enriched);
+    this.enriched = true;
   }
 
   /**
@@ -43,6 +63,7 @@ export class AgentCapabilitiesManager {
    * Get all registered agent capabilities
    */
   getAllCapabilities(): Map<string, AgentCapability> {
+    if (!this.enriched) this.applyMemoryRoutingEnrichment();
     return new Map(this.capabilities);
   }
 
@@ -54,24 +75,35 @@ export class AgentCapabilitiesManager {
   }
 
   /**
-   * Select the best agent for a task based on complexity and capabilities
+   * Select the best agent for a task based on complexity, capabilities, and memory routing.
    */
-  selectAgentForTask(requiredCapabilities: string[], complexity: number): string | null {
+  selectAgentForTask(
+    requiredCapabilities: string[],
+    complexity: number,
+    operationDescription = '',
+  ): string | null {
+    const provider = getProvider();
+
+    if (provider.id !== 'null' && operationDescription) {
+      const memoryCaps = toMemoryCapabilityMap(this.getAllCapabilities());
+      return provider.selectAgent(
+        memoryCaps,
+        requiredCapabilities,
+        complexity,
+        operationDescription,
+      );
+    }
+
     let bestAgent: string | null = null;
     let bestScore = -1;
 
     for (const [agent, caps] of this.capabilities) {
-      // Check if agent can handle the complexity
-      if (complexity > caps.complexityThreshold) {
-        continue;
-      }
+      if (complexity > caps.complexityThreshold) continue;
 
-      // Calculate capability match score
-      const matchCount = requiredCapabilities.filter(cap =>
-        caps.capabilities.includes(cap)
+      const matchCount = requiredCapabilities.filter((cap) =>
+        caps.capabilities.includes(cap),
       ).length;
 
-      // Prefer agents with more concurrent tasks available
       const score = matchCount * 10 + caps.concurrentTasks;
 
       if (score > bestScore) {
@@ -97,7 +129,6 @@ export class AgentCapabilitiesManager {
   }
 }
 
-// Singleton instance
 let capabilitiesManagerInstance: AgentCapabilitiesManager | null = null;
 
 export function getAgentCapabilitiesManager(): AgentCapabilitiesManager {
@@ -106,3 +137,7 @@ export function getAgentCapabilitiesManager(): AgentCapabilitiesManager {
   }
   return capabilitiesManagerInstance;
 }
+
+export function resetAgentCapabilitiesManager(): void {
+  capabilitiesManagerInstance = null;
+}