agentic-qe 3.8.11 → 3.8.13

package/dist/cli/commands/code.js

@@ -5,17 +5,29 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { walkSourceFiles } from '../utils/file-discovery.js';
+import { walkSourceFiles, SOURCE_EXTENSIONS } from '../utils/file-discovery.js';
 import { writeOutput, toJSON } from '../utils/ci-output.js';
 export function createCodeCommand(context, cleanupAndExit, ensureInitialized) {
     const codeCmd = new Command('code')
         .description('Code intelligence analysis')
-        .argument('<action>', 'Action (index|search|impact|deps)')
+        .argument('<action>', 'Action (index|search|impact|deps|complexity)')
         .argument('[target]', 'Target path or query')
         .option('--depth <depth>', 'Analysis depth', '3')
         .option('--include-tests', 'Include test files')
+        .option('--incremental', 'Incremental indexing (index action only)')
+        .option('--git-since <ref>', 'Index changes since git ref (index action only)')
         .option('-F, --format <format>', 'Output format (text|json)', 'text')
         .option('-o, --output <path>', 'Write output to file')
+        .addHelpText('after', `
+Examples:
+  aqe code index src/                  Index source files into knowledge graph
+  aqe code index src/ --incremental    Incremental index (only changed files)
+  aqe code index . --git-since HEAD~5  Index files changed in last 5 commits
+  aqe code search "authentication"     Semantic code search
+  aqe code impact src/auth/            Analyze change impact
+  aqe code deps src/                   Map dependencies
+  aqe code complexity src/             Analyze code complexity metrics
+`)
         .action(async (action, target, options) => {
         if (!await ensureInitialized())
             return;
@@ -27,17 +39,47 @@ export function createCodeCommand(context, cleanupAndExit, ensureInitialized) {
             }
             const path = await import('path');
             const format = (options.format || 'text');
+            const parsedDepth = parseInt(options.depth);
+            if (isNaN(parsedDepth) || parsedDepth < 1) {
+                console.log(chalk.red(`Invalid --depth value: "${options.depth}" (must be a positive integer)`));
+                return;
+            }
             if (action === 'index') {
-                console.log(chalk.blue(`\n Indexing codebase at ${target || '.'}...\n`));
+                const incremental = options.incremental || false;
+                const gitSince = options.gitSince;
+                const label = incremental ? 'Incrementally indexing' : 'Indexing';
+                console.log(chalk.blue(`\n ${label} codebase at ${target || '.'}${gitSince ? ` (since ${gitSince})` : ''}...\n`));
                 const targetPath = path.resolve(target || '.');
-                // Fix #280: Use shared file discovery supporting all languages
-                const paths = walkSourceFiles(targetPath, {
-                    includeTests: options.includeTests || false,
-                });
+                let paths;
+                if (gitSince) {
+                    // Use git diff to find changed files since the ref
+                    // SEC: Use execFileSync with array args to prevent shell injection (CWE-78)
+                    const { execFileSync } = await import('child_process');
+                    try {
+                        const diffOutput = execFileSync('git', ['diff', '--name-only', '--diff-filter=ACMR', gitSince, '--', targetPath], { encoding: 'utf-8', cwd: process.cwd() }).trim();
+                        paths = diffOutput
+                            ? diffOutput.split('\n')
+                                .filter(f => SOURCE_EXTENSIONS.has(path.extname(f)))
+                                .map(f => path.resolve(f))
+                            : [];
+                    }
+                    catch {
+                        console.log(chalk.yellow(`  Warning: git diff failed for ref "${gitSince}", falling back to full scan`));
+                        paths = walkSourceFiles(targetPath, {
+                            includeTests: options.includeTests || false,
+                        });
+                    }
+                }
+                else {
+                    // Fix #280: Use shared file discovery supporting all languages
+                    paths = walkSourceFiles(targetPath, {
+                        includeTests: options.includeTests || false,
+                    });
+                }
                 console.log(chalk.gray(`  Found ${paths.length} files to index...\n`));
                 const result = await codeAPI.index({
                     paths,
-                    incremental: false,
+                    incremental,
                     includeTests: options.includeTests || false,
                 });
                 if (result.success && result.value) {
@@ -101,7 +143,7 @@ export function createCodeCommand(context, cleanupAndExit, ensureInitialized) {
                 const changedFiles = walkSourceFiles(targetPath, { maxDepth: 2 }).slice(0, 10);
                 const result = await codeAPI.analyzeImpact({
                     changedFiles,
-                    depth: parseInt(options.depth),
+                    depth: parsedDepth,
                     includeTests: options.includeTests || false,
                 });
                 if (result.success && result.value) {
@@ -151,7 +193,7 @@ export function createCodeCommand(context, cleanupAndExit, ensureInitialized) {
                 const result = await codeAPI.mapDependencies({
                     files,
                     direction: 'both',
-                    depth: parseInt(options.depth),
+                    depth: parsedDepth,
                 });
                 if (result.success && result.value) {
                     const deps = result.value;
@@ -184,9 +226,105 @@ export function createCodeCommand(context, cleanupAndExit, ensureInitialized) {
                     console.log(chalk.red(`Failed: ${result.error?.message || 'Unknown error'}`));
                 }
             }
+            else if (action === 'complexity') {
+                console.log(chalk.blue(`\n Analyzing complexity for ${target || '.'}...\n`));
+                const targetPath = path.resolve(target || '.');
+                const files = walkSourceFiles(targetPath, {
+                    includeTests: options.includeTests || false,
+                    maxDepth: 3,
+                }).slice(0, 50);
+                if (files.length === 0) {
+                    console.log(chalk.yellow('  No source files found'));
+                    return await cleanupAndExit(0);
+                }
+                const fs = await import('fs');
+                const analyzer = typeof codeAPI.getSemanticAnalyzer === 'function'
+                    ? codeAPI.getSemanticAnalyzer()
+                    : null;
+                if (!analyzer) {
+                    console.log(chalk.red('Semantic analyzer not available — ensure fleet is initialized'));
+                    return await cleanupAndExit(1);
+                }
+                // Analyze files in batches of 8 for concurrency
+                const BATCH_SIZE = 8;
+                const results = [];
+                for (let i = 0; i < files.length; i += BATCH_SIZE) {
+                    const batch = files.slice(i, i + BATCH_SIZE);
+                    const batchResults = await Promise.all(batch.map(async (file) => {
+                        try {
+                            const content = fs.readFileSync(file, 'utf-8');
+                            const analysisResult = await analyzer.analyze(content);
+                            if (analysisResult.success && analysisResult.value) {
+                                const a = analysisResult.value;
+                                return {
+                                    file,
+                                    cyclomatic: a.complexity.cyclomatic,
+                                    cognitive: a.complexity.cognitive,
+                                    halstead: a.complexity.halstead,
+                                    suggestions: a.suggestions,
+                                };
+                            }
+                        }
+                        catch {
+                            // Skip files that can't be read/analyzed
+                        }
+                        return null;
+                    }));
+                    for (const r of batchResults) {
+                        if (r)
+                            results.push(r);
+                    }
+                }
+                // Sort by cyclomatic complexity descending
+                results.sort((a, b) => b.cyclomatic - a.cyclomatic);
+                // Compute aggregates
+                const totalCyclomatic = results.reduce((s, r) => s + r.cyclomatic, 0);
+                const avgCyclomatic = results.length > 0 ? totalCyclomatic / results.length : 0;
+                const maxCyclomatic = results.length > 0 ? results[0].cyclomatic : 0;
+                const totalBugs = results.reduce((s, r) => s + r.halstead.bugs, 0);
+                const highComplexity = results.filter(r => r.cyclomatic > 10).length;
+                if (format === 'json') {
+                    writeOutput(toJSON({
+                        filesAnalyzed: results.length,
+                        aggregate: {
+                            totalCyclomatic,
+                            avgCyclomatic: Math.round(avgCyclomatic * 100) / 100,
+                            maxCyclomatic,
+                            estimatedBugs: Math.round(totalBugs * 1000) / 1000,
+                            highComplexityFiles: highComplexity,
+                        },
+                        files: results,
+                    }), options.output);
+                }
+                else {
+                    console.log(chalk.cyan('  Aggregate Metrics:'));
+                    console.log(`    Files analyzed:       ${chalk.white(results.length)}`);
+                    console.log(`    Avg cyclomatic:       ${chalk.yellow(avgCyclomatic.toFixed(2))}`);
+                    console.log(`    Max cyclomatic:       ${maxCyclomatic > 20 ? chalk.red(maxCyclomatic) : maxCyclomatic > 10 ? chalk.yellow(maxCyclomatic) : chalk.green(maxCyclomatic)}`);
+                    console.log(`    Estimated bugs:       ${chalk.yellow(totalBugs.toFixed(3))}`);
+                    console.log(`    High complexity (>10): ${highComplexity > 0 ? chalk.red(highComplexity) : chalk.green(highComplexity)}`);
+                    // Show top hotspots
+                    const hotspots = results.filter(r => r.cyclomatic > 5).slice(0, 10);
+                    if (hotspots.length > 0) {
+                        console.log(chalk.cyan('\n  Complexity Hotspots:'));
+                        for (const h of hotspots) {
+                            const filePath = h.file.replace(process.cwd() + '/', '');
+                            const cyclColor = h.cyclomatic > 20 ? chalk.red : h.cyclomatic > 10 ? chalk.yellow : chalk.white;
+                            console.log(`    ${chalk.white(filePath)}`);
+                            console.log(chalk.gray(`      Cyclomatic: ${cyclColor(h.cyclomatic)}  Cognitive: ${h.cognitive}  Halstead bugs: ${h.halstead.bugs}`));
+                            if (h.suggestions.length > 0) {
+                                console.log(chalk.gray(`      Suggestion: ${h.suggestions[0]}`));
+                            }
+                        }
+                    }
+                    if (highComplexity === 0) {
+                        console.log(chalk.green('\n  All files within acceptable complexity thresholds'));
+                    }
+                }
+            }
             else {
                 console.log(chalk.red(`\nUnknown action: ${action}`));
-                console.log(chalk.gray('  Available: index, search, impact, deps\n'));
+                console.log(chalk.gray('  Available: index, search, impact, deps, complexity\n'));
                 await cleanupAndExit(1);
             }
             console.log('');

package/dist/cli/commands/init.js

@@ -41,7 +41,8 @@ export function createInitCommand() {
         .option('--with-codex', 'Include OpenAI Codex CLI MCP config and AGENTS.md')
         .option('--with-windsurf', 'Include Windsurf MCP config and rules')
         .option('--with-continuedev', 'Include Continue.dev MCP config and rules')
-        .option('--with-mcp', 'Include MCP server config in .mcp.json (opt-in — CLI works without MCP)')
+        .option('--no-mcp', 'Skip MCP server config (MCP is enabled by default)')
+        .option('--with-mcp', 'Enable MCP server config (default — kept for backward compatibility)')
         .option('--with-all-platforms', 'Include all coding agent platform configurations')
         .option('--with-claude-flow', 'Force Claude Flow integration setup')
         .option('--skip-claude-flow', 'Skip Claude Flow integration')
@@ -114,7 +115,7 @@ async function runInit(options) {
         withCodex: options.withCodex,
         withWindsurf: options.withWindsurf,
         withContinueDev: options.withContinuedev,
-        withMcp: options.withMcp,
+        noMcp: options.noMcp && !options.withMcp,
         noGovernance: options.noGovernance,
     });
     // Run initialization

package/dist/cli/commands/ruvector-commands.js

@@ -50,6 +50,23 @@ const FLAG_DESCRIPTIONS = {
     useDAGAttention: 'DAG attention for test scheduling (Task 4.2)',
     useCoherenceActionGate: 'Coherence-gated agent actions (ADR-083, Task 3.2)',
     useReasoningQEC: 'Reasoning QEC error correction (Task 4.5)',
+    // Phase 5 (ADR-087)
+    useHDCFingerprinting: 'HDC pattern fingerprinting (R1, ADR-087)',
+    useCusumDriftDetection: 'CUSUM drift detection (R2, ADR-087)',
+    useDeltaEventSourcing: 'Delta event sourcing (R3, ADR-087)',
+    useEwcPlusPlusRegularization: 'EWC++ regularization (ADR-087)',
+    // Phase 5 Milestone 2 (ADR-087)
+    useGraphMAEEmbeddings: 'GraphMAE self-supervised embeddings (R4, ADR-087)',
+    useHopfieldMemory: 'Modern Hopfield memory (R5, ADR-087)',
+    useColdTierGNN: 'Cold-tier GNN training (R6, ADR-087)',
+    // Phase 5 Milestone 3 (ADR-087)
+    useMetaLearningEnhancements: 'Meta-learning enhancements (R7, ADR-087)',
+    useSublinearSolver: 'Sublinear PageRank solver (R8, ADR-087)',
+    useSpectralSparsification: 'Spectral graph sparsification (R9, ADR-087)',
+    useReservoirReplay: 'Reservoir replay with coherence gating (R10, ADR-087)',
+    // Phase 5 Milestone 4 (ADR-087)
+    useEpropOnlineLearning: 'E-prop online learning, RL algorithm #10 (R11, ADR-087)',
+    useGrangerCausality: 'Granger causality for test failure prediction (R12, ADR-087)',
 };
 const PROFILES = {
     performance: {

package/dist/cli/handlers/init-handler.d.ts

@@ -40,6 +40,7 @@ interface InitOptions {
     withWindsurf?: boolean;
     withContinuedev?: boolean;
     withAllPlatforms?: boolean;
+    noMcp?: boolean;
     withMcp?: boolean;
     withClaudeFlow?: boolean;
     skipClaudeFlow?: boolean;

package/dist/cli/handlers/init-handler.js

@@ -49,7 +49,8 @@ export class InitHandler {
             .option('--with-codex', 'Include OpenAI Codex CLI MCP config and AGENTS.md')
             .option('--with-windsurf', 'Include Windsurf MCP config and rules')
             .option('--with-continuedev', 'Include Continue.dev MCP config and rules')
-            .option('--with-mcp', 'Include MCP server config in .mcp.json (opt-in — CLI works without MCP)')
+            .option('--no-mcp', 'Skip MCP server config (MCP is enabled by default)')
+            .option('--with-mcp', 'Enable MCP server config (default — kept for backward compatibility)')
             .option('--with-all-platforms', 'Include all coding agent platform configurations')
             .option('--auto-migrate', 'Automatically migrate from v2 if detected')
             .option('--with-claude-flow', 'Force Claude Flow integration setup')
@@ -115,7 +116,7 @@ export class InitHandler {
             withCodex: options.withCodex,
             withWindsurf: options.withWindsurf,
             withContinueDev: options.withContinuedev,
-            withMcp: options.withMcp,
+            noMcp: options.noMcp && !options.withMcp,
             noGovernance: options.noGovernance,
         });
         console.log(chalk.white('  Analyzing project...\n'));
@@ -175,10 +176,9 @@ export class InitHandler {
             console.log(chalk.gray('  1. Run tests: aqe test <path>'));
             console.log(chalk.gray('  2. Check coverage: aqe coverage <path>'));
             console.log(chalk.gray('  3. Check status: aqe status'));
-            if (!result.summary.mcpConfigured) {
-                console.log(chalk.gray('\n  Optional — enable MCP server for richer agent integration:'));
-                console.log(chalk.gray('    aqe init --with-mcp'));
-                console.log(chalk.gray('    # or manually: claude mcp add aqe -- aqe-mcp\n'));
+            if (result.summary.mcpConfigured) {
+                console.log(chalk.gray('\n  MCP server configured in .mcp.json'));
+                console.log(chalk.gray('    Use --no-mcp to skip MCP setup if using CLI only\n'));
             }
         }
         else {
@@ -230,10 +230,9 @@ export class InitHandler {
             console.log(chalk.gray('  1. Run tests: aqe test <path>'));
             console.log(chalk.gray('  2. Check coverage: aqe coverage <path>'));
             console.log(chalk.gray('  3. Check status: aqe status'));
-            if (!result.summary.mcpConfigured) {
-                console.log(chalk.gray('\n  Optional — enable MCP server for richer agent integration:'));
-                console.log(chalk.gray('    aqe init --with-mcp'));
-                console.log(chalk.gray('    # or manually: claude mcp add aqe -- aqe-mcp\n'));
+            if (result.summary.mcpConfigured) {
+                console.log(chalk.gray('\n  MCP server configured in .mcp.json'));
+                console.log(chalk.gray('    Use --no-mcp to skip MCP setup if using CLI only\n'));
             }
         }
         else {
@@ -338,9 +337,15 @@ Options:
   --auto-migrate             Automatically migrate from v2 if detected
   --with-claude-flow         Force Claude Flow integration setup
   --skip-claude-flow         Skip Claude Flow integration
+  --no-mcp                   Skip MCP server config (MCP is enabled by default)
   --no-governance            Skip governance configuration (ADR-058)
   --modular                  Use new modular init system
 
+MCP Server:
+  MCP server configuration is ENABLED BY DEFAULT. It writes .mcp.json
+  at the project root so Claude Code auto-discovers the AQE MCP server.
+  Use --no-mcp to skip if you only want CLI commands.
+
 Governance:
   Governance is ENABLED BY DEFAULT. It installs .claude/guidance/ with:
   - constitution.md: 7 unbreakable QE invariants

package/dist/cli/utils/file-discovery.d.ts

@@ -6,6 +6,7 @@
  *
  * Fixes #280: CLI commands previously only found .ts files.
  */
+export declare const SOURCE_EXTENSIONS: Set<string>;
 export interface WalkOptions {
     /** Maximum directory depth (default: 6) */
     maxDepth?: number;

package/dist/cli/utils/file-discovery.js

@@ -11,7 +11,7 @@ import { join, extname } from 'path';
 // ============================================================================
 // Source File Extensions by Language
 // ============================================================================
-const SOURCE_EXTENSIONS = new Set([
+export const SOURCE_EXTENSIONS = new Set([
     // JavaScript / TypeScript
     '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
     // Python

package/dist/domains/code-intelligence/coordinator-gnn.d.ts

@@ -12,6 +12,13 @@ export declare function initializeGNNIndex(domainKey: string): QEGNNEmbeddingInd
  * Index code embeddings in GNN for fast similarity search
  */
 export declare function indexCodeEmbeddings(gnnIndex: QEGNNEmbeddingIndex, fileReader: FileReader, paths: string[]): Promise<void>;
+/**
+ * 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 declare function generateGraphMAEEmbeddings(fileReader: FileReader, paths: string[]): Promise<Map<string, number[]>>;
 /**
  * Generate code embedding using semantic features
  */
@@ -34,6 +41,20 @@ export declare function mergeSearchResults(semanticResults: SearchResult[], gnnR
     file: string;
     similarity: number;
 }>): SearchResult[];
+/**
+ * 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 declare function trainWithColdTier(nodeFeatures: Map<number, Float32Array>, adjacency: Map<number, number[]>, options?: {
+    hotsetSize?: number;
+    epochs?: number;
+    hiddenDim?: number;
+}): {
+    embeddings: Map<number, Float32Array>;
+    loss: number;
+    usedColdTier: boolean;
+};
 /**
  * Simple hash function for strings
  */

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);