agentic-qe 3.8.11 → 3.8.13

package/dist/domains/quality-assessment/coordinator.js

@@ -28,6 +28,8 @@ import * as ClaimVerifierHelpers from './coordinator-claim-verifier.js';
 import * as GateEvalHelpers from './coordinator-gate-evaluation.js';
 // ADR-070: Witness Chain audit trail
 import { getWitnessChain } from '../../audit/witness-chain.js';
+// Three-loop feature flag for instantAdapt protocol
+import { isSONAThreeLoopEnabled } from '../../integrations/ruvector/feature-flags.js';
 // CQ-002: Base domain coordinator
 import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 const DEFAULT_CONFIG = {
@@ -227,6 +229,20 @@ export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
             }
             // Success path
             this.completeWorkflow(workflowId);
+            // Three-loop protocol: instantAdapt must precede recordOutcome
+            if (isSONAThreeLoopEnabled() && this.qesona?.isThreeLoopEnabled()) {
+                const m = effectiveRequest.metrics;
+                this.qesona.instantAdapt([
+                    m.coverage / 100,
+                    m.testsPassing / 100,
+                    m.criticalBugs / 10,
+                    m.codeSmells / 100,
+                    m.securityVulnerabilities / 10,
+                    m.technicalDebt / 100,
+                    m.duplications / 100,
+                    finalResult.overallScore / 100,
+                ]);
+            }
             // Store quality pattern in SONA if enabled
             if (this.config.enableSONAPatternLearning && this.qesona) {
                 await this.storeQualityPattern(effectiveRequest, finalResult);
@@ -322,6 +338,16 @@ export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
                     result.value = enhanced;
                 }
             }
+            // Three-loop protocol: instantAdapt must precede recordOutcome
+            if (isSONAThreeLoopEnabled() && this.qesona?.isThreeLoopEnabled()) {
+                const score = result.value.score;
+                this.qesona.instantAdapt([
+                    score.overall / 100,
+                    result.value.metrics.length / 20,
+                    result.value.trends.length / 10,
+                    result.value.recommendations.length / 10,
+                ]);
+            }
             // Store quality pattern in SONA
             if (this.config.enableSONAPatternLearning && this.qesona) {
                 await this.storeQualityAnalysisPattern(request, result.value);

package/dist/domains/test-generation/coordinator.js

@@ -24,6 +24,8 @@ import { createDomainFinding, } from '../../coordination/consensus/domain-findin
 import { createPersistentSONAEngine, } from '../../integrations/ruvector/sona-persistence.js';
 import { createQEFlashAttention, } from '../../integrations/ruvector/wrappers.js';
 import { DecisionTransformerAlgorithm, } from '../../integrations/rl-suite/algorithms/decision-transformer.js';
+// Three-loop feature flag for instantAdapt protocol
+import { isSONAThreeLoopEnabled } from '../../integrations/ruvector/feature-flags.js';
 // Coherence Gate Integration (ADR-052)
 import { createTestGenerationCoherenceGate, } from './services/coherence-gate-service.js';
 const DEFAULT_CONFIG = {
@@ -307,6 +309,18 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                         await this.publishTestGenerated(test, request.framework ?? 'vitest');
                     }
                 }
+                // Three-loop protocol: instantAdapt must precede recordOutcome
+                if (isSONAThreeLoopEnabled() && this.qesona?.isThreeLoopEnabled()) {
+                    const tests = result.value;
+                    this.qesona.instantAdapt([
+                        tests.tests.length / 20,
+                        tests.coverageEstimate / 100,
+                        tests.patternsUsed.length / 10,
+                        request.sourceFiles.length / 20,
+                        (request.coverageTarget ?? 80) / 100,
+                        tests.tests.filter(t => t.type === 'unit').length / 20,
+                    ]);
+                }
                 // Learn from successful generation using QESONA
                 if (this.config.enableQESONA && this.qesona) {
                     await this.storeTestGenerationPattern(result.value, request);

package/dist/init/orchestrator.js

@@ -47,6 +47,7 @@ export class ModularInitOrchestrator {
                 n8nApiConfig: options.n8nApiConfig,
                 wizardAnswers: options.wizardAnswers,
                 noGovernance: options.noGovernance,
+                noMcp: options.noMcp,
             },
             config: {},
             enhancements: {

package/dist/init/phases/08-mcp.js

@@ -26,10 +26,10 @@ export class MCPPhase extends BasePhase {
     requiresPhases = ['configuration', 'database'];
     async run(context) {
         const { projectRoot } = context;
-        // MCP is opt-in: skip unless --with-mcp is passed
-        if (!context.options.withMcp) {
-            context.services.log('  MCP: skipped (opt-in — use --with-mcp to enable)');
-            context.services.log('  All QE commands available via CLI: aqe memory, aqe test, aqe coverage, etc.');
+        // MCP is enabled by default — skip only with --no-mcp
+        if (context.options.noMcp) {
+            context.services.log('  MCP: skipped (--no-mcp)');
+            context.services.log('  CLI commands available: aqe memory, aqe test, aqe coverage, etc.');
             return {
                 configured: false,
                 mcpPath: '',

package/dist/init/phases/phase-interface.d.ts

@@ -106,7 +106,9 @@ export interface InitOptions {
     withContinueDev?: boolean;
     /** Install all coding agent platform configurations */
     withAllPlatforms?: boolean;
-    /** Install MCP server config (opt-in — CLI commands work without MCP) */
+    /** Skip MCP server config (MCP is enabled by default) */
+    noMcp?: boolean;
+    /** @deprecated Use default behavior instead — MCP is now enabled by default */
     withMcp?: boolean;
 }
 /**

package/dist/integrations/agentic-flow/reasoning-bank/experience-replay.d.ts

@@ -117,6 +117,7 @@ export declare class ExperienceReplay {
     private experienceIdToHnswId;
     private nextHnswId;
     private recentExperiences;
+    private reservoirBuffer;
     private stats;
     constructor(config?: Partial<ExperienceReplayConfig>);
     /**
@@ -197,6 +198,16 @@ export declare class ExperienceReplay {
         hnswIndexSize: number;
         recentBufferSize: number;
     };
+    /**
+     * Get reservoir buffer stats (R10, ADR-087).
+     * Returns null if the reservoir is not enabled.
+     */
+    getReservoirStats(): {
+        size: number;
+        totalAdmitted: number;
+        totalRejected: number;
+        tierCounts: Record<string, number>;
+    } | null;
     /**
      * Dispose and cleanup
      */

package/dist/integrations/agentic-flow/reasoning-bank/experience-replay.js

@@ -19,6 +19,8 @@ import { CircularBuffer } from '../../../shared/utils/circular-buffer.js';
 import { HNSWEmbeddingIndex } from '../../embeddings/index/HNSWIndex.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { ExperienceConsolidator } from '../../../learning/experience-consolidation.js';
+import { getRuVectorFeatureFlags } from '../../ruvector/feature-flags.js';
+import { ReservoirReplayBuffer } from '../../ruvector/reservoir-replay.js';
 const DEFAULT_CONFIG = {
     minQualityThreshold: 0.6,
     maxExperiencesPerDomain: 500,
@@ -64,6 +66,8 @@ export class ExperienceReplay {
     nextHnswId = 0;
     // Recent experiences buffer
     recentExperiences;
+    // Reservoir replay buffer (R10, ADR-087) — coherence-gated admission
+    reservoirBuffer = null;
     // Statistics
     stats = {
         experiencesStored: 0,
@@ -99,6 +103,11 @@ export class ExperienceReplay {
         this.prepareStatements();
         // Load embeddings into memory index
         await this.loadEmbeddingIndex();
+        // Initialize reservoir buffer if feature flag is enabled (R10, ADR-087)
+        if (getRuVectorFeatureFlags().useReservoirReplay) {
+            this.reservoirBuffer = new ReservoirReplayBuffer({ capacity: 10_000 });
+            console.log('[ExperienceReplay] Reservoir replay buffer enabled');
+        }
         this.initialized = true;
         console.log('[ExperienceReplay] Initialized');
     }
@@ -333,6 +342,10 @@ export class ExperienceReplay {
         }
         // Add to recent buffer
         this.recentExperiences.push(experience);
+        // Admit to reservoir buffer with coherence gating (R10, ADR-087)
+        if (this.reservoirBuffer) {
+            this.reservoirBuffer.admit(experience.id, experience, experience.qualityScore);
+        }
         this.stats.experiencesStored++;
         // Auto-consolidate if enabled (replaces destructive auto-prune)
         if (this.config.autoPrune) {
@@ -349,8 +362,23 @@ export class ExperienceReplay {
      */
     async getGuidance(task, domain) {
         this.ensureInitialized();
-        // Find similar experiences
+        // Find similar experiences via HNSW
         const similar = await this.findSimilarExperiences(task, domain);
+        // Blend in high-coherence experiences from reservoir buffer (R10, ADR-087)
+        if (this.reservoirBuffer && this.reservoirBuffer.size() > 0) {
+            const reservoirSamples = this.reservoirBuffer.sample(Math.max(2, Math.floor(this.config.topK / 2)), 0.6);
+            for (const entry of reservoirSamples) {
+                const exp = entry.data;
+                // Skip if already in HNSW results
+                if (similar.some(s => s.experience.id === exp.id))
+                    continue;
+                // Skip if domain filter doesn't match
+                if (domain && exp.domain !== domain)
+                    continue;
+                // Add with a coherence-based similarity score
+                similar.push({ experience: exp, similarity: entry.coherenceScore * 0.8 });
+            }
+        }
         if (similar.length === 0) {
             return null;
         }
@@ -564,6 +592,21 @@ export class ExperienceReplay {
             recentBufferSize: this.recentExperiences.length,
         };
     }
+    /**
+     * Get reservoir buffer stats (R10, ADR-087).
+     * Returns null if the reservoir is not enabled.
+     */
+    getReservoirStats() {
+        if (!this.reservoirBuffer)
+            return null;
+        const stats = this.reservoirBuffer.getStats();
+        return {
+            size: stats.size,
+            totalAdmitted: stats.totalAdmitted,
+            totalRejected: stats.totalRejected,
+            tierCounts: stats.tierCounts,
+        };
+    }
     /**
      * Dispose and cleanup
      */

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

@@ -0,0 +1,79 @@
+/**
+ * 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 type { RLState, RLPrediction, RLTrainingStats, RLExperience, RLAlgorithmInfo, RewardSignal } from '../interfaces';
+interface EpropAlgorithmConfig {
+    /** Number of state features */
+    stateSize: number;
+    /** Hidden layer size for the E-prop network */
+    hiddenSize: number;
+    /** Number of discrete actions */
+    actionSize: number;
+    /** E-prop learning rate */
+    epropLearningRate: number;
+    /** Eligibility trace decay */
+    eligibilityDecay: number;
+    /** Use feedback alignment */
+    feedbackAlignment: boolean;
+}
+/**
+ * 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 declare class EpropAlgorithm extends BaseRLAlgorithm {
+    private network;
+    private epropConfig;
+    private actions;
+    constructor(config?: Partial<EpropAlgorithmConfig>, rewardSignals?: RewardSignal[]);
+    /**
+     * Predict best action for a given state.
+     * Runs the E-prop network forward pass and selects the action
+     * with highest output activation.
+     */
+    predict(state: RLState): Promise<RLPrediction>;
+    /**
+     * 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
+     */
+    train(experience: RLExperience): Promise<RLTrainingStats>;
+    /**
+     * Core training logic for batch experiences.
+     * E-prop processes each experience online (sequentially).
+     */
+    protected trainCore(experiences: RLExperience[]): Promise<RLTrainingStats>;
+    /**
+     * Get algorithm-specific info.
+     */
+    protected getAlgorithmInfo(): RLAlgorithmInfo;
+    protected exportCustomData(): Promise<Record<string, unknown>>;
+    protected importCustomData(data: Record<string, unknown>): Promise<void>;
+    protected resetAlgorithm(): Promise<void>;
+    private prepareState;
+    private argmax;
+    private calculateConfidence;
+    private generateReasoning;
+}
+/**
+ * Create a new E-prop RL algorithm instance.
+ */
+export declare function createEpropAlgorithm(config?: Partial<EpropAlgorithmConfig>, rewardSignals?: RewardSignal[]): EpropAlgorithm;
+export {};
+//# sourceMappingURL=eprop.d.ts.map

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)
 // ============================================================================