agentic-qe 3.8.10 → 3.8.12

package/dist/domains/code-intelligence/coordinator-gnn.js

@@ -6,6 +6,7 @@
  */
 import { LoggerFactory } from '../../logging/index.js';
 import { QEGNNIndexFactory, initGNN, } from '../../integrations/ruvector/wrappers';
+import { isGraphMAEEnabled, isColdTierGNNEnabled, createGraphMAEEncoder, createColdTierTrainer, InMemoryGraph, } from '../../integrations/ruvector/index.js';
 /**
  * Initialize GNN for code graph embeddings
  */
@@ -55,6 +56,73 @@ export async function indexCodeEmbeddings(gnnIndex, fileReader, paths) {
         logger.error('Failed to index code embeddings:', error instanceof Error ? error : undefined);
     }
 }
+// R4: GraphMAE singleton encoder (lazy-initialized)
+let graphMAEEncoder = null;
+/**
+ * R4: Generate graph-aware embeddings for a set of files using GraphMAE.
+ * Builds a dependency graph from import relationships and uses masked
+ * autoencoders to produce structure-aware embeddings.
+ * Falls back to feature-hash embeddings when GraphMAE is disabled.
+ */
+export async function generateGraphMAEEmbeddings(fileReader, paths) {
+    const embeddings = new Map();
+    if (!isGraphMAEEnabled() || paths.length < 2) {
+        // Fallback: use feature-hash for each file independently
+        for (const p of paths) {
+            const result = await fileReader.readFile(p);
+            if (result.success && result.value) {
+                embeddings.set(p, await generateCodeEmbedding(p, result.value));
+            }
+        }
+        return embeddings;
+    }
+    try {
+        // Build QEGraph: nodes are files, edges are import dependencies
+        const nodes = new Map();
+        const edges = new Map();
+        const contentCache = new Map();
+        for (const p of paths) {
+            const result = await fileReader.readFile(p);
+            if (result.success && result.value) {
+                contentCache.set(p, result.value);
+                const featureVec = await generateCodeEmbedding(p, result.value);
+                nodes.set(p, new Float32Array(featureVec.slice(0, 32)));
+                // Extract import targets as edges
+                const imports = result.value.match(/from\s+['"]([^'"]+)['"]/g) ?? [];
+                const targets = imports
+                    .map(m => m.replace(/from\s+['"]/, '').replace(/['"]$/, ''))
+                    .filter(t => paths.some(pp => pp.includes(t.replace(/^\.\//, ''))));
+                edges.set(p, targets.length > 0 ? targets : []);
+            }
+        }
+        if (nodes.size < 2) {
+            // Not enough nodes for meaningful graph learning
+            for (const [p, content] of contentCache) {
+                embeddings.set(p, await generateCodeEmbedding(p, content));
+            }
+            return embeddings;
+        }
+        const graph = { nodes, edges };
+        if (!graphMAEEncoder) {
+            graphMAEEncoder = createGraphMAEEncoder({ embeddingDim: 128, numHeads: 4 });
+        }
+        const graphEmbeddings = graphMAEEncoder.embed(graph);
+        for (const [nodeId, emb] of graphEmbeddings) {
+            embeddings.set(nodeId, Array.from(emb));
+        }
+        logger.info(`[R4] GraphMAE generated ${graphEmbeddings.size} graph-aware embeddings`);
+    }
+    catch (error) {
+        logger.error('[R4] GraphMAE embedding failed, using feature-hash fallback:', error instanceof Error ? error : undefined);
+        for (const p of paths) {
+            const result = await fileReader.readFile(p);
+            if (result.success && result.value) {
+                embeddings.set(p, await generateCodeEmbedding(p, result.value));
+            }
+        }
+    }
+    return embeddings;
+}
 /**
  * Generate code embedding using semantic features
  */
@@ -171,6 +239,40 @@ export function mergeSearchResults(semanticResults, gnnResults) {
         .sort((a, b) => b.score - a.score)
         .slice(0, 20);
 }
+// R6: ColdTier trainer singleton (lazy-initialized)
+let coldTierTrainer = null;
+/**
+ * R6: Train GNN embeddings with memory-bounded cold-tier training.
+ * Uses LRU hotset caching when the graph exceeds hotsetSize, falling
+ * back to full in-memory training for small graphs.
+ */
+export function trainWithColdTier(nodeFeatures, adjacency, options = {}) {
+    if (!isColdTierGNNEnabled()) {
+        return { embeddings: new Map(), loss: 0, usedColdTier: false };
+    }
+    try {
+        if (!coldTierTrainer) {
+            coldTierTrainer = createColdTierTrainer({
+                hotsetSize: options.hotsetSize ?? 10000,
+                epochs: options.epochs ?? 10,
+                hiddenDim: options.hiddenDim ?? 64,
+            });
+        }
+        const graph = new InMemoryGraph(nodeFeatures, adjacency);
+        const result = coldTierTrainer.train(graph);
+        logger.info(`[R6] ColdTier training: ${graph.nodeCount} nodes, ` +
+            `loss=${result.loss.toFixed(4)}, mode=${result.usedInMemoryMode ? 'in-memory' : 'cold-tier'}`);
+        return {
+            embeddings: result.embeddings,
+            loss: result.loss,
+            usedColdTier: !result.usedInMemoryMode,
+        };
+    }
+    catch (error) {
+        logger.error('[R6] ColdTier training failed:', error instanceof Error ? error : undefined);
+        return { embeddings: new Map(), loss: 0, usedColdTier: false };
+    }
+}
 /**
  * Simple hash function for strings
  */

package/dist/domains/contract-testing/coordinator.js

@@ -16,6 +16,8 @@ import { ContractValidatorService } from './services/contract-validator.js';
 import { ApiCompatibilityService } from './services/api-compatibility.js';
 import { SARSAAlgorithm } from '../../integrations/rl-suite/algorithms/sarsa.js';
 import { createPersistentSONAEngine } from '../../integrations/ruvector/sona-persistence.js';
+// Three-loop feature flag for instantAdapt protocol
+import { isSONAThreeLoopEnabled } from '../../integrations/ruvector/feature-flags.js';
 import { createDomainFinding, } from '../../coordination/consensus/domain-findings.js';
 // CQ-002: Base domain coordinator
 import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
@@ -960,6 +962,17 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
                     contract.endpoints.filter((e) => e.responseSchema).length / 100,
                 ],
             };
+            // Three-loop protocol: instantAdapt must precede recordOutcome
+            if (isSONAThreeLoopEnabled() && this.qesona.isThreeLoopEnabled()) {
+                this.qesona.instantAdapt([
+                    contract.endpoints.length / 100,
+                    contract.consumers.length / 50,
+                    contract.schemas.length / 50,
+                    quality,
+                    validationSuccess ? 1 : 0,
+                    contract.version.major / 10,
+                ]);
+            }
             const action = {
                 type: validationSuccess ? 'validate' : 'reject',
                 value: quality,

package/dist/domains/coverage-analysis/coordinator.js

@@ -69,6 +69,11 @@ export class CoverageAnalysisCoordinator extends BaseDomainCoordinator {
     async onInitialize() {
         // Services are stateless, no domain-specific initialization needed
         // ADR-059: Ghost coverage analyzer is lazy-initialized on first use
+        // NOTE: EWC++ three-loop integration not available in this coordinator.
+        // Coverage-analysis uses Q-Learning (not SONA), so the three-loop engine
+        // is not accessible here. To enable EWC++ for coverage patterns, this
+        // coordinator would need a PersistentSONAEngine instance wired the same
+        // way as quality-assessment and test-generation coordinators.
     }
     async onDispose() {
         // No domain-specific cleanup needed

package/dist/domains/defect-intelligence/coordinator.d.ts

@@ -54,6 +54,7 @@ export declare class DefectIntelligenceCoordinator extends BaseDomainCoordinator
     private readonly predictor;
     private readonly patternLearner;
     private readonly rootCauseAnalyzer;
+    private readonly testExecutionHistory;
     constructor(eventBus: EventBus, memory: MemoryBackend, agentCoordinator: AgentCoordinator, config?: Partial<CoordinatorConfig>);
     protected onInitialize(): Promise<void>;
     protected onDispose(): Promise<void>;

package/dist/domains/defect-intelligence/coordinator.js

@@ -17,6 +17,9 @@ import { PatternLearnerService, } from './services/pattern-learner';
 import { RootCauseAnalyzerService, } from './services/root-cause-analyzer';
 // CQ-002: Base domain coordinator
 import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
+// R12: Granger Causality for temporal failure prediction (ADR-087)
+import { getRuVectorFeatureFlags } from '../../integrations/ruvector/feature-flags.js';
+import { GrangerAnalyzer } from '../../integrations/ruvector/temporal-causality.js';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 5,
     defaultTimeout: 60000,
@@ -49,6 +52,8 @@ export class DefectIntelligenceCoordinator extends BaseDomainCoordinator {
     predictor;
     patternLearner;
     rootCauseAnalyzer;
+    // R12: Accumulated test execution history for Granger causality (ADR-087)
+    testExecutionHistory = new Map();
     constructor(eventBus, memory, agentCoordinator, config = {}) {
         const fullConfig = { ...DEFAULT_CONFIG, ...config };
         super(eventBus, 'defect-intelligence', fullConfig, {
@@ -160,6 +165,44 @@ export class DefectIntelligenceCoordinator extends BaseDomainCoordinator {
                 if (this.config.enablePatternLearning) {
                     await this.autoAnalyzeHighRisk(enhancedResult);
                 }
+                // R12: Accumulate test history and run Granger causality (ADR-087)
+                if (getRuVectorFeatureFlags().useGrangerCausality) {
+                    try {
+                        const now = Date.now();
+                        // Accumulate prediction outcomes into per-test history
+                        for (const p of enhancedResult.predictions) {
+                            const history = this.testExecutionHistory.get(p.file) ?? { timestamps: [], outcomes: [] };
+                            history.timestamps.push(now);
+                            history.outcomes.push(p.probability > 0.5 ? 0 : 1);
+                            // Cap history at 500 points per test
+                            if (history.timestamps.length > 500) {
+                                history.timestamps.splice(0, history.timestamps.length - 500);
+                                history.outcomes.splice(0, history.outcomes.length - 500);
+                            }
+                            this.testExecutionHistory.set(p.file, history);
+                        }
+                        // Run Granger analysis when we have enough accumulated history
+                        const eligibleSeries = Array.from(this.testExecutionHistory.entries())
+                            .filter(([, h]) => h.timestamps.length >= 30)
+                            .map(([testId, h]) => ({ testId, timestamps: h.timestamps, outcomes: h.outcomes }));
+                        if (eligibleSeries.length >= 3) {
+                            const analyzer = new GrangerAnalyzer({ maxLag: 5, alpha: 0.05 });
+                            const causalLinks = analyzer.analyzeCausality(eligibleSeries);
+                            if (causalLinks.length > 0) {
+                                logger.info('Granger causality found causal links in defect predictions', {
+                                    linkCount: causalLinks.length,
+                                    historyDepth: eligibleSeries[0].timestamps.length,
+                                    topLink: `${causalLinks[0].sourceTestId} → ${causalLinks[0].targetTestId} (lag=${causalLinks[0].lag}, p=${causalLinks[0].pValue.toFixed(4)})`,
+                                });
+                            }
+                        }
+                    }
+                    catch (grangerErr) {
+                        logger.warn('Granger causality analysis failed (non-fatal)', {
+                            error: grangerErr instanceof Error ? grangerErr.message : 'unknown',
+                        });
+                    }
+                }
                 // Stop the agent
                 await this.agentCoordinator.stop(agentResult.value);
                 return ok(enhancedResult);

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