agentic-qe 3.8.11 → 3.8.12

package/dist/integrations/rl-suite/algorithms/eprop.js

@@ -0,0 +1,284 @@
+/**
+ * Agentic QE v3 - E-prop Online Learning Algorithm (ADR-087 Milestone 4)
+ *
+ * RL algorithm #10: Eligibility propagation for online learning.
+ * Uses 12 bytes/synapse with no backprop required.
+ *
+ * Application: Online adaptive test strategies — learns in real time
+ * from test execution feedback without storing replay buffers.
+ */
+import { BaseRLAlgorithm } from '../base-algorithm';
+import { TEST_EXECUTION_REWARDS } from '../interfaces';
+import { createEpropNetwork, } from '../../ruvector/eprop-learner.js';
+import { getRuVectorFeatureFlags } from '../../ruvector/feature-flags.js';
+const DEFAULT_EPROP_ALGORITHM_CONFIG = {
+    stateSize: 10,
+    hiddenSize: 50,
+    actionSize: 4,
+    epropLearningRate: 0.01,
+    eligibilityDecay: 0.95,
+    feedbackAlignment: true,
+};
+// ============================================================================
+// E-prop RL Algorithm
+// ============================================================================
+/**
+ * E-prop online learning algorithm for adaptive test strategies.
+ *
+ * Unlike batch RL algorithms, E-prop learns from each experience
+ * immediately using eligibility traces — no replay buffer needed.
+ *
+ * Key advantages:
+ * - Online: updates weights after every step
+ * - Memory-efficient: 12 bytes/synapse (vs kilobytes for replay-based)
+ * - Biologically plausible: no weight transport (feedback alignment)
+ * - Fast: no backward pass through the full network
+ */
+export class EpropAlgorithm extends BaseRLAlgorithm {
+    network;
+    epropConfig;
+    actions;
+    constructor(config = {}, rewardSignals = TEST_EXECUTION_REWARDS) {
+        super('eprop', 'online-learning', {}, rewardSignals);
+        this.epropConfig = { ...DEFAULT_EPROP_ALGORITHM_CONFIG, ...config };
+        // Create the underlying E-prop network
+        this.network = createEpropNetwork({
+            inputSize: this.epropConfig.stateSize,
+            hiddenSize: this.epropConfig.hiddenSize,
+            outputSize: this.epropConfig.actionSize,
+            learningRate: this.epropConfig.epropLearningRate,
+            eligibilityDecay: this.epropConfig.eligibilityDecay,
+            feedbackAlignment: this.epropConfig.feedbackAlignment,
+        });
+        // Default action space for test execution
+        this.actions = [
+            { type: 'execute', value: 'standard' },
+            { type: 'prioritize', value: 'high' },
+            { type: 'retry', value: 'adaptive' },
+            { type: 'skip', value: 0 },
+        ];
+        // Trim or pad action space to match config
+        while (this.actions.length < this.epropConfig.actionSize) {
+            this.actions.push({ type: 'explore', value: this.actions.length });
+        }
+        this.actions = this.actions.slice(0, this.epropConfig.actionSize);
+    }
+    // ==========================================================================
+    // RLAlgorithm Interface
+    // ==========================================================================
+    /**
+     * Predict best action for a given state.
+     * Runs the E-prop network forward pass and selects the action
+     * with highest output activation.
+     */
+    async predict(state) {
+        if (!getRuVectorFeatureFlags().useEpropOnlineLearning) {
+            // Feature flag disabled — return default action with zero confidence
+            return {
+                action: { type: this.actions[0]?.type ?? 'test-action', value: this.actions[0]?.value ?? 'default' },
+                confidence: 0,
+            };
+        }
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        const stateFeatures = this.prepareState(state);
+        const output = this.network.forward(stateFeatures);
+        // Select action with highest activation
+        const actionIndex = this.argmax(output);
+        const action = this.actions[actionIndex];
+        const confidence = this.calculateConfidence(output);
+        return {
+            action: { type: action.type, value: action.value },
+            confidence,
+            value: output[actionIndex],
+            reasoning: this.generateReasoning(action, output[actionIndex], confidence),
+        };
+    }
+    /**
+     * Train with a single experience — the core online learning step.
+     *
+     * Unlike batch algorithms, E-prop processes each experience immediately:
+     * 1. Forward pass (already done during predict)
+     * 2. Online update: dw = eta * eligibility * reward
+     */
+    async train(experience) {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        const startTime = Date.now();
+        // Run forward pass on the state to update eligibility traces
+        const stateFeatures = this.prepareState(experience.state);
+        this.network.forward(stateFeatures);
+        // Apply online update with reward signal
+        this.network.updateOnline(experience.reward);
+        // Reset traces if episode ended
+        if (experience.done) {
+            this.network.resetTraces();
+        }
+        // Track stats
+        this.episodeCount++;
+        this.totalReward += experience.reward;
+        this.rewardHistory.push(experience.reward);
+        if (this.rewardHistory.length > 1000) {
+            this.rewardHistory.shift();
+        }
+        const avgReward = this.rewardHistory.reduce((a, b) => a + b, 0) / this.rewardHistory.length;
+        this.stats = {
+            episode: this.episodeCount,
+            totalReward: this.totalReward,
+            averageReward: avgReward,
+            trainingTimeMs: Date.now() - startTime,
+            timestamp: new Date(),
+            explorationRate: this.config.explorationRate,
+        };
+        return this.stats;
+    }
+    /**
+     * Core training logic for batch experiences.
+     * E-prop processes each experience online (sequentially).
+     */
+    async trainCore(experiences) {
+        for (const exp of experiences) {
+            const stateFeatures = this.prepareState(exp.state);
+            this.network.forward(stateFeatures);
+            this.network.updateOnline(exp.reward);
+            if (exp.done) {
+                this.network.resetTraces();
+            }
+        }
+        const avgReward = this.rewardHistory.length > 0
+            ? this.rewardHistory.reduce((a, b) => a + b, 0) / this.rewardHistory.length
+            : 0;
+        return {
+            episode: this.episodeCount,
+            totalReward: this.totalReward,
+            averageReward: avgReward,
+            trainingTimeMs: 0,
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Get algorithm-specific info.
+     */
+    getAlgorithmInfo() {
+        const networkStats = this.network.getStats();
+        return {
+            type: 'eprop',
+            category: 'online-learning',
+            version: '1.0.0',
+            description: 'E-prop Online Learning for Adaptive Test Strategies',
+            capabilities: [
+                'Online learning (no replay buffer)',
+                'Eligibility trace propagation',
+                'Feedback alignment (no weight transport)',
+                '12 bytes/synapse memory budget',
+                'Real-time adaptation to test results',
+            ],
+            hyperparameters: {
+                stateSize: this.epropConfig.stateSize,
+                hiddenSize: this.epropConfig.hiddenSize,
+                actionSize: this.epropConfig.actionSize,
+                learningRate: this.epropConfig.epropLearningRate,
+                eligibilityDecay: this.epropConfig.eligibilityDecay,
+                feedbackAlignment: String(this.epropConfig.feedbackAlignment),
+                synapsCount: networkStats.synapsCount,
+                memoryBytes: networkStats.memoryBytes,
+            },
+            stats: this.stats,
+        };
+    }
+    // ==========================================================================
+    // Export / Import
+    // ==========================================================================
+    async exportCustomData() {
+        const weights = this.network.exportWeights();
+        return {
+            inputHidden: Array.from(weights.inputHidden),
+            hiddenOutput: Array.from(weights.hiddenOutput),
+            epropConfig: this.epropConfig,
+            networkStats: this.network.getStats(),
+        };
+    }
+    async importCustomData(data) {
+        if (data.epropConfig) {
+            this.epropConfig = { ...this.epropConfig, ...data.epropConfig };
+        }
+        if (data.inputHidden && data.hiddenOutput) {
+            this.network.importWeights({
+                inputHidden: new Float32Array(data.inputHidden),
+                hiddenOutput: new Float32Array(data.hiddenOutput),
+            });
+        }
+        this.initialized = true;
+    }
+    async resetAlgorithm() {
+        this.network = createEpropNetwork({
+            inputSize: this.epropConfig.stateSize,
+            hiddenSize: this.epropConfig.hiddenSize,
+            outputSize: this.epropConfig.actionSize,
+            learningRate: this.epropConfig.epropLearningRate,
+            eligibilityDecay: this.epropConfig.eligibilityDecay,
+            feedbackAlignment: this.epropConfig.feedbackAlignment,
+        });
+    }
+    // ==========================================================================
+    // Private Helpers
+    // ==========================================================================
+    prepareState(state) {
+        const features = state.features.slice(0, this.epropConfig.stateSize);
+        // Pad with zeros if needed
+        while (features.length < this.epropConfig.stateSize) {
+            features.push(0);
+        }
+        // Normalize to [-1, 1]
+        const max = Math.max(...features.map(Math.abs));
+        if (max > 0) {
+            for (let i = 0; i < features.length; i++) {
+                features[i] = features[i] / max;
+            }
+        }
+        return new Float32Array(features);
+    }
+    argmax(array) {
+        let maxIndex = 0;
+        let maxValue = array[0];
+        for (let i = 1; i < array.length; i++) {
+            if (array[i] > maxValue) {
+                maxValue = array[i];
+                maxIndex = i;
+            }
+        }
+        return maxIndex;
+    }
+    calculateConfidence(output) {
+        const arr = Array.from(output);
+        const max = Math.max(...arr);
+        const min = Math.min(...arr);
+        if (max === min)
+            return 0.5;
+        const spread = max - min;
+        return Math.min(1, 0.3 + spread * 2);
+    }
+    generateReasoning(action, value, confidence) {
+        const stats = this.network.getStats();
+        if (stats.totalSteps < 10) {
+            return `E-prop exploration phase (step ${stats.totalSteps}): ${action.type} action`;
+        }
+        if (confidence > 0.8) {
+            return (`High-confidence E-prop decision (${confidence.toFixed(2)}): ${action.type} ` +
+                `with value ${value.toFixed(3)} after ${stats.totalSteps} online updates`);
+        }
+        return `E-prop online learning: ${action.type} with confidence ${confidence.toFixed(2)}`;
+    }
+}
+// ============================================================================
+// Factory
+// ============================================================================
+/**
+ * Create a new E-prop RL algorithm instance.
+ */
+export function createEpropAlgorithm(config, rewardSignals) {
+    return new EpropAlgorithm(config, rewardSignals);
+}
+//# sourceMappingURL=eprop.js.map

package/dist/integrations/rl-suite/algorithms/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Agentic QE v3 - RL Algorithms Index
  *
- * Exports all 9 RL algorithms for QE applications.
+ * Exports all 10 RL algorithms for QE applications.
  */
 export { QLearningAlgorithm } from './q-learning';
 export { DecisionTransformerAlgorithm } from './decision-transformer';
@@ -12,4 +12,5 @@ export { DQNAlgorithm } from './dqn';
 export { PPOAlgorithm } from './ppo';
 export { A2CAlgorithm } from './a2c';
 export { DDPGAlgorithm } from './ddpg';
+export { EpropAlgorithm, createEpropAlgorithm } from './eprop';
 //# sourceMappingURL=index.d.ts.map

package/dist/integrations/rl-suite/algorithms/index.js

@@ -1,7 +1,7 @@
 /**
  * Agentic QE v3 - RL Algorithms Index
  *
- * Exports all 9 RL algorithms for QE applications.
+ * Exports all 10 RL algorithms for QE applications.
  */
 export { QLearningAlgorithm } from './q-learning';
 export { DecisionTransformerAlgorithm } from './decision-transformer';
@@ -12,4 +12,5 @@ export { DQNAlgorithm } from './dqn';
 export { PPOAlgorithm } from './ppo';
 export { A2CAlgorithm } from './a2c';
 export { DDPGAlgorithm } from './ddpg';
+export { EpropAlgorithm, createEpropAlgorithm } from './eprop';
 //# sourceMappingURL=index.js.map

package/dist/integrations/rl-suite/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Agentic QE v3 - RL Suite Main Export
  *
- * Complete RL Suite for Quality Engineering with 9 algorithms.
+ * Complete RL Suite for Quality Engineering with 10 algorithms.
  * Per ADR-040, provides reinforcement learning for QE decision-making.
  */
 import type { DomainName } from '../../shared/types';
@@ -10,7 +10,7 @@ import type { QERLSuite } from './orchestrator';
 export { QERLSuite, createQERLSuite } from './orchestrator';
 export type { RLSuiteStats } from './orchestrator';
 export { BaseRLAlgorithm } from './base-algorithm';
-export { QLearningAlgorithm, DecisionTransformerAlgorithm, SARSAAlgorithm, ActorCriticAlgorithm, PolicyGradientAlgorithm, DQNAlgorithm, PPOAlgorithm, A2CAlgorithm, DDPGAlgorithm, } from './algorithms';
+export { QLearningAlgorithm, DecisionTransformerAlgorithm, SARSAAlgorithm, ActorCriticAlgorithm, PolicyGradientAlgorithm, DQNAlgorithm, PPOAlgorithm, A2CAlgorithm, DDPGAlgorithm, EpropAlgorithm, createEpropAlgorithm, } from './algorithms';
 export type { RLAlgorithmType, RLAlgorithmCategory, QEDomainApplication, RLState, RLAction, RLExperience, RLPrediction, RLTrainingStats, RLTrainingConfig, RLAlgorithmInfo, TestExecutionState, TestExecutionAction, CoverageAnalysisState, CoverageOptimizationAction, QualityGateState, QualityGateAction, ResourceAllocationState, ResourceAllocationAction, RewardSignal, RewardContext, RewardCalculation, AlgorithmDomainMapping, RLSuiteConfig, ALGORITHM_DOMAIN_MAPPINGS, RLAlgorithmError, RLTrainingError, RLPredictionError, RLConfigError, } from './interfaces';
 export { SONA, SONAIndex, SONAOptimizer, SONAPatternCache, createSONA, createDomainSONA, } from './sona';
 export type { SONAPattern, SONAPatternType, SONAAdaptationResult, SONAStats, SONAConfig, } from './sona';

package/dist/integrations/rl-suite/index.js

@@ -1,7 +1,7 @@
 /**
  * Agentic QE v3 - RL Suite Main Export
  *
- * Complete RL Suite for Quality Engineering with 9 algorithms.
+ * Complete RL Suite for Quality Engineering with 10 algorithms.
  * Per ADR-040, provides reinforcement learning for QE decision-making.
  */
 // ============================================================================
@@ -15,7 +15,7 @@ export { BaseRLAlgorithm } from './base-algorithm';
 // ============================================================================
 // Algorithms
 // ============================================================================
-export { QLearningAlgorithm, DecisionTransformerAlgorithm, SARSAAlgorithm, ActorCriticAlgorithm, PolicyGradientAlgorithm, DQNAlgorithm, PPOAlgorithm, A2CAlgorithm, DDPGAlgorithm, } from './algorithms';
+export { QLearningAlgorithm, DecisionTransformerAlgorithm, SARSAAlgorithm, ActorCriticAlgorithm, PolicyGradientAlgorithm, DQNAlgorithm, PPOAlgorithm, A2CAlgorithm, DDPGAlgorithm, EpropAlgorithm, createEpropAlgorithm, } from './algorithms';
 // ============================================================================
 // SONA (Self-Optimizing Neural Architecture)
 // ============================================================================

package/dist/integrations/rl-suite/interfaces.d.ts

@@ -2,18 +2,18 @@
  * Agentic QE v3 - RL Suite Interfaces
  *
  * Reinforcement Learning algorithms for Quality Engineering.
- * Per ADR-040, implements 9 RL algorithms for QE-specific applications.
+ * Per ADR-040 + ADR-087 R11, implements 10 RL algorithms for QE-specific applications.
  */
 import type { DomainName, Priority, AgentType } from '../../shared/types';
 export type { DomainName } from '../../shared/types';
 /**
  * All supported RL algorithms
  */
-export type RLAlgorithmType = 'decision-transformer' | 'q-learning' | 'sarsa' | 'actor-critic' | 'policy-gradient' | 'dqn' | 'ppo' | 'a2c' | 'ddpg';
+export type RLAlgorithmType = 'decision-transformer' | 'q-learning' | 'sarsa' | 'actor-critic' | 'policy-gradient' | 'dqn' | 'ppo' | 'a2c' | 'ddpg' | 'eprop';
 /**
  * RL algorithm categories
  */
-export type RLAlgorithmCategory = 'value-based' | 'policy-based' | 'actor-critic' | 'offline-rl' | 'deterministic-policy';
+export type RLAlgorithmCategory = 'value-based' | 'policy-based' | 'actor-critic' | 'offline-rl' | 'deterministic-policy' | 'online-learning';
 /**
  * QE domain application for RL algorithms
  */

package/dist/integrations/rl-suite/interfaces.js

@@ -2,7 +2,7 @@
  * Agentic QE v3 - RL Suite Interfaces
  *
  * Reinforcement Learning algorithms for Quality Engineering.
- * Per ADR-040, implements 9 RL algorithms for QE-specific applications.
+ * Per ADR-040 + ADR-087 R11, implements 10 RL algorithms for QE-specific applications.
  */
 // ============================================================================
 // QE Reward Signal Presets

package/dist/integrations/rl-suite/orchestrator.d.ts

@@ -1,7 +1,7 @@
 /**
  * Agentic QE v3 - QE RL Suite Orchestrator
  *
- * Main orchestrator for all 9 RL algorithms in QE.
+ * Main orchestrator for all 10 RL algorithms in QE.
  * Provides unified interface for algorithm selection, training, and inference.
  */
 import type { RLAlgorithm, RLAlgorithmType, RLState, RLAction, RLPrediction, RLExperience, RLTrainingStats, RLSuiteConfig, DomainName, RewardContext, RewardCalculation } from './interfaces';
@@ -16,7 +16,7 @@ export interface RLSuiteStats {
 /**
  * Main orchestrator for QE RL Suite
  *
- * Manages all 9 RL algorithms and provides:
+ * Manages all 10 RL algorithms and provides:
  * - Algorithm selection based on domain/task
  * - Unified training interface
  * - Prediction with automatic algorithm routing

package/dist/integrations/rl-suite/orchestrator.js

@@ -1,7 +1,7 @@
 /**
  * Agentic QE v3 - QE RL Suite Orchestrator
  *
- * Main orchestrator for all 9 RL algorithms in QE.
+ * Main orchestrator for all 10 RL algorithms in QE.
  * Provides unified interface for algorithm selection, training, and inference.
  */
 import { QLearningAlgorithm } from './algorithms/q-learning';
@@ -21,7 +21,7 @@ import { getRewardSignalsForDomain, calculateReward } from './reward-signals';
 /**
  * Main orchestrator for QE RL Suite
  *
- * Manages all 9 RL algorithms and provides:
+ * Manages all 10 RL algorithms and provides:
  * - Algorithm selection based on domain/task
  * - Unified training interface
  * - Prediction with automatic algorithm routing
@@ -347,6 +347,7 @@ export class QERLSuite {
                 'ppo': 0,
                 'a2c': 0,
                 'ddpg': 0,
+                'eprop': 0,
             },
             domainUsage: {},
             lastUpdated: new Date(),

package/dist/integrations/rl-suite/reward-signals.d.ts

@@ -2,7 +2,7 @@
  * Agentic QE v3 - QE-Specific Reward Signals
  *
  * Domain-specific reward functions for RL algorithms in QE.
- * Per ADR-040, implements reward signals for all 9 algorithms.
+ * Per ADR-040, implements reward signals for all 10 algorithms.
  */
 import type { RewardSignal, RewardContext, RewardCalculation, DomainName } from './interfaces';
 /**

package/dist/integrations/rl-suite/reward-signals.js

@@ -2,7 +2,7 @@
  * Agentic QE v3 - QE-Specific Reward Signals
  *
  * Domain-specific reward functions for RL algorithms in QE.
- * Per ADR-040, implements reward signals for all 9 algorithms.
+ * Per ADR-040, implements reward signals for all 10 algorithms.
  */
 // ============================================================================
 // Test Execution Rewards (for Decision Transformer, DQN, PPO)

package/dist/integrations/ruvector/coherence-gate-cohomology.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Coherence Gate - CohomologyEngine WASM Lazy Loader
+ *
+ * Lazily loads the CohomologyEngine from prime-radiant-advanced-wasm.
+ * Returns null when the WASM module is unavailable, allowing fallback
+ * to word-frequency cosine similarity.
+ *
+ * @module integrations/ruvector/coherence-gate-cohomology
+ * @see ADR-083-coherence-gated-agent-actions.md
+ */
+/**
+ * Minimal interface for the CohomologyEngine from prime-radiant-advanced-wasm.
+ */
+export interface ICohomologyEngine {
+    consistencyEnergy(graph: {
+        nodes: Array<{
+            id: number;
+            label: string;
+            section: number[];
+            weight: number;
+        }>;
+        edges: Array<{
+            source: number;
+            target: number;
+            weight: number;
+            restriction_map: number[];
+            source_dim: number;
+            target_dim: number;
+        }>;
+    }): number;
+}
+/**
+ * Lazily load the CohomologyEngine from prime-radiant-advanced-wasm.
+ * Returns null if the WASM module is unavailable.
+ */
+export declare function getCohomologyEngine(): ICohomologyEngine | null;
+/**
+ * Reset the CohomologyEngine loader state (for testing).
+ */
+export declare function resetCohomologyEngineLoader(): void;
+//# sourceMappingURL=coherence-gate-cohomology.d.ts.map

package/dist/integrations/ruvector/coherence-gate-cohomology.js

@@ -0,0 +1,47 @@
+/**
+ * Coherence Gate - CohomologyEngine WASM Lazy Loader
+ *
+ * Lazily loads the CohomologyEngine from prime-radiant-advanced-wasm.
+ * Returns null when the WASM module is unavailable, allowing fallback
+ * to word-frequency cosine similarity.
+ *
+ * @module integrations/ruvector/coherence-gate-cohomology
+ * @see ADR-083-coherence-gated-agent-actions.md
+ */
+import { createRequire } from 'module';
+import { LoggerFactory } from '../../logging/index.js';
+const esmRequire = createRequire(import.meta.url);
+const logger = LoggerFactory.create('coherence-gate-cohomology');
+let cohomologyEngine = null;
+let cohomologyLoadAttempted = false;
+/**
+ * Lazily load the CohomologyEngine from prime-radiant-advanced-wasm.
+ * Returns null if the WASM module is unavailable.
+ */
+export function getCohomologyEngine() {
+    if (cohomologyLoadAttempted)
+        return cohomologyEngine;
+    cohomologyLoadAttempted = true;
+    try {
+        const pr = esmRequire('prime-radiant-advanced-wasm');
+        const fs = esmRequire('fs');
+        const path = esmRequire('path');
+        const wasmPath = path.join(path.dirname(require.resolve('prime-radiant-advanced-wasm')), 'prime_radiant_advanced_wasm_bg.wasm');
+        pr.initSync({ module: fs.readFileSync(wasmPath) });
+        cohomologyEngine = new pr.CohomologyEngine();
+        logger.info('CohomologyEngine loaded from prime-radiant-advanced-wasm');
+    }
+    catch (err) {
+        logger.debug('CohomologyEngine unavailable, using word-frequency fallback', { error: String(err) });
+        cohomologyEngine = null;
+    }
+    return cohomologyEngine;
+}
+/**
+ * Reset the CohomologyEngine loader state (for testing).
+ */
+export function resetCohomologyEngineLoader() {
+    cohomologyEngine = null;
+    cohomologyLoadAttempted = false;
+}
+//# sourceMappingURL=coherence-gate-cohomology.js.map