api-tests-coverage 1.0.24 → 1.0.26

package/dist/src/index.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const endpointCoverage_1 = require("./endpointCoverage");
 const parameterCoverage_1 = require("./parameterCoverage");
@@ -44,6 +45,7 @@ const errorCoverage_1 = require("./errorCoverage");
 const securityCoverage_1 = require("./securityCoverage");
 const perfResilienceCoverage_1 = require("./perfResilienceCoverage");
 const compatibilityCoverage_1 = require("./compatibilityCoverage");
+const qualityGate_1 = require("./qualityGate");
 const springCloudContractParser_1 = require("./contracts/springCloudContractParser");
 const pactBrokerClient_1 = require("./contracts/pactBrokerClient");
 const schema_1 = require("./streaming/schema");
@@ -70,11 +72,10 @@ const routeInference_1 = require("./inference/routeInference");
 const scanManifest_1 = require("./inference/scanManifest");
 const serveDashboard_1 = require("./serveDashboard");
 const unitAnalysis_1 = require("./unitAnalysis");
+const analyzeHelpers_1 = require("./analyzeHelpers");
 // Register all language AST analyzers at startup.
 // This side-effect import ensures each language module's registerAnalyzer() call runs.
 (0, astAnalysisOrchestrator_1.registerAllAnalyzers)();
-/** Keywords that indicate a test is exercising an error/failure path. */
-const ERROR_TEST_KEYWORDS = ['error', 'fail', 'throw', 'exception', 'reject', 'invalid', 'blank', 'missing'];
 const program = new commander_1.Command();
 program
     .name('api-tests-coverage-analyzer')
@@ -181,7 +182,7 @@ async function finaliseObservability(allResults, thresholds, metricsPort, servic
     // Log threshold breaches
     for (const r of allResults) {
         const t = thresholds[r.type];
-        if (t !== undefined && r.coveragePercent < t) {
+        if (t !== undefined && r.totalItems > 0 && r.coveragePercent < t) {
             (0, observability_1.logThresholdBreach)(logger, r.type, r.coveragePercent, t);
         }
     }
@@ -1562,102 +1563,64 @@ program
     .command('analyze')
     .description('Zero-config full analysis: discover project artifacts, infer missing rules/flows, compute coverage.')
     .option('--root <dir>', 'Project root to analyze (default: current working directory)')
+    .option('--spec <path>', 'Path to the current OpenAPI/Swagger spec file (auto-detected when omitted)')
+    .option('--spec-old <path>', 'Path to the previous OpenAPI/Swagger spec file for compatibility analysis')
     .option('--reports-dir <dir>', 'Directory to write reports to (default: reports/)')
     .option('--export-inferred-rules', 'Export inferred rules/flows as editable YAML files')
-    .option('--no-infer-business-rules', 'Disable business rule inference')
-    .option('--no-infer-integration-flows', 'Disable integration flow inference')
+    .option('--no-infer-business-rules', 'Disable business rule inference for this run when config would otherwise allow it')
+    .option('--no-infer-integration-flows', 'Disable integration flow inference for this run when config would otherwise allow it')
     .option('--dashboard', 'Start the coverage dashboard after analysis')
     .option('--port <port>', 'Port for the dashboard server (requires --dashboard)', parseInt)
     .option('--open', 'Open the dashboard in your browser automatically (requires --dashboard)')
     .action(async (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+    var _a, _b, _c, _d, _e, _f, _g;
     const { metricsPort, serviceName } = setupObservability();
     const logger = (0, observability_1.getLogger)();
     const configPath = program.opts()['config'];
     const analyzerCfg = (0, config_1.loadCentralConfig)(configPath);
-    const rootDir = (_a = options['root']) !== null && _a !== void 0 ? _a : process.cwd();
-    const reportsDir = (_d = (_b = options['reportsDir']) !== null && _b !== void 0 ? _b : (_c = analyzerCfg.reports) === null || _c === void 0 ? void 0 : _c.outputDir) !== null && _d !== void 0 ? _d : 'reports';
-    const doInferRules = options['inferBusinessRules'] !== false &&
-        ((_f = (_e = analyzerCfg.analysis) === null || _e === void 0 ? void 0 : _e.inferBusinessRules) !== null && _f !== void 0 ? _f : true);
-    const doInferFlows = options['inferIntegrationFlows'] !== false &&
-        ((_h = (_g = analyzerCfg.analysis) === null || _g === void 0 ? void 0 : _g.inferIntegrationFlows) !== null && _h !== void 0 ? _h : true);
-    const agnosticDisc = (_k = (_j = analyzerCfg.analysis) === null || _j === void 0 ? void 0 : _j.agnosticDiscovery) !== null && _k !== void 0 ? _k : true;
-    logger.info({ event: 'analyze_start', rootDir }, 'Starting agnostic project analysis');
-    // ── 1. Discover project artifacts ──────────────────────────────────────
+    const startedAt = Date.now();
+    const rootDir = path.resolve((_a = options['root']) !== null && _a !== void 0 ? _a : process.cwd());
+    const reportsDir = path.resolve((_d = (_b = options['reportsDir']) !== null && _b !== void 0 ? _b : (_c = analyzerCfg.reports) === null || _c === void 0 ? void 0 : _c.outputDir) !== null && _d !== void 0 ? _d : 'reports');
+    const doInferRules = ((_e = analyzerCfg.analysis) === null || _e === void 0 ? void 0 : _e.inferBusinessRules) !== false && options['inferBusinessRules'] !== false;
+    const doInferFlows = ((_f = analyzerCfg.analysis) === null || _f === void 0 ? void 0 : _f.inferIntegrationFlows) !== false && options['inferIntegrationFlows'] !== false;
+    const fsMod = fs;
+    fsMod.mkdirSync(reportsDir, { recursive: true });
+    logger.info({ event: 'analyze_start', rootDir }, 'Starting full analyze command');
     const artifacts = (0, projectDiscovery_1.discoverProject)({
         rootDir,
         generatedSourceDirs: analyzerCfg.project.generatedSourceDirs,
     });
+    const specPath = await (0, analyzeHelpers_1.detectOpenApiSpec)(rootDir, reportsDir, options['spec']);
+    if (specPath) {
+        console.log(`Auto-detected OpenAPI spec at: ${specPath}`);
+    }
     console.log('\n=== API Test Coverage Analyzer ===');
     console.log(`Project root: ${rootDir}`);
     console.log(`Languages detected: ${artifacts.languages.join(', ') || 'none'}`);
     console.log(`Frameworks detected: ${artifacts.frameworks.join(', ') || 'none'}`);
-    console.log(`API specs found: ${artifacts.specs.length}`);
     console.log(`Test files found: ${artifacts.testFiles.length}`);
     console.log(`Service files found: ${artifacts.serviceFiles.length}`);
-    if (!agnosticDisc && artifacts.specs.length === 0) {
-        console.error('\n[ERROR] No API spec found and agnosticDiscovery is disabled. Aborting.');
-        process.exitCode = 1;
-        return;
-    }
     const warnings = [];
     let inferredRulesResult = null;
     let inferredFlowsResult = null;
-    // ── 2. Business rule inference ─────────────────────────────────────────
     if (doInferRules) {
         inferredRulesResult = (0, businessRuleInference_1.inferBusinessRules)(artifacts.serviceFiles, warnings);
-        const rulesPath = (0, businessRuleInference_1.writeInferredBusinessRules)(inferredRulesResult, reportsDir);
-        console.log(`\nBusiness Rule Inference`);
-        console.log(`  Rules detected in service code: ${inferredRulesResult.rules.length}`);
-        console.log(`  Written to: ${rulesPath}`);
-        if (options['exportInferredRules']) {
-            const fsMod = require('fs');
-            const yaml = inferredRulesResult.rules.map((r) => [
-                `- id: ${r.id}`,
-                `  name: ${r.name}`,
-                `  type: ${r.type}`,
-                r.endpoint ? `  endpoint: "${r.endpoint}"` : null,
-                `  condition: "${r.condition.replace(/"/g, "'")}"`,
-                `  source: ${r.source_location}`,
-            ].filter(Boolean).join('\n')).join('\n');
-            fsMod.writeFileSync(path.join(rootDir, 'generated-business-rules.yaml'), yaml, 'utf-8');
-            console.log('  Exported: generated-business-rules.yaml');
-        }
-    }
-    // ── 3. Integration flow inference ──────────────────────────────────────
+        (0, businessRuleInference_1.writeInferredBusinessRules)(inferredRulesResult, reportsDir);
+    }
     if (doInferFlows) {
         inferredFlowsResult = (0, integrationFlowInference_1.inferIntegrationFlows)(artifacts.testFiles, warnings);
-        const flowsPath = (0, integrationFlowInference_1.writeInferredIntegrationFlows)(inferredFlowsResult, reportsDir);
-        console.log(`\nIntegration Flow Inference`);
-        console.log(`  Multi-step flows detected in tests: ${inferredFlowsResult.flows.length}`);
-        console.log(`  Written to: ${flowsPath}`);
-        if (options['exportInferredRules']) {
-            const fs = require('fs');
-            const yaml = inferredFlowsResult.flows.map((f) => [
-                `- id: ${f.id}`,
-                `  name: "${f.name}"`,
-                `  steps:`,
-                ...f.steps.map((s) => `    - { method: ${s.method}, path: "${s.path}" }`),
-            ].join('\n')).join('\n');
-            fs.writeFileSync(path.join(rootDir, 'generated-integration-flows.yaml'), yaml, 'utf-8');
-            console.log('  Exported: generated-integration-flows.yaml');
-        }
-    }
-    // ── 4. Full coverage analysis → coverage-summary.json ─────────────────
-    const allCoverageResults = [];
-    const fsMod = require('fs');
-    // When test files are explicitly discovered, use them directly.
-    // Otherwise fall back to a test-file-pattern glob (avoids scanning node_modules
-    // or the entire project tree, which can hang on large repositories).
-    const testsGlob = artifacts.testFiles.length > 0
-        ? '{' + artifacts.testFiles.join(',') + '}'
-        : path.join(rootDir, '**', '*.{test,spec}.{js,ts,jsx,tsx,mjs,cjs,py,rb}');
+        (0, integrationFlowInference_1.writeInferredIntegrationFlows)(inferredFlowsResult, reportsDir);
+    }
+    const discoveredTestsPattern = `{${artifacts.testFiles.join(',')}}`;
+    const discoveredSourcePattern = `{${artifacts.serviceFiles.join(',')}}`;
+    const testsGlob = artifacts.testFiles.length > 0 && discoveredTestsPattern.length <= 8000
+        ? discoveredTestsPattern
+        : path.join(rootDir, '**', '*.{test,spec}.{js,ts,jsx,tsx,mjs,cjs,py,rb,java,kt}');
+    const sourceGlob = artifacts.serviceFiles.length > 0 && discoveredSourcePattern.length <= 8000
+        ? discoveredSourcePattern
+        : path.join(rootDir, '**/*.{js,jsx,ts,tsx,java,kt,py,rb}');
     const detectedLanguages = artifacts.languages;
-    // Pre-compute test entries once from the discovered test files.
-    // These are reused for endpoint, error, and business-rule coverage matching
-    // (avoids multiple glob expansions which can hang on large projects).
     const TEST_DECL_RE = /\b(?:test|it)\s*\(\s*(['"`])([\s\S]*?)\1/g;
-    // Java/Kotlin JUnit: @Test followed by a method declaration
     const JAVA_TEST_RE = /@Test\b[^{]*?(?:public|protected|private|default)?\s+(?:\w+\s+)?(\w+)\s*\(\s*\)/g;
     const testEntries = artifacts.testFiles.flatMap((tf) => {
         let content = '';
@@ -1671,590 +1634,552 @@ program
         const contentLower = content.toLowerCase();
         const ext = path.extname(tf).toLowerCase();
         const isJavaLike = ext === '.java' || ext === '.kt' || ext === '.kts';
-        let m;
+        let javaMatch;
         if (isJavaLike) {
-            // Extract @Test-annotated method names; convert snake_case to spaces for keyword matching
             JAVA_TEST_RE.lastIndex = 0;
-            while ((m = JAVA_TEST_RE.exec(content)) !== null) {
-                descriptions.push(m[1].replace(/_/g, ' ').toLowerCase());
+            while ((javaMatch = JAVA_TEST_RE.exec(content)) !== null) {
+                descriptions.push(javaMatch[1].replace(/_/g, ' ').toLowerCase());
             }
         }
         else {
+            let jsMatch;
             TEST_DECL_RE.lastIndex = 0;
-            while ((m = TEST_DECL_RE.exec(content)) !== null) {
-                descriptions.push(m[2].toLowerCase());
+            while ((jsMatch = TEST_DECL_RE.exec(content)) !== null) {
+                descriptions.push(jsMatch[2].toLowerCase());
             }
         }
         return [{ file: tf, contentLower, descriptions, isJavaLike }];
     });
-    if (artifacts.specs.length > 0) {
-        for (const specPath of artifacts.specs) {
-            // ── 4a. Endpoint coverage ───────────────────────────────────────────
-            try {
-                console.log(`\nAnalyzing endpoint coverage for: ${path.basename(specPath)}`);
-                const endpoints = await (0, endpointCoverage_1.parseOpenApiSpec)(specPath);
-                const coverageMap = await (0, endpointCoverage_1.analyzeTestCoverage)(endpoints, testsGlob, detectedLanguages);
-                const report = (0, endpointCoverage_1.buildCoverageReport)(coverageMap);
-                const result = {
-                    type: 'endpoint',
-                    totalItems: report.total,
-                    coveredItems: report.covered,
-                    coveragePercent: report.percentage,
-                    details: report,
-                };
-                allCoverageResults.push(result);
-                console.log(`  ${report.covered}/${report.total} endpoints covered (${report.percentage}%)`);
-            }
-            catch (err) {
-                warnings.push(`Endpoint coverage failed for ${path.basename(specPath)}: ` +
-                    `${err instanceof Error ? err.message : String(err)}`);
-            }
-            // ── 4b. Parameter coverage ──────────────────────────────────────────
-            try {
-                const parameters = await (0, parameterCoverage_1.parseParameters)(specPath);
-                const astParamOptions = {
-                    astConfig: (_m = (_l = analyzerCfg.analysis) === null || _l === void 0 ? void 0 : _l.ast) !== null && _m !== void 0 ? _m : {},
-                    deepConfig: undefined,
-                };
-                const paramCoverages = await (0, parameterCoverage_1.analyzeParameterCoverage)(parameters, testsGlob, astParamOptions);
-                const paramReport = (0, parameterCoverage_1.buildParameterCoverageReport)(paramCoverages);
-                const paramResult = {
-                    type: 'parameter',
-                    totalItems: paramReport.totalParameters,
-                    coveredItems: paramCoverages.filter((c) => c.ratio > 0).length,
-                    coveragePercent: paramReport.averageCoverage,
-                    details: paramReport,
-                };
-                allCoverageResults.push(paramResult);
-                console.log(`  ${paramResult.coveredItems}/${paramResult.totalItems} parameters covered (${paramReport.averageCoverage}%)`);
-            }
-            catch (err) {
-                warnings.push(`Parameter coverage failed for ${path.basename(specPath)}: ` +
-                    `${err instanceof Error ? err.message : String(err)}`);
-            }
-            // ── 4c. Error scenario coverage ─────────────────────────────────────
-            try {
-                const scenarios = await (0, errorCoverage_1.parseErrorScenarios)(specPath);
-                if (scenarios.length > 0) {
-                    const astErrorOptions = {
-                        astConfig: (_p = (_o = analyzerCfg.analysis) === null || _o === void 0 ? void 0 : _o.ast) !== null && _p !== void 0 ? _p : {},
-                        deepConfig: undefined,
-                    };
-                    const errorCoverages = await (0, errorCoverage_1.analyzeErrorCoverage)(scenarios, testsGlob, astErrorOptions);
-                    const errorReport = (0, errorCoverage_1.buildErrorCoverageReport)(errorCoverages);
-                    const errorResult = {
-                        type: 'error',
-                        totalItems: errorReport.total,
-                        coveredItems: errorReport.covered,
-                        coveragePercent: errorReport.percentage,
-                        details: errorReport,
-                    };
-                    allCoverageResults.push(errorResult);
-                    console.log(`  ${errorReport.covered}/${errorReport.total} error scenarios covered (${errorReport.percentage}%)`);
-                }
-            }
-            catch (err) {
-                warnings.push(`Error coverage failed for ${path.basename(specPath)}: ` +
-                    `${err instanceof Error ? err.message : String(err)}`);
+    const loadResultCandidates = [
+        path.join(rootDir, 'load-results.json'),
+        path.join(rootDir, 'load-results.self-analysis.json'),
+        path.join(rootDir, 'reports', 'load-results.json'),
+        path.join(rootDir, 'reports', 'load-results.self-analysis.json'),
+    ].filter((candidate) => fsMod.existsSync(candidate));
+    const resilienceKeywordPattern = /\b(circuit.?breaker|retry|timeout|fallback|bulkhead)\b/i;
+    const resiliencePatternFiles = artifacts.serviceFiles.filter((filePath) => {
+        try {
+            return resilienceKeywordPattern.test(fsMod.readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            return false;
+        }
+    });
+    const performanceFilesScanned = artifacts.serviceFiles.length + loadResultCandidates.length;
+    const allCoverageResults = [];
+    const endpointResult = await (0, analyzeHelpers_1.runMetricSafe)('endpoint', { filesScanned: artifacts.serviceFiles.length, scanDurationMs: 0, detectionMethod: specPath ? 'spec-driven' : 'inferred' }, async () => {
+        const metricStartedAt = Date.now();
+        if (specPath) {
+            const endpoints = await (0, endpointCoverage_1.parseOpenApiSpec)(specPath);
+            const coverageMap = await (0, endpointCoverage_1.analyzeTestCoverage)(endpoints, testsGlob, detectedLanguages);
+            const report = (0, endpointCoverage_1.buildCoverageReport)(coverageMap);
+            (0, endpointCoverage_1.generateReports)(report, reportsDir);
+            if (report.total === 0) {
+                return (0, analyzeHelpers_1.buildNaCoverageResult)('endpoint', (0, analyzeHelpers_1.requiredNaReason)('endpoint', { filesScanned: artifacts.serviceFiles.length }), { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' }, report);
             }
+            return {
+                type: 'endpoint',
+                totalItems: report.total,
+                coveredItems: report.covered,
+                coveragePercent: report.percentage,
+                scanMeta: { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' },
+                details: report,
+            };
         }
-    }
-    else {
-        warnings.push('No API spec files found; attempting route inference for endpoint/error coverage.');
-        // ── 4a-alt. Inferred route endpoint coverage ──────────────────────────
-        try {
-            const routeResult = (0, routeInference_1.inferRoutes)(artifacts.serviceFiles, {
-                generatedSourceDirs: analyzerCfg.project.generatedSourceDirs,
-                openApiFirst: analyzerCfg.project.openApiFirst,
-            });
-            if (routeResult.routes.length > 0) {
-                const routesPath = (0, routeInference_1.writeInferredRoutes)(routeResult, reportsDir);
-                console.log(`\nRoute Inference`);
-                console.log(`  Routes detected in service code: ${routeResult.routes.length}`);
-                console.log(`  Written to: ${routesPath}`);
-                console.log(`\nAnalyzing endpoint coverage (from inferred routes)...`);
-                const endpointItems = routeResult.routes.map((route) => {
-                    var _a;
-                    const pathSegments = route.path.split('/').filter((s) => s.length > 1 && !s.startsWith(':'));
-                    const method = route.method.toLowerCase();
-                    // Leaf path segment is the most specific identifier (e.g., "comments", "favorite", "feed")
-                    const leafSegment = (_a = pathSegments[pathSegments.length - 1]) !== null && _a !== void 0 ? _a : '';
-                    const matchedTests = [];
-                    for (const { file, contentLower, descriptions } of testEntries) {
-                        let matched = false;
-                        // Priority 1: handler function name appears in test file imports/calls
-                        if (route.handlerFunction) {
-                            const fnLower = route.handlerFunction.toLowerCase();
-                            if (contentLower.includes(fnLower)) {
-                                matched = true;
-                            }
-                        }
-                        // Priority 2: test description mentions method + leaf path segment
-                        if (!matched && leafSegment.length > 2) {
-                            matched = descriptions.some((desc) => desc.includes(method) && desc.includes(leafSegment));
-                        }
-                        // Priority 3: test description mentions the exact path
-                        if (!matched && route.path.length >= 1) {
-                            matched = descriptions.some((desc) => desc.includes(route.path.toLowerCase()));
-                        }
-                        // Priority 4: test file directly calls the URL path (e.g., axios.get('/articles'))
-                        if (!matched && pathSegments.length > 0) {
-                            // Check for full path string in file (e.g., axios.get('/articles/feed'))
-                            const quotedPathPattern = new RegExp(`['"\`]${route.path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"\`]`);
-                            if (quotedPathPattern.test(contentLower)) {
-                                matched = true;
-                            }
-                        }
-                        if (matched) {
-                            matchedTests.push(path.basename(file));
-                        }
-                    }
-                    const covered = matchedTests.length > 0;
-                    return {
-                        id: `${route.method.toUpperCase()} ${route.path}`,
-                        covered,
-                        matchedTests,
-                        handler_function: route.handlerFunction,
-                        source_file: route.sourceFile,
-                        line_number: route.lineNumber,
-                    };
-                });
-                const coveredCount = endpointItems.filter((i) => i.covered).length;
-                const pct = endpointItems.length > 0 ? Math.round((coveredCount / endpointItems.length) * 100) : 0;
-                const endpointResult = {
-                    type: 'endpoint',
-                    totalItems: endpointItems.length,
-                    coveredItems: coveredCount,
-                    coveragePercent: pct,
-                    details: {
-                        total: endpointItems.length,
-                        covered: coveredCount,
-                        percentage: pct,
-                        items: endpointItems,
-                        source: 'inferred',
-                    },
-                };
-                allCoverageResults.push(endpointResult);
-                console.log(`  ${coveredCount}/${endpointItems.length} inferred routes have test coverage (${pct}%)`);
-                // ── 4c-alt. Error coverage from inferred routes + rules ──────────
-                if (inferredRulesResult && inferredRulesResult.rules.length > 0) {
-                    console.log(`\nAnalyzing error coverage (from inferred business rules)...`);
-                    const errorCandidateRules = inferredRulesResult.rules.filter((r) => r.type === 'validation' || r.type === 'business_logic');
-                    const errorItems = errorCandidateRules.map((rule) => {
-                        var _a;
-                        const matchedTestDescriptions = [];
-                        for (const { file, descriptions, isJavaLike, contentLower } of testEntries) {
-                            // Match at TEST DESCRIPTION level, not file level
-                            // Require: description contains an error indicator + at least one specific keyword
-                            const specificKws = (_a = rule.specificKeywords) !== null && _a !== void 0 ? _a : [];
-                            const matchingDescs = descriptions.filter((desc) => {
-                                const hasErrorKeyword = ERROR_TEST_KEYWORDS.some((kw) => desc.includes(kw));
-                                if (!hasErrorKeyword)
-                                    return false;
-                                // If we have specific keywords, at least one must match in the description
-                                if (specificKws.length > 0) {
-                                    return specificKws.some((kw) => desc.includes(kw.toLowerCase()));
-                                }
-                                // No specific keywords — use handler function name as fallback
-                                return true;
-                            });
-                            if (matchingDescs.length > 0) {
-                                matchedTestDescriptions.push(...matchingDescs.map((d) => `[${path.basename(file)}] ${d}`));
-                            }
-                            else if (isJavaLike) {
-                                // Java/Kotlin: test method names rarely contain exception class names.
-                                // Check file body for specific long keywords (≥8 chars, e.g. "authorization")
-                                // combined with HTTP 4xx status checks or exception throws.
-                                const specificLongKws = specificKws
-                                    .filter((k) => k.length >= 8)
-                                    .map((k) => k.toLowerCase());
-                                if (specificLongKws.length > 0 && specificLongKws.some((kw) => contentLower.includes(kw))) {
-                                    const hasErrorInContent = /\.statuscode\s*\(\s*[45]\d{2}|throw\s+new\s+\w*exception/i.test(contentLower);
-                                    if (hasErrorInContent) {
-                                        // Prefer test methods that look like error/boundary tests
-                                        const errorDescs = descriptions.filter((d) => /\b(4\d\d|error|fail|forbidden|unauthorized|invalid|exception|not.?found)\b/.test(d));
-                                        const descsToReport = errorDescs.length > 0 ? errorDescs : descriptions.slice(0, 1);
-                                        matchedTestDescriptions.push(...descsToReport.map((d) => `[${path.basename(file)}] ${d}`));
-                                    }
-                                }
-                            }
-                        }
-                        return {
-                            id: rule.id,
-                            description: rule.condition,
-                            covered: matchedTestDescriptions.length > 0,
-                            matchedTests: matchedTestDescriptions,
-                            source_location: rule.source_location,
-                            code_snippet: rule.code_snippet,
-                        };
-                    });
-                    const errorCovered = errorItems.filter((i) => i.covered).length;
-                    const errorPct = errorItems.length > 0 ? Math.round((errorCovered / errorItems.length) * 100) : 0;
-                    const errorResult = {
-                        type: 'error',
-                        totalItems: errorItems.length,
-                        coveredItems: errorCovered,
-                        coveragePercent: errorPct,
-                        details: {
-                            total: errorItems.length,
-                            covered: errorCovered,
-                            percentage: errorPct,
-                            items: errorItems,
-                            source: 'inferred',
-                        },
-                    };
-                    allCoverageResults.push(errorResult);
-                    console.log(`  ${errorCovered}/${errorItems.length} inferred error scenarios have test coverage (${errorPct}%)`);
-                }
-                // ── 4b-alt. Parameter coverage from inferred routes + body params ──
-                // Extract path parameters (e.g. ':article', ':id') and body params
-                // (e.g. 'req.body.email') from inferred routes and business rules.
-                // This populates the Parameters tab even without an OpenAPI spec.
-                console.log(`\nAnalyzing parameter coverage (from inferred routes)...`);
-                try {
-                    const paramItems = [];
-                    // Path parameters from routes
-                    const seenParamKeys = new Set();
-                    for (const epItem of endpointItems) {
-                        const route = routeResult.routes.find((r) => `${r.method.toUpperCase()} ${r.path}` === epItem.id);
-                        if (!route)
-                            continue;
-                        const pathParams = route.path.split('/').filter((s) => s.startsWith(':'));
-                        for (const param of pathParams) {
-                            const paramName = param.slice(1); // strip ':'
-                            const key = `${paramName}@${route.method.toUpperCase()}`;
-                            if (seenParamKeys.has(key))
-                                continue;
-                            seenParamKeys.add(key);
-                            paramItems.push({
-                                id: `PATH :${paramName} @ ${epItem.id}`,
-                                covered: epItem.covered, // param is covered if the route is covered
-                                matchedTests: epItem.matchedTests,
-                                param_type: 'path',
-                                source_file: route.sourceFile,
-                                line_number: route.lineNumber,
-                            });
-                        }
-                    }
-                    // Body parameters from inferred business rules (req.body.<field>)
-                    if (inferredRulesResult) {
-                        const BODY_PARAM_RE = /req\.body\.(\w+)/g;
-                        const seenBodyParams = new Set();
-                        for (const rule of inferredRulesResult.rules) {
-                            let bm;
-                            BODY_PARAM_RE.lastIndex = 0;
-                            const combinedText = `${rule.condition} ${rule.code_snippet}`;
-                            while ((bm = BODY_PARAM_RE.exec(combinedText)) !== null) {
-                                const fieldName = bm[1];
-                                const paramKey = `body_${fieldName}_${(_q = rule.endpoint) !== null && _q !== void 0 ? _q : ''}`;
-                                if (seenBodyParams.has(paramKey))
-                                    continue;
-                                seenBodyParams.add(paramKey);
-                                const endpointLabel = (_r = rule.endpoint) !== null && _r !== void 0 ? _r : 'unknown endpoint';
-                                // Match: any test description mentioning the field name
-                                const fieldNameLower = fieldName.toLowerCase();
-                                const matchedTestDescs = [];
-                                for (const { file, descriptions } of testEntries) {
-                                    const hitting = descriptions.filter((desc) => desc.includes(fieldNameLower));
-                                    if (hitting.length > 0) {
-                                        matchedTestDescs.push(...hitting.map((d) => `[${path.basename(file)}] ${d}`));
-                                    }
-                                }
-                                const srcParts = (_t = (_s = rule.source_location) === null || _s === void 0 ? void 0 : _s.split(':')) !== null && _t !== void 0 ? _t : [];
-                                const srcFile = srcParts[0];
-                                const srcLine = srcParts[1] !== undefined ? parseInt(srcParts[1], 10) : undefined;
-                                paramItems.push({
-                                    id: `BODY ${fieldName} @ ${endpointLabel}`,
-                                    covered: matchedTestDescs.length > 0,
-                                    matchedTests: matchedTestDescs,
-                                    param_type: 'body',
-                                    source_file: srcFile,
-                                    line_number: srcLine && srcLine > 0 ? srcLine : undefined,
-                                });
-                            }
-                        }
-                    }
-                    if (paramItems.length > 0) {
-                        const paramCovered = paramItems.filter((i) => i.covered).length;
-                        const paramPct = Math.round((paramCovered / paramItems.length) * 100);
-                        allCoverageResults.push({
-                            type: 'parameter',
-                            totalItems: paramItems.length,
-                            coveredItems: paramCovered,
-                            coveragePercent: paramPct,
-                            details: {
-                                total: paramItems.length,
-                                covered: paramCovered,
-                                percentage: paramPct,
-                                items: paramItems,
-                                source: 'inferred',
-                            },
-                        });
-                        console.log(`  ${paramCovered}/${paramItems.length} inferred parameters have test coverage (${paramPct}%)`);
-                    }
-                }
-                catch (paramErr) {
-                    warnings.push(`Parameter inference failed: ${paramErr instanceof Error ? paramErr.message : String(paramErr)}`);
+        const routeResult = (0, routeInference_1.inferRoutes)(artifacts.serviceFiles, {
+            generatedSourceDirs: analyzerCfg.project.generatedSourceDirs,
+            openApiFirst: analyzerCfg.project.openApiFirst,
+        });
+        (0, routeInference_1.writeInferredRoutes)(routeResult, reportsDir);
+        const endpointItems = routeResult.routes.map((route) => {
+            var _a;
+            const pathSegments = route.path.split('/').filter((segment) => segment.length > 1 && !segment.startsWith(':'));
+            const leafSegment = (_a = pathSegments[pathSegments.length - 1]) !== null && _a !== void 0 ? _a : '';
+            const method = route.method.toLowerCase();
+            const matchedTests = [];
+            for (const { file, contentLower, descriptions } of testEntries) {
+                const matched = (route.handlerFunction ? contentLower.includes(route.handlerFunction.toLowerCase()) : false) ||
+                    (leafSegment.length > 2 && descriptions.some((desc) => desc.includes(method) && desc.includes(leafSegment))) ||
+                    descriptions.some((desc) => desc.includes(route.path.toLowerCase()));
+                if (matched) {
+                    matchedTests.push(path.basename(file));
                 }
             }
-            else {
-                warnings.push('No routes detected in service files; endpoint coverage skipped.');
-            }
+            return {
+                id: `${route.method.toUpperCase()} ${route.path}`,
+                covered: matchedTests.length > 0,
+                matchedTests,
+                source_file: route.sourceFile,
+                line_number: route.lineNumber,
+            };
+        });
+        if (endpointItems.length === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('endpoint', (0, analyzeHelpers_1.requiredNaReason)('endpoint', { filesScanned: artifacts.serviceFiles.length }), { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'inferred' }, { items: [] });
+        }
+        const covered = endpointItems.filter((item) => item.covered).length;
+        const percentage = Math.round((covered / endpointItems.length) * 100);
+        return {
+            type: 'endpoint',
+            totalItems: endpointItems.length,
+            coveredItems: covered,
+            coveragePercent: percentage,
+            scanMeta: { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'inferred' },
+            details: {
+                total: endpointItems.length,
+                covered,
+                percentage,
+                items: endpointItems,
+                source: 'inferred',
+            },
+        };
+    });
+    allCoverageResults.push(endpointResult);
+    const parameterResult = await (0, analyzeHelpers_1.runMetricSafe)('parameter', { filesScanned: artifacts.serviceFiles.length, scanDurationMs: 0, detectionMethod: specPath ? 'spec-driven' : 'inferred' }, async () => {
+        var _a, _b;
+        const metricStartedAt = Date.now();
+        if (!specPath) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('parameter', (0, analyzeHelpers_1.requiredNaReason)('parameter', { routesScanned: endpointResult.totalItems }), { filesScanned: endpointResult.totalItems, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'inferred' });
         }
-        catch (err) {
-            warnings.push(`Route/error inference failed: ${err instanceof Error ? err.message : String(err)}`);
+        const parameters = await (0, parameterCoverage_1.parseParameters)(specPath);
+        const astParamOptions = {
+            astConfig: (_b = (_a = analyzerCfg.analysis) === null || _a === void 0 ? void 0 : _a.ast) !== null && _b !== void 0 ? _b : {},
+            deepConfig: undefined,
+        };
+        const coverages = await (0, parameterCoverage_1.analyzeParameterCoverage)(parameters, testsGlob, astParamOptions);
+        const report = (0, parameterCoverage_1.buildParameterCoverageReport)(coverages);
+        (0, parameterCoverage_1.generateParameterReports)(report, reportsDir);
+        if (report.totalParameters === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('parameter', (0, analyzeHelpers_1.requiredNaReason)('parameter', { routesScanned: endpointResult.totalItems }), { filesScanned: endpointResult.totalItems, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' }, report);
         }
-    }
-    // ── 4d. Business rules coverage ─────────────────────────────────────────
+        return {
+            type: 'parameter',
+            totalItems: report.totalParameters,
+            coveredItems: coverages.filter((coverage) => coverage.ratio > 0).length,
+            coveragePercent: report.averageCoverage,
+            scanMeta: { filesScanned: endpointResult.totalItems, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' },
+            details: report,
+        };
+    });
+    allCoverageResults.push(parameterResult);
     const businessRulesYaml = path.join(rootDir, 'business-rules.yaml');
-    if (fsMod.existsSync(businessRulesYaml)) {
-        // Explicit YAML takes precedence
-        try {
-            console.log(`\nAnalyzing business rules coverage...`);
+    const businessResult = await (0, analyzeHelpers_1.runMetricSafe)('business', { filesScanned: artifacts.serviceFiles.length, scanDurationMs: 0, detectionMethod: fsMod.existsSync(businessRulesYaml) ? 'spec-driven' : 'inferred' }, async () => {
+        var _a;
+        const metricStartedAt = Date.now();
+        if (fsMod.existsSync(businessRulesYaml)) {
             const rules = (0, businessCoverage_1.parseBusinessRules)(businessRulesYaml);
-            const bizCoverages = await (0, businessCoverage_1.analyzeBusinessCoverage)(rules, testsGlob);
-            const bizReport = (0, businessCoverage_1.buildBusinessCoverageReport)(bizCoverages);
-            const bizResult = {
+            const coverages = await (0, businessCoverage_1.analyzeBusinessCoverage)(rules, testsGlob);
+            const report = (0, businessCoverage_1.buildBusinessCoverageReport)(coverages);
+            (0, businessCoverage_1.generateBusinessReports)(report, reportsDir);
+            if (report.total === 0) {
+                return (0, analyzeHelpers_1.buildNaCoverageResult)('business', (0, analyzeHelpers_1.requiredNaReason)('business', { filesScanned: artifacts.serviceFiles.length }), { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' }, report);
+            }
+            return {
                 type: 'business',
-                totalItems: bizReport.total,
-                coveredItems: bizReport.covered,
-                coveragePercent: bizReport.percentage,
-                details: bizReport,
+                totalItems: report.total,
+                coveredItems: report.covered,
+                coveragePercent: report.percentage,
+                scanMeta: { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' },
+                details: report,
             };
-            allCoverageResults.push(bizResult);
-            console.log(`  ${bizReport.covered}/${bizReport.total} business rules covered (${bizReport.percentage}%)`);
         }
-        catch (err) {
-            warnings.push(`Business rules coverage failed: ${err instanceof Error ? err.message : String(err)}`);
+        const inferredRules = (_a = inferredRulesResult === null || inferredRulesResult === void 0 ? void 0 : inferredRulesResult.rules) !== null && _a !== void 0 ? _a : [];
+        if (inferredRules.length === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('business', (0, analyzeHelpers_1.requiredNaReason)('business', { filesScanned: artifacts.serviceFiles.length }), { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'inferred' }, { items: [] });
         }
-    }
-    else if (inferredRulesResult && inferredRulesResult.rules.length > 0) {
-        // Auto-inferred: use specificKeywords from rule for accurate test matching.
-        // Reuse the testEntries already computed for endpoint coverage — avoids
-        // a second glob expansion (which can be slow/hang on large projects).
-        try {
-            console.log(`\nAnalyzing business rules coverage (from inferred rules)...`);
-            const syntheticRules = inferredRulesResult.rules.map((r) => {
-                const kwSet = new Set();
-                // Use specificKeywords extracted from the condition (most accurate)
-                if (r.specificKeywords && r.specificKeywords.length > 0) {
-                    r.specificKeywords.forEach((kw) => { if (!businessRuleInference_1.KEYWORD_STOP_WORDS.has(kw))
-                        kwSet.add(kw); });
-                }
-                else {
-                    // Fallback: words from rule name only (filter stop words)
-                    r.name.toLowerCase().split(/[-_\s]+/).forEach((w) => {
-                        if (w.length > 2 && !businessRuleInference_1.KEYWORD_STOP_WORDS.has(w))
-                            kwSet.add(w);
-                    });
-                }
-                // Non-trivial path segments from endpoint
-                if (r.endpoint) {
-                    r.endpoint.toLowerCase().split(/[/.\s:]+/)
-                        .forEach((w) => { if (w.length > 2 && !/^(api|v\d)$/.test(w) && !businessRuleInference_1.KEYWORD_STOP_WORDS.has(w))
-                        kwSet.add(w); });
-                }
-                return {
-                    id: r.id,
-                    description: r.name,
-                    endpoints: r.endpoint ? [r.endpoint] : [],
-                    keywords: [...kwSet],
-                    scenarios: [],
-                };
+        const rules = inferredRules.map((rule) => {
+            var _a;
+            const kwSet = new Set();
+            ((_a = rule.specificKeywords) !== null && _a !== void 0 ? _a : []).forEach((keyword) => {
+                if (!businessRuleInference_1.KEYWORD_STOP_WORDS.has(keyword))
+                    kwSet.add(keyword.toLowerCase());
             });
-            // Match rules against the testEntries already built for endpoint coverage.
-            // This avoids a second glob expansion and is safe when there are no test files.
-            const bizCoverages = syntheticRules.map((rule) => {
-                const kwsLower = rule.keywords.map((k) => k.toLowerCase());
-                const matchedDescs = [];
-                const matchedFileSet = new Set();
-                for (const { file, descriptions, isJavaLike, contentLower } of testEntries) {
-                    const hitting = descriptions.filter((desc) => kwsLower.length > 0 && kwsLower.some((kw) => desc.includes(kw)));
-                    if (hitting.length > 0) {
-                        matchedDescs.push(...hitting);
-                        matchedFileSet.add(file);
-                    }
-                    else if (isJavaLike) {
-                        // Java/Kotlin: test method names may not contain exception class names.
-                        // Fall back to checking the file body for specific long keywords (≥8 chars).
-                        const specificLongKws = kwsLower.filter((k) => k.length >= 8);
-                        if (specificLongKws.length > 0 && specificLongKws.some((kw) => contentLower.includes(kw))) {
-                            // Prefer tests that look like error/boundary tests; otherwise include all
-                            const relevantDescs = descriptions.filter((d) => /\b(4\d\d|error|fail|forbidden|unauthorized|invalid|exception|not.?found)\b/.test(d));
-                            const descsToAdd = relevantDescs.length > 0 ? relevantDescs : descriptions;
-                            matchedDescs.push(...descsToAdd);
-                            matchedFileSet.add(file);
-                        }
-                    }
+            if (kwSet.size === 0) {
+                rule.name.toLowerCase().split(/[-_\s]+/).forEach((word) => {
+                    if (word.length > 2 && !businessRuleInference_1.KEYWORD_STOP_WORDS.has(word))
+                        kwSet.add(word);
+                });
+            }
+            return {
+                id: rule.id,
+                description: rule.name,
+                endpoints: rule.endpoint ? [rule.endpoint] : [],
+                keywords: [...kwSet],
+                scenarios: [],
+            };
+        });
+        const coverages = rules.map((rule) => {
+            const keywords = rule.keywords.map((keyword) => keyword.toLowerCase());
+            const matchedDescriptions = [];
+            const matchedFiles = new Set();
+            for (const { file, descriptions } of testEntries) {
+                const hits = descriptions.filter((description) => keywords.length > 0 && keywords.some((keyword) => description.includes(keyword)));
+                if (hits.length > 0) {
+                    hits.forEach((hit) => matchedDescriptions.push(hit));
+                    matchedFiles.add(file);
                 }
-                return {
-                    rule,
-                    covered: matchedDescs.length > 0,
-                    testFiles: [...matchedFileSet],
-                    matchedTests: matchedDescs,
-                    scenarios: [],
-                };
-            });
-            const bizReport = (0, businessCoverage_1.buildBusinessCoverageReport)(bizCoverages);
-            const bizResult = {
-                type: 'business',
-                totalItems: bizReport.total,
-                coveredItems: bizReport.covered,
-                coveragePercent: bizReport.percentage,
-                details: {
-                    ...bizReport,
-                    inferred_details: inferredRulesResult.rules.reduce((acc, r) => {
-                        acc[r.id] = {
-                            source_location: r.source_location,
-                            condition: r.condition,
-                            code_snippet: r.code_snippet,
-                            type: r.type,
-                            specificKeywords: r.specificKeywords,
+            }
+            return {
+                rule,
+                covered: matchedDescriptions.length > 0,
+                testFiles: [...matchedFiles],
+                matchedTests: matchedDescriptions,
+                scenarios: [],
+            };
+        });
+        const report = (0, businessCoverage_1.buildBusinessCoverageReport)(coverages);
+        (0, businessCoverage_1.generateBusinessReports)(report, reportsDir);
+        return {
+            type: 'business',
+            totalItems: report.total,
+            coveredItems: report.covered,
+            coveragePercent: report.percentage,
+            scanMeta: { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'inferred' },
+            details: report.total === 0
+                ? { items: [] }
+                : {
+                    ...report,
+                    inferred_details: inferredRules.reduce((acc, rule) => {
+                        acc[rule.id] = {
+                            source_location: rule.source_location,
+                            condition: rule.condition,
+                            code_snippet: rule.code_snippet,
+                            type: rule.type,
+                            specificKeywords: rule.specificKeywords,
                         };
                         return acc;
                     }, {}),
                 },
-            };
-            allCoverageResults.push(bizResult);
-            console.log(`  ${bizReport.covered}/${bizReport.total} inferred business rules have test coverage (${bizReport.percentage}%)`);
-        }
-        catch (err) {
-            warnings.push(`Business rules coverage failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    // ── 4e. Integration flows coverage ──────────────────────────────────────
+            reason: report.total === 0 ? (0, analyzeHelpers_1.requiredNaReason)('business', { filesScanned: artifacts.serviceFiles.length }) : undefined,
+            status: report.total === 0 ? 'N/A' : undefined,
+        };
+    });
+    allCoverageResults.push(businessResult);
     const integrationFlowsYaml = path.join(rootDir, 'integration-flows.yaml');
-    if (fsMod.existsSync(integrationFlowsYaml)) {
-        // Explicit YAML takes precedence
-        try {
-            console.log(`\nAnalyzing integration flows coverage...`);
+    const integrationResult = await (0, analyzeHelpers_1.runMetricSafe)('integration', { filesScanned: artifacts.testFiles.length, scanDurationMs: 0, detectionMethod: fsMod.existsSync(integrationFlowsYaml) ? 'spec-driven' : 'inferred' }, async () => {
+        var _a;
+        const metricStartedAt = Date.now();
+        if (fsMod.existsSync(integrationFlowsYaml)) {
             const flows = (0, integrationCoverage_1.parseIntegrationFlows)(integrationFlowsYaml);
-            const flowCoverages = await (0, integrationCoverage_1.analyzeIntegrationCoverage)(flows, testsGlob);
-            const flowReport = (0, integrationCoverage_1.buildIntegrationCoverageReport)(flowCoverages);
-            const flowResult = {
+            const coverages = await (0, integrationCoverage_1.analyzeIntegrationCoverage)(flows, testsGlob);
+            const report = (0, integrationCoverage_1.buildIntegrationCoverageReport)(coverages);
+            (0, integrationCoverage_1.generateIntegrationReports)(report, reportsDir);
+            if (report.total === 0) {
+                return (0, analyzeHelpers_1.buildNaCoverageResult)('integration', (0, analyzeHelpers_1.requiredNaReason)('integration', { filesScanned: artifacts.testFiles.length }), { filesScanned: artifacts.testFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' }, report);
+            }
+            return {
                 type: 'integration',
-                totalItems: flowReport.total,
-                coveredItems: flowReport.complete,
-                coveragePercent: flowReport.percentage,
-                details: flowReport,
+                totalItems: report.total,
+                coveredItems: report.complete,
+                coveragePercent: report.percentage,
+                scanMeta: { filesScanned: artifacts.testFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' },
+                details: report,
             };
-            allCoverageResults.push(flowResult);
-            console.log(`  ${flowReport.complete}/${flowReport.total} integration flows covered (${flowReport.percentage}%)`);
         }
-        catch (err) {
-            warnings.push(`Integration flows coverage failed: ${err instanceof Error ? err.message : String(err)}`);
+        const inferredFlows = (_a = inferredFlowsResult === null || inferredFlowsResult === void 0 ? void 0 : inferredFlowsResult.flows) !== null && _a !== void 0 ? _a : [];
+        if (inferredFlows.length === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('integration', (0, analyzeHelpers_1.requiredNaReason)('integration', { filesScanned: artifacts.testFiles.length }), { filesScanned: artifacts.testFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'inferred' }, { items: [] });
         }
-    }
-    else if (inferredFlowsResult && inferredFlowsResult.flows.length > 0) {
-        // Auto-inferred: flows are extracted FROM tests, so by definition they're all covered
-        console.log(`\nIntegration flows coverage (from inferred flows)...`);
-        const syntheticItems = inferredFlowsResult.flows.map((f) => ({
-            id: f.id,
-            name: f.name,
-            total: f.steps.length,
-            covered: f.steps.length,
+        const items = inferredFlows.map((flow) => ({
+            id: flow.id,
+            name: flow.name,
+            total: flow.steps.length,
+            covered: flow.steps.length,
             complete: true,
             percentage: 100,
             uncoveredSteps: [],
         }));
-        const syntheticReport = {
-            total: syntheticItems.length,
-            complete: syntheticItems.length,
-            percentage: 100,
-            items: syntheticItems,
+        const report = {
+            total: items.length,
+            complete: items.length,
+            percentage: items.length > 0 ? 100 : 0,
+            items,
         };
-        const flowResult = {
+        return {
             type: 'integration',
-            totalItems: syntheticReport.total,
-            coveredItems: syntheticReport.complete,
-            coveragePercent: syntheticReport.percentage,
-            details: syntheticReport,
+            totalItems: report.total,
+            coveredItems: report.complete,
+            coveragePercent: report.percentage,
+            scanMeta: { filesScanned: artifacts.testFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'inferred' },
+            details: report,
         };
-        allCoverageResults.push(flowResult);
-        console.log(`  ${syntheticReport.complete}/${syntheticReport.total} multi-step flows detected and covered (100%)`);
-    }
-    if (allCoverageResults.length > 0) {
-        const observabilityInfo = (0, observability_1.buildObservabilityInfo)(metricsPort);
-        (0, reporting_1.generateMultiFormatReports)(allCoverageResults, ['json'], reportsDir, {}, observabilityInfo);
-        // Append discoveryInfo to coverage-summary.json for the dashboard
-        const summaryPath = path.join(reportsDir, 'coverage-summary.json');
-        try {
-            const summaryJson = JSON.parse(fsMod.readFileSync(summaryPath, 'utf-8'));
-            summaryJson.discoveryInfo = {
-                projectRoot: rootDir,
-                analyzedAt: new Date().toISOString(),
-                languages: artifacts.languages,
-                frameworks: artifacts.frameworks,
-                serviceFilesCount: artifacts.serviceFiles.length,
-                testFilesCount: artifacts.testFiles.length,
-                specFilesCount: artifacts.specs.length,
-                analysisMode: artifacts.specs.length > 0 ? 'explicit-spec' : 'inferred',
+    });
+    allCoverageResults.push(integrationResult);
+    const errorResult = await (0, analyzeHelpers_1.runMetricSafe)('error', { filesScanned: endpointResult.totalItems, scanDurationMs: 0, detectionMethod: specPath ? 'spec-driven' : 'inferred' }, async () => {
+        var _a, _b;
+        const metricStartedAt = Date.now();
+        if (!specPath) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('error', (0, analyzeHelpers_1.requiredNaReason)('error'), { filesScanned: endpointResult.totalItems, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'inferred' });
+        }
+        const scenarios = await (0, errorCoverage_1.parseErrorScenarios)(specPath);
+        if (scenarios.length === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('error', (0, analyzeHelpers_1.requiredNaReason)('error'), { filesScanned: endpointResult.totalItems, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' }, { items: [] });
+        }
+        const astErrorOptions = {
+            astConfig: (_b = (_a = analyzerCfg.analysis) === null || _a === void 0 ? void 0 : _a.ast) !== null && _b !== void 0 ? _b : {},
+            deepConfig: undefined,
+        };
+        const coverages = await (0, errorCoverage_1.analyzeErrorCoverage)(scenarios, testsGlob, astErrorOptions);
+        const report = (0, errorCoverage_1.buildErrorCoverageReport)(coverages);
+        (0, errorCoverage_1.generateErrorReports)(report, reportsDir);
+        return {
+            type: 'error',
+            totalItems: report.total,
+            coveredItems: report.covered,
+            coveragePercent: report.percentage,
+            scanMeta: { filesScanned: endpointResult.totalItems, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' },
+            details: report,
+        };
+    });
+    allCoverageResults.push(errorResult);
+    const securityResult = await (0, analyzeHelpers_1.runMetricSafe)('security', { filesScanned: endpointResult.totalItems, scanDurationMs: 0, detectionMethod: specPath ? 'spec-driven' : 'ast' }, async () => {
+        var _a, _b, _c;
+        const metricStartedAt = Date.now();
+        if (!specPath) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('security', (0, analyzeHelpers_1.requiredNaReason)('security'), { filesScanned: endpointResult.totalItems, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'ast' });
+        }
+        const controls = await (0, securityCoverage_1.parseSecurityControls)(specPath);
+        if (controls.length === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('security', (0, analyzeHelpers_1.requiredNaReason)('security', { specDetected: true }), { filesScanned: endpointResult.totalItems, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' }, { items: [] });
+        }
+        const astSecurityOptions = {
+            astConfig: (_b = (_a = analyzerCfg.analysis) === null || _a === void 0 ? void 0 : _a.ast) !== null && _b !== void 0 ? _b : {},
+            deepConfig: (_c = analyzerCfg.scans.coverage) === null || _c === void 0 ? void 0 : _c.deepAnalysis,
+        };
+        const coverages = await (0, securityCoverage_1.analyzeSecurityCoverage)(controls, testsGlob, undefined, astSecurityOptions);
+        const report = (0, securityCoverage_1.buildSecurityCoverageReport)(coverages, 0);
+        (0, securityCoverage_1.generateSecurityReports)(report, reportsDir);
+        return {
+            type: 'security',
+            totalItems: report.total,
+            coveredItems: report.covered,
+            coveragePercent: report.percentage,
+            scanMeta: { filesScanned: endpointResult.totalItems, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' },
+            details: report,
+        };
+    });
+    allCoverageResults.push(securityResult);
+    const performanceResult = await (0, analyzeHelpers_1.runMetricSafe)('performance', { filesScanned: performanceFilesScanned, scanDurationMs: 0, detectionMethod: 'cascaded' }, async () => {
+        const metricStartedAt = Date.now();
+        if (!specPath || loadResultCandidates.length === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('performance', (0, analyzeHelpers_1.requiredNaReason)('performance', { filesScanned: performanceFilesScanned }), { filesScanned: performanceFilesScanned, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'cascaded' });
+        }
+        const endpoints = await (0, perfResilienceCoverage_1.parseEndpointsFromSpec)(specPath);
+        const thresholds = { responseMs: 500, errorRate: 0.05 };
+        const metricsMap = (0, perfResilienceCoverage_1.parseLoadTestResults)(loadResultCandidates);
+        const perfCoverages = (0, perfResilienceCoverage_1.analyzePerformanceCoverage)(endpoints, metricsMap, thresholds);
+        const scenarios = (0, perfResilienceCoverage_1.buildResilienceScenarios)(endpoints);
+        const resilienceCoverages = await (0, perfResilienceCoverage_1.analyzeResilienceCoverage)(scenarios, testsGlob);
+        const report = (0, perfResilienceCoverage_1.buildPerfResilienceReport)(perfCoverages, resilienceCoverages);
+        (0, perfResilienceCoverage_1.generatePerfResilienceReports)(report, reportsDir);
+        if (report.totalEndpoints === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('performance', (0, analyzeHelpers_1.requiredNaReason)('performance', { filesScanned: performanceFilesScanned }), { filesScanned: performanceFilesScanned, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'cascaded' }, report);
+        }
+        return {
+            type: 'performance',
+            totalItems: report.totalEndpoints,
+            coveredItems: report.endpointsWithLoadData,
+            coveragePercent: report.performanceCoveragePercent,
+            scanMeta: { filesScanned: performanceFilesScanned, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'cascaded' },
+            details: report,
+        };
+    });
+    allCoverageResults.push(performanceResult);
+    const resilienceResult = await (0, analyzeHelpers_1.runMetricSafe)('resilience', { filesScanned: artifacts.serviceFiles.length, scanDurationMs: 0, detectionMethod: 'cascaded' }, async () => {
+        const metricStartedAt = Date.now();
+        if (!specPath || resiliencePatternFiles.length === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('resilience', (0, analyzeHelpers_1.requiredNaReason)('resilience', { filesScanned: artifacts.serviceFiles.length }), { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'cascaded' });
+        }
+        const endpoints = await (0, perfResilienceCoverage_1.parseEndpointsFromSpec)(specPath);
+        const metricsMap = loadResultCandidates.length > 0 ? (0, perfResilienceCoverage_1.parseLoadTestResults)(loadResultCandidates) : new Map();
+        const perfCoverages = (0, perfResilienceCoverage_1.analyzePerformanceCoverage)(endpoints, metricsMap, { responseMs: 500, errorRate: 0.05 });
+        const scenarios = (0, perfResilienceCoverage_1.buildResilienceScenarios)(endpoints);
+        const resilienceCoverages = await (0, perfResilienceCoverage_1.analyzeResilienceCoverage)(scenarios, testsGlob);
+        const report = (0, perfResilienceCoverage_1.buildPerfResilienceReport)(perfCoverages, resilienceCoverages);
+        (0, perfResilienceCoverage_1.generatePerfResilienceReports)(report, reportsDir);
+        if (report.totalResilienceScenarios === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('resilience', (0, analyzeHelpers_1.requiredNaReason)('resilience', { filesScanned: artifacts.serviceFiles.length }), { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'cascaded' }, report);
+        }
+        return {
+            type: 'resilience',
+            totalItems: report.totalResilienceScenarios,
+            coveredItems: report.coveredResilienceScenarios,
+            coveragePercent: report.resilienceCoveragePercent,
+            scanMeta: { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'cascaded' },
+            details: report,
+        };
+    });
+    allCoverageResults.push(resilienceResult);
+    const unitResult = await (0, analyzeHelpers_1.runMetricSafe)('unit', { filesScanned: artifacts.testFiles.length, scanDurationMs: 0, detectionMethod: 'cascaded' }, async () => {
+        const metricStartedAt = Date.now();
+        const execution = await (0, unitAnalysis_1.analyzeUnitTests)({
+            rootDir,
+            testFiles: artifacts.testFiles,
+            serviceFiles: artifacts.serviceFiles,
+            languages: artifacts.languages,
+            config: analyzerCfg.unitAnalysis,
+        });
+        if (execution.result.totalItems === 0) {
+            return {
+                ...execution.result,
+                status: 'N/A',
+                reason: (0, analyzeHelpers_1.requiredNaReason)('unit', { filesScanned: artifacts.testFiles.length }),
+                scanMeta: { filesScanned: artifacts.testFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'cascaded' },
             };
-            fsMod.writeFileSync(summaryPath, JSON.stringify(summaryJson, null, 2), 'utf-8');
         }
-        catch {
-            // Non-fatal — discovery info is also in scan-manifest.json
+        return {
+            ...execution.result,
+            scanMeta: { filesScanned: artifacts.testFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'cascaded' },
+        };
+    });
+    allCoverageResults.push(unitResult);
+    const eventResult = await (0, analyzeHelpers_1.runMetricSafe)('event', { filesScanned: artifacts.serviceFiles.length, scanDurationMs: 0, detectionMethod: 'ast' }, async () => {
+        const metricStartedAt = Date.now();
+        const { analyzeEventCoverage, writeEventReport } = await Promise.resolve().then(() => __importStar(require('./streaming/eventCoverage')));
+        const result = analyzeEventCoverage(sourceGlob, testsGlob);
+        if (result.totalItems === 0) {
+            const emptyReport = {
+                generatedAt: new Date().toISOString(),
+                ...(0, analyzeHelpers_1.buildNaCoverageResult)('event', (0, analyzeHelpers_1.requiredNaReason)('event', { filesScanned: artifacts.serviceFiles.length }), { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'ast' }, result.details),
+                topics: [],
+            };
+            fsMod.writeFileSync(path.join(reportsDir, 'event-coverage.json'), JSON.stringify(emptyReport, null, 2), 'utf-8');
+            return emptyReport;
         }
-        console.log(`\nReports written to: ${reportsDir}`);
-        // ── 4f-intel. Run coverage intelligence automatically ─────────────────
-        try {
-            const coverageResultsForIntel = allCoverageResults.map((r) => ({
-                type: r.type,
-                totalItems: r.totalItems,
-                coveredItems: r.coveredItems,
-                coveragePercent: r.coveragePercent,
-                details: normalizeDetailsForIntelligence(r.type, r.details),
-            }));
-            const intelReport = (0, index_3.runIntelligenceEngine)({
-                coverageResults: coverageResultsForIntel,
-                languages: artifacts.languages,
-                frameworks: artifacts.frameworks,
-                projectName: path.basename(rootDir),
-                outDir: reportsDir,
-            });
-            console.log(`\nCoverage Intelligence: ${intelReport.summary.totalFindings} findings, ` +
-                `${intelReport.summary.totalRecommendations} recommendations ` +
-                `(${intelReport.summary.criticalUncoveredItems} critical uncovered)`);
-            if (intelReport.summary.recommendationsByPriority.P0 > 0) {
-                console.log(`⚠️  P0 Recommendations: ${intelReport.summary.recommendationsByPriority.P0} — immediate action required`);
-            }
+        writeEventReport(result, reportsDir);
+        return {
+            type: 'event',
+            totalItems: result.totalItems,
+            coveredItems: result.coveredItems,
+            coveragePercent: result.coveragePercent,
+            scanMeta: { filesScanned: artifacts.serviceFiles.length, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'ast' },
+            details: result.details,
+        };
+    });
+    allCoverageResults.push(eventResult);
+    const compatibilityResult = await (0, analyzeHelpers_1.runMetricSafe)('compatibility', { filesScanned: specPath ? 2 : 0, scanDurationMs: 0, detectionMethod: 'spec-driven' }, async () => {
+        const metricStartedAt = Date.now();
+        const oldSpecPath = options['specOld'] ? path.resolve(options['specOld']) : undefined;
+        if (!specPath || !oldSpecPath || !fsMod.existsSync(oldSpecPath)) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('compatibility', (0, analyzeHelpers_1.requiredNaReason)('compatibility'), { filesScanned: specPath ? 1 : 0, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' });
         }
-        catch (intelErr) {
-            warnings.push(`Coverage intelligence failed: ${intelErr instanceof Error ? intelErr.message : String(intelErr)}`);
+        const oldApi = await (0, compatibilityCoverage_1.loadSpec)(oldSpecPath);
+        const newApi = await (0, compatibilityCoverage_1.loadSpec)(specPath);
+        const changes = (0, compatibilityCoverage_1.compareSpecs)(oldApi, newApi);
+        const verificationResults = (0, compatibilityCoverage_1.verifyContracts)([], newApi);
+        const report = (0, compatibilityCoverage_1.buildCompatibilityReport)(oldApi, newApi, changes, verificationResults, oldSpecPath, specPath);
+        (0, compatibilityCoverage_1.generateCompatibilityReports)(report, reportsDir);
+        const uniqueAffectedEndpoints = new Set(report.breakingChanges.filter((change) => change.changeType !== 'added').map((change) => `${change.method}:${change.path}`)).size;
+        const coveredItems = report.totalOldEndpoints - uniqueAffectedEndpoints;
+        if (report.totalOldEndpoints === 0) {
+            return (0, analyzeHelpers_1.buildNaCoverageResult)('compatibility', (0, analyzeHelpers_1.requiredNaReason)('compatibility'), { filesScanned: 2, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' }, report);
+        }
+        return {
+            type: 'compatibility',
+            totalItems: report.totalOldEndpoints,
+            coveredItems,
+            coveragePercent: report.compatibilityPercent,
+            scanMeta: { filesScanned: 2, scanDurationMs: Date.now() - metricStartedAt, detectionMethod: 'spec-driven' },
+            details: report,
+        };
+    });
+    allCoverageResults.push(compatibilityResult);
+    const orderedResults = (0, analyzeHelpers_1.sortResultsInKnownOrder)(allCoverageResults);
+    const effectiveThresholds = Object.fromEntries(summaryTypes_1.KNOWN_METRIC_TYPES
+        .map((type) => [type, (0, qualityGate_1.effectiveThresholdForCategory)(analyzerCfg.thresholds, type)])
+        .filter((entry) => entry[1] !== undefined));
+    const qualityGateResult = (0, qualityGate_1.evaluateQualityGate)(orderedResults, { thresholds: effectiveThresholds, qualityGate: analyzerCfg.qualityGate });
+    const enrichedResults = (0, analyzeHelpers_1.enrichResultsWithStatuses)(orderedResults, effectiveThresholds, qualityGateResult);
+    const observabilityInfo = (0, observability_1.buildObservabilityInfo)(metricsPort);
+    (0, reporting_1.generateMultiFormatReports)(enrichedResults, ['json'], reportsDir, Object.fromEntries(Object.entries(effectiveThresholds).filter((entry) => entry[1] !== undefined)), observabilityInfo);
+    for (const result of enrichedResults) {
+        if (result.type !== 'event') {
+            (0, analyzeHelpers_1.writeMetricReport)(result, reportsDir);
         }
     }
-    // ── 4f. Write scan manifest ────────────────────────────────────────────
+    const coverageResultsForIntel = enrichedResults.map((result) => ({
+        type: result.type,
+        totalItems: result.totalItems,
+        coveredItems: result.coveredItems,
+        coveragePercent: result.coveragePercent,
+        details: normalizeDetailsForIntelligence(result.type, result.details),
+    }));
+    const intelligenceReport = (0, index_3.runIntelligenceEngine)({
+        coverageResults: coverageResultsForIntel,
+        languages: artifacts.languages,
+        frameworks: artifacts.frameworks,
+        projectName: path.basename(rootDir),
+        outDir: reportsDir,
+    });
+    (0, observability_2.recordIntelligenceMetrics)({
+        projectName: path.basename(rootDir),
+        totalFindings: intelligenceReport.summary.totalFindings,
+        totalRecommendations: intelligenceReport.summary.totalRecommendations,
+        recommendationsByPriority: intelligenceReport.summary.recommendationsByPriority,
+        maxRiskScore: intelligenceReport.summary.maxRiskScore,
+        avgRiskScore: intelligenceReport.summary.avgRiskScore,
+        criticalUncoveredItems: intelligenceReport.summary.criticalUncoveredItems,
+        unprotectedSecurityFindings: intelligenceReport.summary.unprotectedSecurityFindings,
+        languages: artifacts.languages,
+        frameworks: artifacts.frameworks,
+    }, path.basename(rootDir));
+    const summaryInput = {
+        results: enrichedResults,
+        qualityGate: qualityGateResult,
+        thresholds: effectiveThresholds,
+        projectName: path.basename(rootDir),
+        intelligenceSummary: intelligenceReport.summary,
+    };
+    await (0, buildSummary_1.generateBuildSummary)(summaryInput, reportsDir);
+    await (0, prSummary_1.generatePrSummary)(summaryInput, reportsDir);
+    (0, analyzeHelpers_1.writeArchitectureArtifacts)({
+        rootDir,
+        reportsDir,
+        languages: artifacts.languages,
+        frameworks: artifacts.frameworks,
+        serviceFiles: artifacts.serviceFiles.length,
+        testFiles: artifacts.testFiles.length,
+        specPath,
+        results: enrichedResults,
+    });
+    const summaryPath = path.join(reportsDir, 'coverage-summary.json');
+    try {
+        const summaryJson = JSON.parse(fsMod.readFileSync(summaryPath, 'utf-8'));
+        summaryJson.discoveryInfo = {
+            projectRoot: rootDir,
+            analyzedAt: new Date().toISOString(),
+            languages: artifacts.languages,
+            frameworks: artifacts.frameworks,
+            serviceFilesCount: artifacts.serviceFiles.length,
+            testFilesCount: artifacts.testFiles.length,
+            specFilesCount: specPath ? 1 : 0,
+            analysisMode: specPath ? 'explicit-spec' : 'inferred',
+        };
+        summaryJson.qualityGate = qualityGateResult;
+        fsMod.writeFileSync(summaryPath, JSON.stringify(summaryJson, null, 2), 'utf-8');
+    }
+    catch (err) {
+        warnings.push(`Coverage summary update failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     try {
-        const scanTypes = allCoverageResults.map((r) => ({
-            type: r.type,
-            source: artifacts.specs.length > 0 ? 'explicit' : 'inferred',
-            itemsFound: r.totalItems,
-            itemsCovered: r.coveredItems,
-            coveragePercent: r.coveragePercent,
+        const scanTypes = enrichedResults.map((result) => ({
+            type: result.type,
+            source: result.totalItems === 0
+                ? 'skipped'
+                : specPath
+                    ? 'explicit'
+                    : 'inferred',
+            reason: result.reason,
+            itemsFound: result.totalItems,
+            itemsCovered: result.coveredItems,
+            coveragePercent: result.coveragePercent,
         }));
-        // Add skipped types (exclude 'business' and 'integration' since these are always attempted
-        // via rule/flow inference regardless of whether a spec file is present; their absence from
-        // allCoverageResults means no rules or flows were discovered, which is informative on its own.)
-        const coveredTypes = new Set(allCoverageResults.map((r) => r.type));
-        for (const skippedType of summaryTypes_1.KNOWN_METRIC_TYPES.filter((t) => t !== 'business' && t !== 'integration')) {
-            if (!coveredTypes.has(skippedType)) {
-                scanTypes.push({
-                    type: skippedType,
-                    source: 'skipped',
-                    reason: artifacts.specs.length === 0 ? 'No API spec and no routes detected' : 'No data available',
-                    itemsFound: 0,
-                    itemsCovered: 0,
-                    coveragePercent: 0,
-                });
-            }
-        }
         const manifestPath = (0, scanManifest_1.writeScanManifest)({
             projectRoot: rootDir,
             analyzedAt: new Date().toISOString(),
             discoveredFiles: {
                 serviceFiles: artifacts.serviceFiles,
                 testFiles: artifacts.testFiles,
-                specFiles: artifacts.specs,
+                specFiles: specPath ? [specPath] : [],
             },
             languages: artifacts.languages,
             frameworks: artifacts.frameworks,
@@ -2265,27 +2190,37 @@ program
     catch (err) {
         warnings.push(`Scan manifest write failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    // ── 5. Emit warnings ───────────────────────────────────────────────────
-    for (const w of warnings) {
-        console.warn(`[WARN] ${w}`);
-    }
-    // ── 6. Configuration override log ──────────────────────────────────────
-    if (options['inferBusinessRules'] === false) {
-        console.log('\nConfiguration override detected: business rule inference disabled via CLI');
+    for (const warning of warnings) {
+        console.warn(`[WARN] ${warning}`);
     }
-    if (options['inferIntegrationFlows'] === false) {
-        console.log('\nConfiguration override detected: integration flow inference disabled via CLI');
+    console.log('');
+    console.log((0, analyzeHelpers_1.renderAnalyzeSummaryTable)({
+        rootDir,
+        serviceFiles: artifacts.serviceFiles.length,
+        testFiles: artifacts.testFiles.length,
+        durationMs: Date.now() - startedAt,
+        results: enrichedResults,
+        thresholds: effectiveThresholds,
+        qualityGate: qualityGateResult,
+    }));
+    console.log(`\nReports written to: ${reportsDir}`);
+    logger.info({ event: 'analyze_complete', warnings: warnings.length, metrics: enrichedResults.length }, 'Full analyze command complete');
+    await finaliseObservability(enrichedResults, Object.fromEntries(Object.entries(effectiveThresholds).filter((entry) => entry[1] !== undefined)), metricsPort, serviceName);
+    const thresholdFailures = (0, reporting_1.checkThresholds)(enrichedResults, Object.fromEntries(Object.entries(effectiveThresholds).filter((entry) => entry[1] !== undefined)));
+    if (thresholdFailures.length > 0) {
+        for (const failure of thresholdFailures) {
+            console.error(`THRESHOLD FAILURE: ${failure}`);
+        }
+        process.exitCode = 1;
     }
-    logger.info({ event: 'analyze_complete', warnings: warnings.length }, 'Agnostic project analysis complete');
-    await finaliseObservability(allCoverageResults, {}, metricsPort, serviceName);
-    // ── 7. Optionally launch the dashboard ─────────────────────────────────
     if (options['dashboard']) {
+        const port = (_g = options['port']) !== null && _g !== void 0 ? _g : 4000;
+        console.log(`Dashboard: http://localhost:${port}`);
         (0, serveDashboard_1.serveDashboard)({
-            reportsDir: reportsDir,
-            port: (_u = options['port']) !== null && _u !== void 0 ? _u : 4000,
+            reportsDir,
+            port,
             open: Boolean(options['open']),
         });
-        // Keep the process alive — the HTTP server holds the event loop open
     }
 });
 // ─── unit-analysis command ────────────────────────────────────────────────────
@@ -2327,7 +2262,10 @@ program
     if (execution.failures.length > 0) {
         process.exitCode = 1;
     }
-    console.log(`Unit analysis complete: ${execution.result.coveredItems}/${execution.result.totalItems} unit items covered (${execution.result.coveragePercent}%)`);
+    for (const line of execution.consoleLines) {
+        console.log(line);
+    }
+    console.log(`Unit analysis complete: ${execution.result.coveredItems}/${execution.result.totalItems} unit items analysed`);
     console.log(`Reports written to: ${reportsDir}`);
     await finaliseObservability([execution.result], {}, metricsPort, serviceName);
 });