agentic-qe 3.8.8 → 3.8.9

package/dist/domains/coverage-analysis/services/coverage-parser.js

@@ -5,6 +5,12 @@
  * - LCOV format (from Istanbul, nyc, c8)
  * - Cobertura XML format
  * - JSON format (Istanbul/vitest)
+ * - JaCoCo XML format (Java/Kotlin)
+ * - dotcover XML format (C#/.NET)
+ * - Tarpaulin JSON format (Rust)
+ * - Go cover text format (Go)
+ * - Kover XML format (Kotlin/JVM)
+ * - xcresult JSON format (Swift/iOS)
  *
  * This is NOT a simulation - it reads and parses real coverage data.
  *
@@ -319,29 +325,560 @@ export async function parseJSONCoverage(jsonPath, projectRoot) {
     };
 }
 // ============================================================================
+// JaCoCo XML Parser (Java/Kotlin)
+// ============================================================================
+/**
+ * Parse JaCoCo XML coverage data.
+ *
+ * JaCoCo XML structure:
+ *   <report><package><class><method><counter type="LINE" missed="X" covered="Y"/></method></class></package></report>
+ */
+export async function parseJaCoCo(xmlPath, projectRoot) {
+    const content = await fs.readFile(xmlPath, 'utf-8');
+    return parseJaCoCoContent(content, projectRoot || path.dirname(xmlPath));
+}
+export function parseJaCoCoContent(content, projectRoot) {
+    const files = new Map();
+    // Parse <package> blocks
+    const packagePattern = /<package\s+name="([^"]*)">([\s\S]*?)<\/package>/g;
+    let pkgMatch;
+    while ((pkgMatch = packagePattern.exec(content)) !== null) {
+        const pkgName = pkgMatch[1].replace(/\//g, path.sep);
+        const pkgBody = pkgMatch[2];
+        // Parse <sourcefile> blocks within package
+        const sfPattern = /<sourcefile\s+name="([^"]*)">([\s\S]*?)<\/sourcefile>/g;
+        let sfMatch;
+        while ((sfMatch = sfPattern.exec(pkgBody)) !== null) {
+            const fileName = sfMatch[1];
+            const sfBody = sfMatch[2];
+            const filePath = path.join(projectRoot, pkgName, fileName);
+            // Parse <counter> elements
+            const counters = parseJaCoCoCounters(sfBody);
+            const lineDetails = new Map();
+            // Parse <line> elements for detailed line data
+            const linePattern = /<line\s+nr="(\d+)"\s+mi="(\d+)"\s+ci="(\d+)"/g;
+            let lineMatch;
+            while ((lineMatch = linePattern.exec(sfBody)) !== null) {
+                const lineNum = parseInt(lineMatch[1], 10);
+                const ci = parseInt(lineMatch[3], 10);
+                lineDetails.set(lineNum, ci);
+            }
+            const uncoveredLines = Array.from(lineDetails.entries())
+                .filter(([, hits]) => hits === 0)
+                .map(([line]) => line)
+                .sort((a, b) => a - b);
+            files.set(filePath, {
+                path: filePath,
+                relativePath: path.join(pkgName, fileName),
+                lines: {
+                    total: counters.LINE.total,
+                    covered: counters.LINE.covered,
+                    percentage: counters.LINE.total > 0 ? (counters.LINE.covered / counters.LINE.total) * 100 : 0,
+                    details: lineDetails,
+                    uncoveredLines,
+                },
+                branches: {
+                    total: counters.BRANCH.total,
+                    covered: counters.BRANCH.covered,
+                    percentage: counters.BRANCH.total > 0 ? (counters.BRANCH.covered / counters.BRANCH.total) * 100 : 0,
+                    uncoveredBranches: [],
+                },
+                functions: {
+                    total: counters.METHOD.total,
+                    covered: counters.METHOD.covered,
+                    percentage: counters.METHOD.total > 0 ? (counters.METHOD.covered / counters.METHOD.total) * 100 : 0,
+                    details: [],
+                    uncoveredFunctions: [],
+                },
+                statements: {
+                    total: counters.INSTRUCTION.total,
+                    covered: counters.INSTRUCTION.covered,
+                    percentage: counters.INSTRUCTION.total > 0 ? (counters.INSTRUCTION.covered / counters.INSTRUCTION.total) * 100 : 0,
+                },
+                coveragePercentage: calculateOverallPercentage(counters.LINE.covered, counters.LINE.total, counters.BRANCH.covered, counters.BRANCH.total),
+            });
+        }
+    }
+    return {
+        timestamp: new Date(),
+        format: 'jacoco',
+        language: 'java',
+        files,
+        summary: calculateSummary(files),
+    };
+}
+function parseJaCoCoCounters(xml) {
+    const result = {
+        LINE: { covered: 0, total: 0 },
+        BRANCH: { covered: 0, total: 0 },
+        METHOD: { covered: 0, total: 0 },
+        INSTRUCTION: { covered: 0, total: 0 },
+    };
+    const counterPattern = /<counter\s+type="(\w+)"\s+missed="(\d+)"\s+covered="(\d+)"\s*\/>/g;
+    let m;
+    while ((m = counterPattern.exec(xml)) !== null) {
+        const type = m[1];
+        const missed = parseInt(m[2], 10);
+        const covered = parseInt(m[3], 10);
+        if (result[type]) {
+            result[type].covered += covered;
+            result[type].total += missed + covered;
+        }
+    }
+    return result;
+}
+// ============================================================================
+// dotcover XML Parser (C#/.NET)
+// ============================================================================
+/**
+ * Parse dotcover XML coverage data.
+ *
+ * dotcover XML structure:
+ *   <Root CoveredStatements="X" TotalStatements="Y"><Assembly><Namespace><Type><Member Statement="..."/></Type></Namespace></Assembly></Root>
+ */
+export async function parseDotcover(xmlPath, projectRoot) {
+    const content = await fs.readFile(xmlPath, 'utf-8');
+    return parseDotcoverContent(content, projectRoot || path.dirname(xmlPath));
+}
+export function parseDotcoverContent(content, projectRoot) {
+    const files = new Map();
+    // Parse <File> elements to build file path index
+    const fileIndex = new Map();
+    const filePattern = /<File\s+Index="(\d+)"\s+Name="([^"]*)"\s*\/>/g;
+    let fm;
+    while ((fm = filePattern.exec(content)) !== null) {
+        fileIndex.set(fm[1], fm[2]);
+    }
+    // Parse <Statement> elements to build per-file coverage
+    const stmtPattern = /<Statement\s+FileIndex="(\d+)"\s+Line="(\d+)"\s+Column="\d+"\s+EndLine="\d+"\s+EndColumn="\d+"\s+Covered="(\w+)"\s*\/>/g;
+    const fileData = new Map();
+    let sm;
+    while ((sm = stmtPattern.exec(content)) !== null) {
+        const fileIdx = sm[1];
+        const lineNum = parseInt(sm[2], 10);
+        const isCovered = sm[3] === 'True';
+        const filePath = fileIndex.get(fileIdx) || `file-${fileIdx}`;
+        if (!fileData.has(filePath)) {
+            fileData.set(filePath, { lineDetails: new Map(), total: 0, covered: 0 });
+        }
+        const data = fileData.get(filePath);
+        data.lineDetails.set(lineNum, isCovered ? 1 : 0);
+        data.total++;
+        if (isCovered)
+            data.covered++;
+    }
+    // If no Statement elements found, parse from CoveredStatements/TotalStatements attributes
+    if (fileData.size === 0) {
+        const rootPattern = /CoveredStatements="(\d+)"\s+TotalStatements="(\d+)"/;
+        const rootMatch = rootPattern.exec(content);
+        if (rootMatch) {
+            const covered = parseInt(rootMatch[1], 10);
+            const total = parseInt(rootMatch[2], 10);
+            const filePath = path.join(projectRoot, 'aggregate');
+            files.set(filePath, {
+                path: filePath,
+                relativePath: 'aggregate',
+                lines: { total, covered, percentage: total > 0 ? (covered / total) * 100 : 0, details: new Map(), uncoveredLines: [] },
+                branches: { total: 0, covered: 0, percentage: 0, uncoveredBranches: [] },
+                functions: { total: 0, covered: 0, percentage: 0, details: [], uncoveredFunctions: [] },
+                statements: { total, covered, percentage: total > 0 ? (covered / total) * 100 : 0 },
+                coveragePercentage: total > 0 ? (covered / total) * 100 : 0,
+            });
+        }
+    }
+    for (const [filePath, data] of fileData.entries()) {
+        const uncoveredLines = Array.from(data.lineDetails.entries())
+            .filter(([, hits]) => hits === 0)
+            .map(([line]) => line)
+            .sort((a, b) => a - b);
+        files.set(filePath, {
+            path: filePath,
+            relativePath: path.relative(projectRoot, filePath),
+            lines: {
+                total: data.lineDetails.size,
+                covered: Array.from(data.lineDetails.values()).filter(h => h > 0).length,
+                percentage: data.lineDetails.size > 0 ? (Array.from(data.lineDetails.values()).filter(h => h > 0).length / data.lineDetails.size) * 100 : 0,
+                details: data.lineDetails,
+                uncoveredLines,
+            },
+            branches: { total: 0, covered: 0, percentage: 0, uncoveredBranches: [] },
+            functions: { total: 0, covered: 0, percentage: 0, details: [], uncoveredFunctions: [] },
+            statements: {
+                total: data.total,
+                covered: data.covered,
+                percentage: data.total > 0 ? (data.covered / data.total) * 100 : 0,
+            },
+            coveragePercentage: data.total > 0 ? (data.covered / data.total) * 100 : 0,
+        });
+    }
+    return {
+        timestamp: new Date(),
+        format: 'dotcover',
+        language: 'csharp',
+        files,
+        summary: calculateSummary(files),
+    };
+}
+// ============================================================================
+// Tarpaulin JSON Parser (Rust)
+// ============================================================================
+/**
+ * Parse Tarpaulin JSON coverage data.
+ *
+ * Tarpaulin JSON structure (--output-dir with --out Json):
+ *   { "files": [ { "path": "...", "content": "...", "traces": [ { "line": N, "stats": { "Line": N } } ] } ] }
+ *
+ * Also handles tarpaulin LCOV output by delegating to parseLCOVContent.
+ */
+export async function parseTarpaulin(filePath, projectRoot) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    const root = projectRoot || path.dirname(filePath);
+    // If it looks like LCOV, delegate
+    if (content.includes('SF:') && content.includes('end_of_record')) {
+        const report = parseLCOVContent(content, root);
+        report.format = 'tarpaulin';
+        report.language = 'rust';
+        return report;
+    }
+    return parseTarpaulinContent(content, root);
+}
+export function parseTarpaulinContent(content, projectRoot) {
+    const files = new Map();
+    const data = safeJsonParse(content);
+    for (const fileEntry of data?.files || []) {
+        const filePath = fileEntry.path || '';
+        const lineDetails = new Map();
+        let linesTotal = 0;
+        let linesCovered = 0;
+        for (const trace of fileEntry.traces || []) {
+            const lineNum = trace.line;
+            const hits = trace.stats?.Line ?? (trace.stats?.line ?? 0);
+            if (typeof lineNum === 'number') {
+                lineDetails.set(lineNum, hits);
+                linesTotal++;
+                if (hits > 0)
+                    linesCovered++;
+            }
+        }
+        const uncoveredLines = Array.from(lineDetails.entries())
+            .filter(([, hits]) => hits === 0)
+            .map(([line]) => line)
+            .sort((a, b) => a - b);
+        files.set(filePath, {
+            path: filePath,
+            relativePath: path.relative(projectRoot, filePath),
+            lines: {
+                total: linesTotal,
+                covered: linesCovered,
+                percentage: linesTotal > 0 ? (linesCovered / linesTotal) * 100 : 0,
+                details: lineDetails,
+                uncoveredLines,
+            },
+            branches: { total: 0, covered: 0, percentage: 0, uncoveredBranches: [] },
+            functions: { total: 0, covered: 0, percentage: 0, details: [], uncoveredFunctions: [] },
+            statements: {
+                total: linesTotal,
+                covered: linesCovered,
+                percentage: linesTotal > 0 ? (linesCovered / linesTotal) * 100 : 0,
+            },
+            coveragePercentage: linesTotal > 0 ? (linesCovered / linesTotal) * 100 : 0,
+        });
+    }
+    return {
+        timestamp: new Date(),
+        format: 'tarpaulin',
+        language: 'rust',
+        files,
+        summary: calculateSummary(files),
+    };
+}
+// ============================================================================
+// Go cover Parser
+// ============================================================================
+/**
+ * Parse Go coverage profile text format.
+ *
+ * Format:
+ *   mode: set|count|atomic
+ *   pkg/file.go:startLine.startCol,endLine.endCol numStatements count
+ */
+export async function parseGoCover(coverPath, projectRoot) {
+    const content = await fs.readFile(coverPath, 'utf-8');
+    return parseGoCoverContent(content, projectRoot || path.dirname(coverPath));
+}
+export function parseGoCoverContent(content, projectRoot) {
+    const files = new Map();
+    const fileData = new Map();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('mode:'))
+            continue;
+        // Format: file:startLine.startCol,endLine.endCol numStatements count
+        const match = trimmed.match(/^(.+):(\d+)\.\d+,(\d+)\.\d+\s+(\d+)\s+(\d+)$/);
+        if (!match)
+            continue;
+        const filePath = match[1];
+        const startLine = parseInt(match[2], 10);
+        const endLine = parseInt(match[3], 10);
+        const numStmts = parseInt(match[4], 10);
+        const count = parseInt(match[5], 10);
+        if (!fileData.has(filePath)) {
+            fileData.set(filePath, { lineDetails: new Map(), stmtTotal: 0, stmtCovered: 0 });
+        }
+        const data = fileData.get(filePath);
+        // Mark each line in the range
+        for (let l = startLine; l <= endLine; l++) {
+            const existing = data.lineDetails.get(l) || 0;
+            data.lineDetails.set(l, existing + count);
+        }
+        data.stmtTotal += numStmts;
+        if (count > 0)
+            data.stmtCovered += numStmts;
+    }
+    for (const [filePath, data] of fileData.entries()) {
+        const linesTotal = data.lineDetails.size;
+        const linesCovered = Array.from(data.lineDetails.values()).filter(h => h > 0).length;
+        const uncoveredLines = Array.from(data.lineDetails.entries())
+            .filter(([, hits]) => hits === 0)
+            .map(([line]) => line)
+            .sort((a, b) => a - b);
+        files.set(filePath, {
+            path: filePath,
+            relativePath: path.relative(projectRoot, filePath),
+            lines: {
+                total: linesTotal,
+                covered: linesCovered,
+                percentage: linesTotal > 0 ? (linesCovered / linesTotal) * 100 : 0,
+                details: data.lineDetails,
+                uncoveredLines,
+            },
+            branches: { total: 0, covered: 0, percentage: 0, uncoveredBranches: [] },
+            functions: { total: 0, covered: 0, percentage: 0, details: [], uncoveredFunctions: [] },
+            statements: {
+                total: data.stmtTotal,
+                covered: data.stmtCovered,
+                percentage: data.stmtTotal > 0 ? (data.stmtCovered / data.stmtTotal) * 100 : 0,
+            },
+            coveragePercentage: data.stmtTotal > 0 ? (data.stmtCovered / data.stmtTotal) * 100 : 0,
+        });
+    }
+    return {
+        timestamp: new Date(),
+        format: 'gocover',
+        language: 'go',
+        files,
+        summary: calculateSummary(files),
+    };
+}
+// ============================================================================
+// Kover XML Parser (Kotlin/JVM)
+// ============================================================================
+/**
+ * Parse Kover XML coverage data.
+ *
+ * Kover outputs JaCoCo-compatible XML. This delegates to the JaCoCo parser
+ * but sets the format and language appropriately.
+ */
+export async function parseKover(xmlPath, projectRoot) {
+    const content = await fs.readFile(xmlPath, 'utf-8');
+    const report = parseJaCoCoContent(content, projectRoot || path.dirname(xmlPath));
+    report.format = 'kover';
+    report.language = 'kotlin';
+    return report;
+}
+// ============================================================================
+// xcresult JSON Parser (Swift/iOS)
+// ============================================================================
+/**
+ * Parse xcresult coverage data exported via:
+ *   xcrun xccov view --report --json result.xcresult > coverage.json
+ *
+ * Structure:
+ *   { "targets": [ { "files": [ { "path": "...", "lineCoverage": 0.85, "coveredLines": N, "executableLines": N, "functions": [...] } ] } ] }
+ */
+export async function parseXcresult(jsonPath, projectRoot) {
+    const content = await fs.readFile(jsonPath, 'utf-8');
+    return parseXcresultContent(content, projectRoot || path.dirname(jsonPath));
+}
+export function parseXcresultContent(content, projectRoot) {
+    const files = new Map();
+    const data = safeJsonParse(content);
+    const targets = data?.targets || [];
+    for (const target of targets) {
+        for (const fileEntry of target.files || []) {
+            const filePath = fileEntry.path || '';
+            const executableLines = fileEntry.executableLines || 0;
+            const coveredLines = fileEntry.coveredLines || 0;
+            const lineCoverage = fileEntry.lineCoverage || 0;
+            // Parse function data if available
+            const functions = [];
+            let fnTotal = 0;
+            let fnCovered = 0;
+            for (const fn of fileEntry.functions || []) {
+                const hits = fn.coveredLines > 0 ? 1 : 0;
+                functions.push({
+                    name: fn.name || 'unknown',
+                    line: fn.lineNumber || 0,
+                    hits,
+                });
+                fnTotal++;
+                if (hits > 0)
+                    fnCovered++;
+            }
+            files.set(filePath, {
+                path: filePath,
+                relativePath: path.relative(projectRoot, filePath),
+                lines: {
+                    total: executableLines,
+                    covered: coveredLines,
+                    percentage: lineCoverage * 100,
+                    details: new Map(),
+                    uncoveredLines: [],
+                },
+                branches: { total: 0, covered: 0, percentage: 0, uncoveredBranches: [] },
+                functions: {
+                    total: fnTotal,
+                    covered: fnCovered,
+                    percentage: fnTotal > 0 ? (fnCovered / fnTotal) * 100 : 0,
+                    details: functions,
+                    uncoveredFunctions: functions.filter(f => f.hits === 0).map(f => f.name),
+                },
+                statements: {
+                    total: executableLines,
+                    covered: coveredLines,
+                    percentage: lineCoverage * 100,
+                },
+                coveragePercentage: lineCoverage * 100,
+            });
+        }
+    }
+    return {
+        timestamp: new Date(),
+        format: 'xcresult',
+        language: 'swift',
+        files,
+        summary: calculateSummary(files),
+    };
+}
+// ============================================================================
 // Auto-Detect Parser
 // ============================================================================
 /**
- * Auto-detect coverage format and parse accordingly
+ * Language-to-format mapping for inference when format is not specified
+ */
+const LANGUAGE_FORMAT_HINTS = {
+    java: ['jacoco', 'cobertura', 'lcov'],
+    kotlin: ['kover', 'jacoco'],
+    csharp: ['dotcover', 'cobertura'],
+    rust: ['tarpaulin', 'lcov'],
+    go: ['gocover'],
+    swift: ['xcresult'],
+    dart: ['lcov'],
+    typescript: ['lcov', 'json'],
+    javascript: ['lcov', 'json'],
+    python: ['lcov', 'cobertura', 'json'],
+};
+/**
+ * Auto-detect coverage format and parse accordingly.
+ *
+ * @param coveragePath - Path to the coverage file
+ * @param projectRoot - Project root for relative path calculation
+ * @param format - Explicit format override
+ * @param language - Language hint for format inference
  */
-export async function parseCoverage(coveragePath, projectRoot) {
+export async function parseCoverage(coveragePath, projectRoot, format, language) {
+    // If format is explicitly specified, use it directly
+    if (format) {
+        switch (format) {
+            case 'lcov': return parseLCOV(coveragePath, projectRoot);
+            case 'json': return parseJSONCoverage(coveragePath, projectRoot);
+            case 'jacoco': return parseJaCoCo(coveragePath, projectRoot);
+            case 'dotcover': return parseDotcover(coveragePath, projectRoot);
+            case 'tarpaulin': return parseTarpaulin(coveragePath, projectRoot);
+            case 'gocover': return parseGoCover(coveragePath, projectRoot);
+            case 'kover': return parseKover(coveragePath, projectRoot);
+            case 'xcresult': return parseXcresult(coveragePath, projectRoot);
+            default: break;
+        }
+    }
     const ext = path.extname(coveragePath).toLowerCase();
     const basename = path.basename(coveragePath).toLowerCase();
-    // Try to detect format
+    // Detect by filename/extension
     if (ext === '.json' || basename.includes('coverage-final')) {
         return parseJSONCoverage(coveragePath, projectRoot);
     }
     if (basename === 'lcov.info' || ext === '.info' || basename.includes('lcov')) {
         return parseLCOV(coveragePath, projectRoot);
     }
-    // Try to read and detect
+    if (basename.includes('jacoco') && ext === '.xml') {
+        return parseJaCoCo(coveragePath, projectRoot);
+    }
+    if (basename.includes('dotcover') && ext === '.xml') {
+        return parseDotcover(coveragePath, projectRoot);
+    }
+    if (basename.includes('tarpaulin')) {
+        return parseTarpaulin(coveragePath, projectRoot);
+    }
+    if (basename.includes('kover') && ext === '.xml') {
+        return parseKover(coveragePath, projectRoot);
+    }
+    if (basename.includes('coverage') && ext === '.out') {
+        return parseGoCover(coveragePath, projectRoot);
+    }
+    if (basename.includes('xcresult') || basename.includes('xccov')) {
+        return parseXcresult(coveragePath, projectRoot);
+    }
+    // Content-based detection
     const content = await fs.readFile(coveragePath, 'utf-8');
-    if (content.trim().startsWith('{')) {
+    const trimmed = content.trim();
+    if (trimmed.startsWith('{')) {
+        // Check for tarpaulin JSON structure
+        if (trimmed.includes('"files"') && trimmed.includes('"traces"')) {
+            return parseTarpaulinContent(content, projectRoot || path.dirname(coveragePath));
+        }
+        // Check for xcresult JSON structure
+        if (trimmed.includes('"targets"') && trimmed.includes('"lineCoverage"')) {
+            return parseXcresultContent(content, projectRoot || path.dirname(coveragePath));
+        }
         return parseJSONCoverage(coveragePath, projectRoot);
     }
     if (content.includes('SF:') && content.includes('end_of_record')) {
         return parseLCOV(coveragePath, projectRoot);
     }
+    // Go cover format: starts with "mode:"
+    if (trimmed.startsWith('mode:')) {
+        return parseGoCoverContent(content, projectRoot || path.dirname(coveragePath));
+    }
+    // XML-based detection
+    if (trimmed.startsWith('<?xml') || trimmed.startsWith('<')) {
+        if (content.includes('<counter type="') || content.includes('<report ')) {
+            // Differentiate JaCoCo vs Kover using language hint
+            if (language === 'kotlin') {
+                const report = parseJaCoCoContent(content, projectRoot || path.dirname(coveragePath));
+                report.format = 'kover';
+                report.language = 'kotlin';
+                return report;
+            }
+            return parseJaCoCoContent(content, projectRoot || path.dirname(coveragePath));
+        }
+        if (content.includes('CoveredStatements=') || content.includes('<Root')) {
+            return parseDotcoverContent(content, projectRoot || path.dirname(coveragePath));
+        }
+    }
+    // Language-based fallback: try the first format associated with the language
+    if (language) {
+        const langLower = language.toLowerCase();
+        const hints = LANGUAGE_FORMAT_HINTS[langLower];
+        if (hints && hints.length > 0) {
+            try {
+                return await parseCoverage(coveragePath, projectRoot, hints[0]);
+            }
+            catch {
+                // Language hint didn't help, fall through to error
+            }
+        }
+    }
     throw new Error(`Unknown coverage format: ${coveragePath}`);
 }
 /**
@@ -349,12 +886,28 @@ export async function parseCoverage(coveragePath, projectRoot) {
  */
 export async function findAndParseCoverage(searchDir, projectRoot) {
     const root = projectRoot || searchDir;
-    // Common coverage file locations
+    // Common coverage file locations (multi-language)
     const candidates = [
+        // JS/TS (Istanbul, nyc, c8, vitest)
         path.join(searchDir, 'coverage', 'lcov.info'),
         path.join(searchDir, 'coverage', 'coverage-final.json'),
         path.join(searchDir, 'lcov.info'),
         path.join(searchDir, '.nyc_output', 'coverage.json'),
+        // Java (JaCoCo)
+        path.join(searchDir, 'target', 'site', 'jacoco', 'jacoco.xml'),
+        path.join(searchDir, 'build', 'reports', 'jacoco', 'test', 'jacocoTestReport.xml'),
+        // C# (dotcover)
+        path.join(searchDir, 'dotcover-report.xml'),
+        // Rust (tarpaulin)
+        path.join(searchDir, 'tarpaulin-report.json'),
+        path.join(searchDir, 'cobertura.xml'),
+        // Go
+        path.join(searchDir, 'coverage.out'),
+        path.join(searchDir, 'cover.out'),
+        // Kotlin (Kover)
+        path.join(searchDir, 'build', 'reports', 'kover', 'report.xml'),
+        // Swift (xcresult)
+        path.join(searchDir, 'coverage.json'),
     ];
     for (const candidate of candidates) {
         try {

package/dist/governance/proof-envelope-integration.js

@@ -1,4 +1,4 @@
-import { randomUUID } from 'node:crypto';
+import { randomUUID, createHash } from 'node:crypto';
 import { safeJsonParse } from '../shared/safe-json.js';
 /**
  * Proof Envelope Integration for Agentic QE Fleet
@@ -48,17 +48,23 @@ export class ProofEnvelopeIntegration {
      *
      * @param signingKey - Key used for signing envelopes
      */
-    async initialize(signingKey = 'agentic-qe-default-key') {
+    async initialize(signingKey) {
         if (this.initialized)
             return;
         await this.kernel.initialize();
-        this.signingKey = signingKey;
+        // Derive a deterministic per-installation signing key from the project
+        // directory. This is consistent across restarts (so envelopes remain
+        // verifiable) but unique per installation (unlike a global hardcoded key).
+        // For production use, pass an explicit key managed outside the process.
+        this.signingKey = signingKey || createHash('sha256')
+            .update(`aqe-proof-envelope:${process.cwd()}`)
+            .digest('hex');
         // Try loading guidance ProofChain for parallel audit trail
         try {
             const modulePath = '@claude-flow/guidance/proof';
             const mod = await import(/* @vite-ignore */ modulePath);
             if (mod && typeof mod.createProofChain === 'function') {
-                this.guidanceProofChain = mod.createProofChain({ signingKey });
+                this.guidanceProofChain = mod.createProofChain({ signingKey: this.signingKey });
                 console.log('[ProofEnvelopeIntegration] Guidance ProofChain loaded');
             }
         }

package/dist/integrations/coherence/engines/witness-adapter.d.ts

@@ -1,11 +1,11 @@
 /**
  * Agentic QE v3 - Witness Engine Adapter
  *
- * Wraps the Prime Radiant WitnessEngine for Blake3 witness chain operations.
+ * Wraps the Prime Radiant WitnessEngine for SHA-256 witness chain operations.
  * Used for creating tamper-evident audit trails of agent decisions.
  *
- * Blake3 Witness Chains:
- * - Each decision is hashed with Blake3
+ * Witness Chains:
+ * - Each decision is hashed with SHA-256
  * - Hash includes reference to previous witness
  * - Creates immutable audit trail
  * - Enables deterministic replay
@@ -94,8 +94,8 @@ export declare class WitnessAdapter implements IWitnessAdapter {
      */
     private createFallbackEngine;
     /**
-     * Compute a hash for witness creation
-     * Uses a simple hash when crypto is not available
+     * Compute a SHA-256 hash for witness creation.
+     * Chains the previous hash into the computation for tamper-evidence.
      */
     private computeHash;
     /**