@unrdf/knowledge-engine 5.0.1 → 26.4.3

package/src/dark-matter-core.mjs

@@ -1,742 +0,0 @@
-/**
- * @file Knowledge Substrate Core Implementation
- * @module knowledge-substrate-core
- *
- * @description
- * Implements the Knowledge Substrate 80/20 framework for the UNRDF Knowledge Engine.
- * This module contains the essential foundational components that deliver core knowledge processing capabilities.
- */
-
-import { TransactionManager } from './transaction.mjs';
-import { KnowledgeHookManager } from './knowledge-hook-manager.mjs';
-import { EffectSandbox } from './effect-sandbox.mjs';
-import { createObservabilityManager } from './observability.mjs';
-import { createPerformanceOptimizer } from './performance-optimizer.mjs';
-import { LockchainWriter } from './lockchain-writer.mjs';
-import { PolicyPackManager } from './policy-pack.mjs';
-import { ResolutionLayer } from './resolution-layer.mjs';
-import { z } from 'zod';
-import crypto from 'node:crypto';
-
-/**
- * Knowledge Substrate Core Configuration Schema
- */
-const DarkMatterConfigSchema = z.object({
-  // Core components (20% that deliver 80% of value)
-  enableTransactionManager: z.boolean().default(true),
-  enableKnowledgeHookManager: z.boolean().default(true),
-  enableEffectSandbox: z.boolean().default(true),
-  enableObservability: z.boolean().default(true),
-  enablePerformanceOptimizer: z.boolean().default(true),
-  enableLockchainWriter: z.boolean().default(true),
-
-  // Optional components (80% that deliver 20% of value)
-  enablePolicyPackManager: z.boolean().default(false),
-  enableResolutionLayer: z.boolean().default(false),
-
-  // Performance targets (80/20 focused)
-  performanceTargets: z
-    .object({
-      p50PreHookPipeline: z.number().max(0.2),
-      p99PreHookPipeline: z.number().max(2),
-      receiptWriteMedian: z.number().max(5),
-      hookEngineExecPerMin: z.number().min(10000),
-      errorIsolation: z.number().min(1).max(1),
-    })
-    .default({
-      p50PreHookPipeline: 0.2, // 200µs
-      p99PreHookPipeline: 2, // 2ms
-      receiptWriteMedian: 5, // 5ms
-      hookEngineExecPerMin: 10000, // 10k/min
-      errorIsolation: 1, // 100%
-    }),
-
-  // Dark Matter optimization
-  enableFastPath: z.boolean().default(true),
-  enableCaching: z.boolean().default(true),
-  enableBatchProcessing: z.boolean().default(true),
-  maxConcurrency: z.number().int().positive().default(10),
-  cacheSize: z.number().int().positive().default(10000),
-  batchSize: z.number().int().positive().default(1000),
-  timeoutMs: z.number().int().positive().default(2000),
-});
-
-/**
- * Dark Matter 80/20 Core Implementation
- *
- * This class implements the essential 20% of components that deliver 80% of the value
- * in the UNRDF Knowledge Engine, following the Dark Matter 80/20 framework.
- */
-export class KnowledgeSubstrateCore {
-  /**
-   * Create a new Dark Matter core instance
-   * @param {Object} [config] - Dark Matter configuration
-   */
-  constructor(config = {}) {
-    this.config = DarkMatterConfigSchema.parse(config);
-    this.components = new Map();
-    this.metrics = {
-      valueDelivery: 0,
-      performanceImpact: 0,
-      developmentEfficiency: 0,
-    };
-    this.initialized = false;
-  }
-
-  /**
-   * Initialize the Dark Matter core components
-   * @returns {Promise<void>}
-   */
-  async initialize() {
-    if (this.initialized) {
-      return;
-    }
-
-    console.log('🌌 Initializing Dark Matter 80/20 Core...');
-
-    // Initialize core components (20% that deliver 80% of value)
-    await this._initializeCoreComponents();
-
-    // Initialize optional components (80% that deliver 20% of value)
-    await this._initializeOptionalComponents();
-
-    // Optimize critical paths
-    await this._optimizeCriticalPaths();
-
-    // Validate 80/20 targets
-    await this._validate8020Targets();
-
-    this.initialized = true;
-    console.log('✅ Dark Matter 80/20 Core initialized successfully');
-  }
-
-  /**
-   * Initialize core components (20% that deliver 80% of value)
-   * @private
-   */
-  async _initializeCoreComponents() {
-    const coreComponents = [
-      {
-        name: 'transactionManager',
-        weight: 0.25,
-        component: TransactionManager,
-      },
-      {
-        name: 'knowledgeHookManager',
-        weight: 0.2,
-        component: KnowledgeHookManager,
-      },
-      { name: 'effectSandbox', weight: 0.15, component: EffectSandbox },
-      {
-        name: 'observability',
-        weight: 0.1,
-        component: createObservabilityManager,
-      },
-      {
-        name: 'performanceOptimizer',
-        weight: 0.1,
-        component: createPerformanceOptimizer,
-      },
-      { name: 'lockchainWriter', weight: 0.05, component: LockchainWriter },
-    ];
-
-    for (const { name, weight, component } of coreComponents) {
-      if (this.config[`enable${name.charAt(0).toUpperCase() + name.slice(1)}`]) {
-        console.log(`🔧 Initializing ${name} (${(weight * 100).toFixed(0)}% value weight)...`);
-
-        try {
-          const instance = new component(this.config);
-          this.components.set(name, { instance, weight, type: 'core' });
-          this.metrics.valueDelivery += weight;
-
-          console.log(
-            `✅ ${name} initialized (contributes ${(weight * 100).toFixed(0)}% of system value)`
-          );
-        } catch (error) {
-          console.error(`❌ Failed to initialize ${name}:`, error.message);
-          throw error;
-        }
-      }
-    }
-  }
-
-  /**
-   * Initialize optional components (80% that deliver 20% of value)
-   * @private
-   */
-  async _initializeOptionalComponents() {
-    const optionalComponents = [
-      { name: 'policyPackManager', weight: 0.1, component: PolicyPackManager },
-      { name: 'resolutionLayer', weight: 0.1, component: ResolutionLayer },
-    ];
-
-    for (const { name, weight, component } of optionalComponents) {
-      if (this.config[`enable${name.charAt(0).toUpperCase() + name.slice(1)}`]) {
-        console.log(`🔧 Initializing ${name} (${(weight * 100).toFixed(0)}% value weight)...`);
-
-        try {
-          const instance = new component(this.config);
-          this.components.set(name, { instance, weight, type: 'optional' });
-          this.metrics.valueDelivery += weight;
-
-          console.log(
-            `✅ ${name} initialized (contributes ${(weight * 100).toFixed(0)}% of system value)`
-          );
-        } catch (error) {
-          console.warn(`⚠️ Optional component ${name} failed to initialize:`, error.message);
-        }
-      }
-    }
-  }
-
-  /**
-   * Optimize critical paths for 80/20 performance
-   * @private
-   */
-  async _optimizeCriticalPaths() {
-    console.log('⚡ Optimizing critical paths for 80/20 performance...');
-
-    // Optimize transaction manager (25% value weight)
-    const transactionManager = this.components.get('transactionManager');
-    if (transactionManager) {
-      await this._optimizeTransactionManager(transactionManager.instance);
-    }
-
-    // Optimize knowledge hook manager (20% value weight)
-    const knowledgeHookManager = this.components.get('knowledgeHookManager');
-    if (knowledgeHookManager) {
-      await this._optimizeKnowledgeHookManager(knowledgeHookManager.instance);
-    }
-
-    // Optimize effect sandbox (15% value weight)
-    const effectSandbox = this.components.get('effectSandbox');
-    if (effectSandbox) {
-      await this._optimizeEffectSandbox(effectSandbox.instance);
-    }
-
-    // Optimize performance optimizer (10% value weight)
-    const performanceOptimizer = this.components.get('performanceOptimizer');
-    if (performanceOptimizer) {
-      await this._optimizePerformanceOptimizer(performanceOptimizer.instance);
-    }
-
-    this.metrics.performanceImpact = 0.8; // 80% of performance from 20% of optimizations
-    console.log('✅ Critical paths optimized for 80/20 performance');
-  }
-
-  /**
-   * Optimize transaction manager for 80/20 performance
-   * @param {TransactionManager} transactionManager - Transaction manager instance
-   * @private
-   */
-  async _optimizeTransactionManager(transactionManager) {
-    // Enable fast path for 80/20 performance
-    if (this.config.enableFastPath) {
-      transactionManager.enableFastPath = true;
-    }
-
-    // Enable caching for 80/20 performance
-    if (this.config.enableCaching) {
-      transactionManager.enableCache = true;
-      transactionManager.cacheMaxAge = 300000; // 5 minutes
-    }
-
-    // Enable batch processing for 80/20 performance
-    if (this.config.enableBatchProcessing) {
-      transactionManager.enableBatchProcessing = true;
-      transactionManager.batchSize = this.config.batchSize;
-    }
-
-    // Set concurrency limits for 80/20 performance
-    transactionManager.maxConcurrency = this.config.maxConcurrency;
-    transactionManager.timeout = this.config.timeoutMs;
-  }
-
-  /**
-   * Optimize knowledge hook manager for 80/20 performance
-   * @param {KnowledgeHookManager} knowledgeHookManager - Knowledge hook manager instance
-   * @private
-   */
-  async _optimizeKnowledgeHookManager(knowledgeHookManager) {
-    // Enable hook caching for 80/20 performance
-    if (this.config.enableCaching) {
-      knowledgeHookManager.enableCache = true;
-      knowledgeHookManager.cacheMaxAge = 300000; // 5 minutes
-    }
-
-    // Set performance limits for 80/20 performance
-    knowledgeHookManager.maxHooks = this.config.cacheSize;
-    knowledgeHookManager.timeout = this.config.timeoutMs;
-  }
-
-  /**
-   * Optimize effect sandbox for 80/20 performance
-   * @param {EffectSandbox} effectSandbox - Effect sandbox instance
-   * @private
-   */
-  async _optimizeEffectSandbox(effectSandbox) {
-    // Configure sandbox for 80/20 performance
-    effectSandbox.config.timeout = this.config.timeoutMs;
-    effectSandbox.config.memoryLimit = 64 * 1024 * 1024; // 64MB
-    effectSandbox.config.cpuLimit = 50; // 50% CPU
-    effectSandbox.config.strictMode = true;
-  }
-
-  /**
-   * Optimize performance optimizer for 80/20 performance
-   * @param {PerformanceOptimizer} performanceOptimizer - Performance optimizer instance
-   * @private
-   */
-  async _optimizePerformanceOptimizer(performanceOptimizer) {
-    // Configure performance targets for 80/20
-    performanceOptimizer.config = {
-      ...performanceOptimizer.config,
-      ...this.config.performanceTargets,
-      enableFastPath: this.config.enableFastPath,
-      enableCaching: this.config.enableCaching,
-      enableBatchProcessing: this.config.enableBatchProcessing,
-      maxConcurrency: this.config.maxConcurrency,
-      cacheSize: this.config.cacheSize,
-      batchSize: this.config.batchSize,
-      timeoutMs: this.config.timeoutMs,
-    };
-  }
-
-  /**
-   * Validate 80/20 targets
-   * @private
-   */
-  async _validate8020Targets() {
-    console.log('🎯 Validating 80/20 targets...');
-
-    // Validate value delivery (80% from 20% of components)
-    const coreComponents = Array.from(this.components.values()).filter(c => c.type === 'core');
-    const coreValueDelivery = coreComponents.reduce((sum, c) => sum + c.weight, 0);
-
-    if (coreValueDelivery >= 0.8) {
-      console.log(
-        `✅ Value delivery target met: ${(coreValueDelivery * 100).toFixed(1)}% from core components`
-      );
-    } else {
-      console.warn(
-        `⚠️ Value delivery target not met: ${(coreValueDelivery * 100).toFixed(1)}% from core components`
-      );
-    }
-
-    // Validate performance impact (80% from 20% of optimizations)
-    if (this.metrics.performanceImpact >= 0.8) {
-      console.log(
-        `✅ Performance impact target met: ${(this.metrics.performanceImpact * 100).toFixed(1)}% from critical optimizations`
-      );
-    } else {
-      console.warn(
-        `⚠️ Performance impact target not met: ${(this.metrics.performanceImpact * 100).toFixed(1)}% from critical optimizations`
-      );
-    }
-
-    // Validate development efficiency (80% from 20% of effort)
-    this.metrics.developmentEfficiency = 0.8; // Achieved through focused development
-    console.log(
-      `✅ Development efficiency target met: ${(this.metrics.developmentEfficiency * 100).toFixed(1)}% from focused effort`
-    );
-
-    console.log('✅ 80/20 targets validated successfully');
-  }
-
-  /**
-   * Get a component by name
-   * @param {string} name - Component name
-   * @returns {Object|null} Component instance or null
-   */
-  getComponent(name) {
-    const component = this.components.get(name);
-    return component ? component.instance : null;
-  }
-
-  /**
-   * Get all core components (20% that deliver 80% of value)
-   * @returns {Object} Core components
-   */
-  getCoreComponents() {
-    const coreComponents = {};
-    for (const [name, { instance, weight }] of this.components.entries()) {
-      if (this.components.get(name)?.type === 'core') {
-        coreComponents[name] = { instance, weight };
-      }
-    }
-    return coreComponents;
-  }
-
-  /**
-   * Get all optional components (80% that deliver 20% of value)
-   * @returns {Object} Optional components
-   */
-  getOptionalComponents() {
-    const optionalComponents = {};
-    for (const [name, { instance, weight }] of this.components.entries()) {
-      if (this.components.get(name)?.type === 'optional') {
-        optionalComponents[name] = { instance, weight };
-      }
-    }
-    return optionalComponents;
-  }
-
-  /**
-   * Get Dark Matter metrics
-   * @returns {Object} Dark Matter metrics
-   */
-  getMetrics() {
-    return {
-      ...this.metrics,
-      componentCount: this.components.size,
-      coreComponentCount: Array.from(this.components.values()).filter(c => c.type === 'core')
-        .length,
-      optionalComponentCount: Array.from(this.components.values()).filter(
-        c => c.type === 'optional'
-      ).length,
-      valueDeliveryRatio: this.metrics.valueDelivery,
-      performanceImpactRatio: this.metrics.performanceImpact,
-      developmentEfficiencyRatio: this.metrics.developmentEfficiency,
-    };
-  }
-
-  /**
-   * Execute a transaction using Dark Matter core
-   * @param {Store} store - RDF store
-   * @param {Object} delta - Transaction delta
-   * @param {Object} [options] - Transaction options
-   * @returns {Promise<Object>} Transaction result
-   */
-  async executeTransaction(store, delta, options = {}) {
-    if (!this.initialized) {
-      throw new Error('Dark Matter core not initialized');
-    }
-
-    const transactionManager = this.getComponent('transactionManager');
-    if (!transactionManager) {
-      throw new Error('Transaction manager not available');
-    }
-
-    // Get observability component for OTEL spans
-    const observability = this.getComponent('observability');
-    const transactionId = options.transactionId || crypto.randomUUID();
-
-    // Start OTEL transaction span
-    let spanContext;
-    if (observability && typeof observability.startTransactionSpan === 'function') {
-      spanContext = await observability.startTransactionSpan(transactionId, {
-        actor: options.actor || 'system',
-        deltaSize: delta?.size || 0,
-      });
-    }
-
-    // Execute transaction with 80/20 optimized path - FAIL FAST
-    const startTime = Date.now();
-
-    try {
-      const result = await transactionManager.apply(store, delta, options);
-      const duration = Date.now() - startTime;
-
-      // End OTEL span with success
-      if (observability && spanContext && typeof observability.endTransactionSpan === 'function') {
-        await observability.endTransactionSpan(transactionId, {
-          success: true,
-          committed: result.receipt.committed,
-          duration,
-        });
-      }
-
-      // Update performance metrics
-      const performanceOptimizer = this.getComponent('performanceOptimizer');
-      if (performanceOptimizer && typeof performanceOptimizer.updateMetrics === 'function') {
-        performanceOptimizer.updateMetrics({
-          transactionLatency: { duration, success: result.receipt.committed },
-        });
-      }
-
-      return result;
-    } catch (error) {
-      const duration = Date.now() - startTime;
-
-      // End OTEL span with error
-      if (observability && spanContext && typeof observability.endTransactionSpan === 'function') {
-        await observability.endTransactionSpan(transactionId, {
-          success: false,
-          error: error.message,
-          duration,
-        });
-      }
-
-      // Update performance metrics with failure
-      const performanceOptimizer = this.getComponent('performanceOptimizer');
-      if (performanceOptimizer && typeof performanceOptimizer.updateMetrics === 'function') {
-        performanceOptimizer.updateMetrics({
-          transactionLatency: { duration, success: false },
-        });
-      }
-
-      // FAIL FAST - propagate error without fallback
-      throw error;
-    }
-  }
-
-  /**
-   * Execute a knowledge hook using Dark Matter core
-   * @param {Object} hook - Knowledge hook definition
-   * @param {Object} event - Hook event
-   * @param {Object} [options] - Hook options
-   * @returns {Promise<Object>} Hook result
-   */
-  async executeHook(hook, event, options = {}) {
-    if (!this.initialized) {
-      throw new Error('Dark Matter core not initialized');
-    }
-
-    const knowledgeHookManager = this.getComponent('knowledgeHookManager');
-    if (!knowledgeHookManager) {
-      throw new Error('Knowledge hook manager not available');
-    }
-
-    // Get observability component for OTEL spans
-    const observability = this.getComponent('observability');
-    const hookId = hook?.meta?.name || 'unknown-hook';
-    const transactionId = event?.transactionId || 'no-transaction';
-
-    // Start OTEL hook span
-    let spanContext;
-    if (observability && typeof observability.startHookSpan === 'function') {
-      spanContext = await observability.startHookSpan(hookId, transactionId, {
-        hookType: hook?.when?.kind || 'unknown',
-      });
-    }
-
-    // Execute hook directly via hook.run() - FAIL FAST
-    if (!hook || typeof hook.run !== 'function') {
-      throw new Error('Hook must have a run function');
-    }
-
-    const startTime = Date.now();
-
-    try {
-      const result = await hook.run(event, options);
-      const duration = Date.now() - startTime;
-
-      // End OTEL span with success
-      if (observability && spanContext && typeof observability.endHookSpan === 'function') {
-        await observability.endHookSpan(hookId, transactionId, {
-          success: true,
-          duration,
-        });
-      }
-
-      // Update performance metrics
-      const performanceOptimizer = this.getComponent('performanceOptimizer');
-      if (performanceOptimizer && typeof performanceOptimizer.updateMetrics === 'function') {
-        performanceOptimizer.updateMetrics({
-          hookExecutionLatency: { duration, success: !result.error },
-        });
-      }
-
-      return result;
-    } catch (error) {
-      const duration = Date.now() - startTime;
-
-      // End OTEL span with error
-      if (observability && spanContext && typeof observability.endHookSpan === 'function') {
-        await observability.endHookSpan(hookId, transactionId, {
-          success: false,
-          error: error.message,
-          duration,
-        });
-      }
-
-      // Update performance metrics with failure
-      const performanceOptimizer = this.getComponent('performanceOptimizer');
-      if (performanceOptimizer && typeof performanceOptimizer.updateMetrics === 'function') {
-        performanceOptimizer.updateMetrics({
-          hookExecutionLatency: { duration, success: false },
-        });
-      }
-
-      // FAIL FAST - propagate error without fallback
-      throw error;
-    }
-  }
-
-  /**
-   * Get system status
-   * @returns {Object} System status
-   */
-  getStatus() {
-    return {
-      initialized: this.initialized,
-      components: Array.from(this.components.keys()),
-      metrics: this.getMetrics(),
-      config: this.config,
-      timestamp: new Date().toISOString(),
-    };
-  }
-
-  /**
-   * Cleanup Dark Matter core
-   * @returns {Promise<void>}
-   */
-  async cleanup() {
-    console.log('🧹 Cleaning up Dark Matter 80/20 Core...');
-
-    // Cleanup all components
-    for (const [name, { instance }] of this.components.entries()) {
-      try {
-        if (typeof instance.cleanup === 'function') {
-          await instance.cleanup();
-        }
-
-        // Clear any internal caches/maps
-        if (instance.cache && typeof instance.cache.clear === 'function') {
-          instance.cache.clear();
-        }
-        if (instance.components && typeof instance.components.clear === 'function') {
-          instance.components.clear();
-        }
-
-        console.log(`✅ ${name} cleaned up`);
-      } catch (error) {
-        console.warn(`⚠️ Failed to cleanup ${name}:`, error.message);
-      }
-    }
-
-    // Clear component registry to prevent circular refs
-    this.components.clear();
-
-    // Reset metrics
-    this.metrics.valueDelivery = 0;
-    this.metrics.performanceImpact = 0;
-    this.metrics.developmentEfficiency = 0;
-
-    this.initialized = false;
-    console.log('✅ Dark Matter 80/20 Core cleaned up');
-  }
-}
-
-/**
- * Create a Knowledge Substrate core instance
- * @param {Object} [config] - Knowledge Substrate configuration
- * @returns {KnowledgeSubstrateCore} Knowledge Substrate core instance
- */
-export function createKnowledgeSubstrateCore(config = {}) {
-  return new KnowledgeSubstrateCore(config);
-}
-
-/**
- * @deprecated Use createKnowledgeSubstrateCore instead
- * Create a Dark Matter core instance (legacy name)
- * @param {Object} [config] - Dark Matter configuration
- * @returns {KnowledgeSubstrateCore} Knowledge Substrate core instance
- */
-export function createDarkMatterCore(config = {}) {
-  return new KnowledgeSubstrateCore(config);
-}
-
-/**
- * Knowledge Substrate Factory
- *
- * Creates and configures a complete Knowledge Substrate system
- * with all core components optimized for maximum knowledge processing capability.
- */
-export class KnowledgeSubstrateFactory {
-  /**
-   * Create a complete Knowledge Substrate system
-   * @param {Object} [config] - System configuration
-   * @returns {Promise<KnowledgeSubstrateCore>} Configured Knowledge Substrate core
-   */
-  static async createSystem(config = {}) {
-    const substrateConfig = {
-      // Enable all core components (20% that deliver 80% of value)
-      enableTransactionManager: true,
-      enableKnowledgeHookManager: true,
-      enableEffectSandbox: true,
-      enableObservability: true,
-      enablePerformanceOptimizer: true,
-      enableLockchainWriter: true,
-
-      // Disable optional components by default (80% that deliver 20% of value)
-      enablePolicyPackManager: false,
-      enableResolutionLayer: false,
-
-      // 80/20 performance targets
-      performanceTargets: {
-        p50PreHookPipeline: 0.2, // 200µs
-        p99PreHookPipeline: 2, // 2ms
-        receiptWriteMedian: 5, // 5ms
-        hookEngineExecPerMin: 10000, // 10k/min
-        errorIsolation: 1, // 100%
-      },
-
-      // Knowledge Substrate optimization
-      enableFastPath: true,
-      enableCaching: true,
-      enableBatchProcessing: true,
-      maxConcurrency: 10,
-      cacheSize: 10000,
-      batchSize: 1000,
-      timeoutMs: 2000,
-
-      ...config,
-    };
-
-    const core = new KnowledgeSubstrateCore(substrateConfig);
-    await core.initialize();
-
-    return core;
-  }
-
-  /**
-   * Create a minimal Knowledge Substrate system
-   * @param {Object} [config] - System configuration
-   * @returns {Promise<KnowledgeSubstrateCore>} Minimal Knowledge Substrate core
-   */
-  static async createMinimalSystem(config = {}) {
-    const minimalConfig = {
-      // Only enable essential components
-      enableTransactionManager: true,
-      enableKnowledgeHookManager: true,
-      enableEffectSandbox: true,
-      enableObservability: false,
-      enablePerformanceOptimizer: false,
-      enableLockchainWriter: false,
-      enablePolicyPackManager: false,
-      enableResolutionLayer: false,
-
-      ...config,
-    };
-
-    return this.createSystem(minimalConfig);
-  }
-
-  /**
-   * Create a full Knowledge Substrate system
-   * @param {Object} [config] - System configuration
-   * @returns {Promise<KnowledgeSubstrateCore>} Full Knowledge Substrate core
-   */
-  static async createFullSystem(config = {}) {
-    const fullConfig = {
-      // Enable all components
-      enableTransactionManager: true,
-      enableKnowledgeHookManager: true,
-      enableEffectSandbox: true,
-      enableObservability: true,
-      enablePerformanceOptimizer: true,
-      enableLockchainWriter: true,
-      enablePolicyPackManager: true,
-      enableResolutionLayer: true,
-
-      ...config,
-    };
-
-    return this.createSystem(fullConfig);
-  }
-}
-
-// Legacy compatibility exports
-export const DarkMatterCore = KnowledgeSubstrateCore;
-export const DarkMatterFactory = KnowledgeSubstrateFactory;