agentic-qe 3.15.5 → 3.15.7

package/dist/workers/workers/performance-baseline.js

@@ -2,13 +2,18 @@
  * Agentic QE v3 - Performance Baseline Worker
  * ADR-014: Background Workers for QE Monitoring
  *
- * Tracks performance trends including:
- * - Test execution time baselines
- * - Build performance tracking
- * - Resource utilization trends
- * - Performance anomaly detection
+ * Tracks test execution time against a baseline built from measured runs.
+ *
+ * #1043: every figure comes from a recorded test run — the run behind the
+ * latest usable testsPassing evidence (`test-run:<runId>` in `test-execution`),
+ * read the same way the regression monitor reads it (#1028). Build and
+ * resource figures have no measured source and are reported unmeasured.
+ * Nothing measured → nothing stored or compared. A baseline without the
+ * measured stamp (the invented one written by <= 3.15.6) is ignored and
+ * replaced by the next measured run.
  */
 import { BaseWorker } from '../base-worker.js';
+import { readQualityEvidenceRecord } from '../../domains/quality-assessment/quality-evidence.js';
 const CONFIG = {
     id: 'performance-baseline',
     name: 'Performance Baseline Tracker',
@@ -21,6 +26,57 @@ const CONFIG = {
     retryCount: 2,
     retryDelayMs: 30000,
 };
+const BASELINE_KEY = 'performance:baseline';
+const HISTORY_KEY = 'performance:history';
+const SCHEMA_VERSION = 1;
+/** Allowed slowdown before a measured run is an anomaly (30%). */
+const DURATION_THRESHOLD = 1.3;
+/** Weight of a new measured run in the baseline average. */
+const EMA_ALPHA = 0.1;
+/** Keep the last 168 measured runs. */
+const MAX_HISTORY = 168;
+const isNonNegative = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
+const round = (v) => Math.round(v * 100) / 100;
+/** A recorded test set `{ total, files }`, or `null`. */
+function parseTestSet(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const { total, files } = raw;
+    if (typeof total !== 'number' || !Number.isInteger(total) || total <= 0)
+        return null;
+    if (!Array.isArray(files) || files.length === 0 || !files.every((f) => typeof f === 'string'))
+        return null;
+    return { total, files: [...new Set(files)].sort() };
+}
+const sameTestSet = (a, b) => a !== null && b !== null && a.total === b.total
+    && a.files.length === b.files.length && a.files.every((f, i) => f === b.files[i]);
+/** The stored baseline when it carries the measured stamp and is well-formed, else `null`. */
+function measuredBaseline(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const r = raw;
+    if (r.measured !== true || r.schemaVersion !== SCHEMA_VERSION)
+        return null;
+    const t = r.testExecution;
+    if (!t || typeof t !== 'object')
+        return null;
+    if (!isNonNegative(t.avgTestDurationMs) || !isNonNegative(t.totalDurationMs)
+        || typeof t.samples !== 'number' || !Number.isInteger(t.samples) || t.samples < 1
+        || typeof t.lastRunId !== 'string')
+        return null;
+    return {
+        measured: true,
+        schemaVersion: SCHEMA_VERSION,
+        updatedAt: typeof r.updatedAt === 'string' ? r.updatedAt : '',
+        testExecution: {
+            avgTestDurationMs: t.avgTestDurationMs,
+            totalDurationMs: t.totalDurationMs,
+            samples: t.samples,
+            lastRunId: t.lastRunId,
+            testSet: parseTestSet(t.testSet),
+        },
+    };
+}
 export class PerformanceBaselineWorker extends BaseWorker {
     constructor() {
         super(CONFIG);
@@ -30,170 +86,133 @@ export class PerformanceBaselineWorker extends BaseWorker {
         context.logger.info('Starting performance baseline tracking');
         const findings = [];
         const recommendations = [];
-        // Collect current metrics
-        const currentMetrics = await this.collectPerformanceMetrics(context);
-        // Get or calculate baseline
-        const baseline = await this.getOrCalculateBaseline(context);
-        // Detect anomalies
-        const anomalies = this.detectAnomalies(currentMetrics, baseline);
-        // Analyze anomalies
-        this.analyzeAnomalies(anomalies, findings, recommendations);
-        // Update baseline with new data point
-        await this.updateBaseline(context, currentMetrics, baseline);
-        // Store metrics history
-        await this.storeMetricsHistory(context, currentMetrics);
+        const current = await this.collectMeasuredRun(context);
+        const stored = await context.memory.get(BASELINE_KEY);
+        const baseline = measuredBaseline(stored);
+        const baselineStatus = this.baselineStatus(stored, baseline);
+        if (baselineStatus === 'legacy-ignored') {
+            context.logger.info('Ignoring a performance:baseline without the measured stamp (written by <= 3.15.6)');
+        }
+        else if (baselineStatus === 'invalid-ignored') {
+            context.logger.warn('Ignoring a malformed measured performance:baseline');
+        }
+        let anomalies = [];
+        let compared = false;
+        if (!current) {
+            findings.push({
+                type: 'performance-unmeasured',
+                severity: 'info',
+                domain: 'test-execution',
+                title: 'Performance Baseline Unmeasured',
+                description: 'No recorded test run backs the current testsPassing evidence, so no timing was stored or ' +
+                    'compared. Run the test suite (test_execute_parallel, or `aqe test execute`) to start tracking. ' +
+                    'Build and resource figures are not measured by AQE.',
+            });
+        }
+        else if (baseline?.testExecution.lastRunId === current.runId) {
+            // The same run was already blended in on an earlier tick.
+            context.logger.debug('Latest measured run already in the performance baseline', { runId: current.runId });
+        }
+        else {
+            if (baseline && sameTestSet(baseline.testExecution.testSet, current.testSet)) {
+                compared = true;
+                anomalies = this.detectAnomalies(current, baseline);
+                this.analyzeAnomalies(anomalies, findings, recommendations);
+            }
+            await context.memory.set(BASELINE_KEY, this.nextBaseline(current, compared ? baseline : null));
+            await this.appendHistory(context, current);
+        }
         const healthScore = this.calculateHealthScore(anomalies);
         context.logger.info('Performance baseline tracking complete', {
             healthScore,
+            measured: current !== null,
+            baselineStatus,
             anomaliesDetected: anomalies.length,
         });
         return this.createResult(Date.now() - startTime, {
-            itemsAnalyzed: 10, // Number of metrics tracked
+            itemsAnalyzed: compared ? 2 : 0,
             issuesFound: anomalies.length,
             healthScore,
-            trend: anomalies.length > 2 ? 'degrading' : 'stable',
+            trend: anomalies.length > 0 ? 'degrading' : 'stable',
             domainMetrics: {
-                avgTestDuration: `${currentMetrics.testExecution.avgTestDurationMs}ms`,
-                p95TestDuration: `${currentMetrics.testExecution.p95DurationMs}ms`,
-                compileDuration: `${currentMetrics.build.compileDurationMs}ms`,
-                bundleSize: `${currentMetrics.build.bundleSizeKb}KB`,
-                peakMemory: `${currentMetrics.resources.peakMemoryMb}MB`,
+                baselineStatus,
+                avgTestDuration: current ? `${round(current.avgTestDurationMs)}ms` : 'unmeasured',
+                totalTestDuration: current ? `${round(current.totalDurationMs)}ms` : 'unmeasured',
+                compileDuration: 'unmeasured',
+                bundleSize: 'unmeasured',
+                peakMemory: 'unmeasured',
                 anomalies: anomalies.length,
             },
         }, findings, recommendations);
     }
-    async collectPerformanceMetrics(_context) {
-        // In a real implementation, this would collect actual metrics
-        return {
-            timestamp: new Date(),
-            testExecution: {
-                totalDurationMs: 45000,
-                avgTestDurationMs: 245,
-                slowestTestMs: 3500,
-                slowestTestName: 'workflow-orchestrator.test.ts::complex scenario',
-                p50DurationMs: 120,
-                p95DurationMs: 800,
-                p99DurationMs: 2500,
-            },
-            build: {
-                compileDurationMs: 12000,
-                bundleSizeKb: 2500,
-                dependencyCount: 45,
-            },
-            resources: {
-                peakMemoryMb: 512,
-                avgCpuPercent: 65,
-                diskReadMb: 150,
-                diskWriteMb: 50,
-            },
-        };
+    baselineStatus(stored, baseline) {
+        if (baseline)
+            return 'measured';
+        if (stored === undefined || stored === null)
+            return 'none';
+        const stamped = typeof stored === 'object' && stored.measured === true;
+        return stamped ? 'invalid-ignored' : 'legacy-ignored';
     }
-    async getOrCalculateBaseline(context) {
-        const existing = await context.memory.get('performance:baseline');
-        if (existing) {
-            return existing;
-        }
-        // Default baseline if none exists
+    /**
+     * #1043: the run behind the latest usable testsPassing evidence, with its
+     * recorded wall time and test count. `null` when there is no such evidence
+     * or the run's result was not recorded.
+     */
+    async collectMeasuredRun(context) {
+        const evidence = await readQualityEvidenceRecord(context.memory, 'testsPassing');
+        if (!evidence?.runId)
+            return null;
+        const run = await context.memory.get(`test-run:${evidence.runId}`, {
+            namespace: 'test-execution',
+        });
+        if (!run || typeof run !== 'object')
+            return null;
+        const { total, duration } = run;
+        if (typeof total !== 'number' || !Number.isInteger(total) || total <= 0 || !isNonNegative(duration))
+            return null;
         return {
-            testExecution: {
-                avgDurationMs: 200,
-                p95DurationMs: 700,
-                threshold: 1.3, // 30% deviation allowed
-            },
-            build: {
-                avgCompileMs: 10000,
-                avgBundleSizeKb: 2400,
-                threshold: 1.2, // 20% deviation allowed
-            },
-            resources: {
-                avgMemoryMb: 450,
-                avgCpuPercent: 60,
-                threshold: 1.25, // 25% deviation allowed
-            },
+            measured: true,
+            runId: evidence.runId,
+            measuredAt: evidence.measuredAt,
+            totalDurationMs: duration,
+            testCount: total,
+            avgTestDurationMs: duration / total,
+            testSet: parseTestSet({ total, files: run.testFiles }),
         };
     }
-    detectAnomalies(metrics, baseline) {
+    /**
+     * Compare a measured run with the measured baseline of the same test set.
+     * The recorded duration is the run's wall time; per-test time across
+     * different test sets would mostly measure runner overhead (#1028 N1).
+     */
+    detectAnomalies(current, baseline) {
         const anomalies = [];
-        // Test execution anomalies
-        const avgTestDeviation = metrics.testExecution.avgTestDurationMs / baseline.testExecution.avgDurationMs;
-        if (avgTestDeviation > baseline.testExecution.threshold) {
-            anomalies.push({
-                metric: 'avgTestDuration',
-                category: 'test',
-                currentValue: metrics.testExecution.avgTestDurationMs,
-                baselineValue: baseline.testExecution.avgDurationMs,
-                deviationPercent: (avgTestDeviation - 1) * 100,
-                severity: avgTestDeviation > 1.5 ? 'high' : 'medium',
-            });
-        }
-        const p95Deviation = metrics.testExecution.p95DurationMs / baseline.testExecution.p95DurationMs;
-        if (p95Deviation > baseline.testExecution.threshold) {
-            anomalies.push({
-                metric: 'p95TestDuration',
-                category: 'test',
-                currentValue: metrics.testExecution.p95DurationMs,
-                baselineValue: baseline.testExecution.p95DurationMs,
-                deviationPercent: (p95Deviation - 1) * 100,
-                severity: p95Deviation > 1.5 ? 'high' : 'medium',
-            });
-        }
-        // Build anomalies
-        const compileDeviation = metrics.build.compileDurationMs / baseline.build.avgCompileMs;
-        if (compileDeviation > baseline.build.threshold) {
-            anomalies.push({
-                metric: 'compileDuration',
-                category: 'build',
-                currentValue: metrics.build.compileDurationMs,
-                baselineValue: baseline.build.avgCompileMs,
-                deviationPercent: (compileDeviation - 1) * 100,
-                severity: compileDeviation > 1.5 ? 'high' : 'medium',
-            });
-        }
-        const bundleDeviation = metrics.build.bundleSizeKb / baseline.build.avgBundleSizeKb;
-        if (bundleDeviation > baseline.build.threshold) {
-            anomalies.push({
-                metric: 'bundleSize',
-                category: 'build',
-                currentValue: metrics.build.bundleSizeKb,
-                baselineValue: baseline.build.avgBundleSizeKb,
-                deviationPercent: (bundleDeviation - 1) * 100,
-                severity: bundleDeviation > 1.3 ? 'high' : 'medium',
-            });
-        }
-        // Resource anomalies
-        const memoryDeviation = metrics.resources.peakMemoryMb / baseline.resources.avgMemoryMb;
-        if (memoryDeviation > baseline.resources.threshold) {
-            anomalies.push({
-                metric: 'peakMemory',
-                category: 'resource',
-                currentValue: metrics.resources.peakMemoryMb,
-                baselineValue: baseline.resources.avgMemoryMb,
-                deviationPercent: (memoryDeviation - 1) * 100,
-                severity: memoryDeviation > 1.5 ? 'critical' : memoryDeviation > 1.3 ? 'high' : 'medium',
-            });
-        }
-        const cpuDeviation = metrics.resources.avgCpuPercent / baseline.resources.avgCpuPercent;
-        if (cpuDeviation > baseline.resources.threshold) {
-            anomalies.push({
-                metric: 'avgCpu',
-                category: 'resource',
-                currentValue: metrics.resources.avgCpuPercent,
-                baselineValue: baseline.resources.avgCpuPercent,
-                deviationPercent: (cpuDeviation - 1) * 100,
-                severity: cpuDeviation > 1.4 ? 'high' : 'medium',
-            });
-        }
+        const check = (metric, value, base) => {
+            if (base <= 0)
+                return;
+            const ratio = value / base;
+            if (ratio > DURATION_THRESHOLD) {
+                anomalies.push({
+                    metric,
+                    currentValue: round(value),
+                    baselineValue: round(base),
+                    deviationPercent: (ratio - 1) * 100,
+                    severity: ratio > 1.5 ? 'high' : 'medium',
+                });
+            }
+        };
+        check('avgTestDuration', current.avgTestDurationMs, baseline.testExecution.avgTestDurationMs);
+        check('totalTestDuration', current.totalDurationMs, baseline.testExecution.totalDurationMs);
         return anomalies;
     }
     analyzeAnomalies(anomalies, findings, recommendations) {
         for (const anomaly of anomalies) {
-            const domain = anomaly.category === 'test' ? 'test-execution' : 'chaos-resilience';
             findings.push({
-                type: `performance-anomaly-${anomaly.category}`,
+                type: 'performance-anomaly-test',
                 severity: anomaly.severity,
-                domain,
+                domain: 'test-execution',
                 title: `Performance Anomaly: ${this.formatMetricName(anomaly.metric)}`,
-                description: `${this.formatMetricName(anomaly.metric)} is ${anomaly.deviationPercent.toFixed(1)}% above baseline`,
+                description: `${this.formatMetricName(anomaly.metric)} is ${anomaly.deviationPercent.toFixed(1)}% above the measured baseline`,
                 context: {
                     currentValue: anomaly.currentValue,
                     baselineValue: anomaly.baselineValue,
@@ -201,11 +220,9 @@ export class PerformanceBaselineWorker extends BaseWorker {
                 },
             });
         }
-        // Category-specific recommendations
-        const testAnomalies = anomalies.filter(a => a.category === 'test');
-        if (testAnomalies.length > 0) {
+        if (anomalies.length > 0) {
             recommendations.push({
-                priority: testAnomalies.some(a => a.severity === 'high') ? 'p1' : 'p2',
+                priority: anomalies.some(a => a.severity === 'high') ? 'p1' : 'p2',
                 domain: 'test-execution',
                 action: 'Investigate Test Performance Degradation',
                 description: 'Test execution times have increased. Review for slow tests or infrastructure issues.',
@@ -214,100 +231,40 @@ export class PerformanceBaselineWorker extends BaseWorker {
                 autoFixable: false,
             });
         }
-        const buildAnomalies = anomalies.filter(a => a.category === 'build');
-        if (buildAnomalies.length > 0) {
-            const bundleAnomaly = buildAnomalies.find(a => a.metric === 'bundleSize');
-            if (bundleAnomaly) {
-                recommendations.push({
-                    priority: 'p2',
-                    domain: 'chaos-resilience',
-                    action: 'Analyze Bundle Size Increase',
-                    description: 'Bundle size has grown. Review for unnecessary dependencies or unoptimized imports.',
-                    estimatedImpact: 'medium',
-                    effort: 'low',
-                    autoFixable: true,
-                });
-            }
-        }
-        const resourceAnomalies = anomalies.filter(a => a.category === 'resource');
-        if (resourceAnomalies.length > 0) {
-            const memoryAnomaly = resourceAnomalies.find(a => a.metric === 'peakMemory');
-            if (memoryAnomaly && memoryAnomaly.severity === 'critical') {
-                recommendations.push({
-                    priority: 'p0',
-                    domain: 'chaos-resilience',
-                    action: 'Investigate Memory Usage Spike',
-                    description: 'Memory usage is significantly above baseline. Check for memory leaks.',
-                    estimatedImpact: 'high',
-                    effort: 'high',
-                    autoFixable: false,
-                });
-            }
-        }
     }
     formatMetricName(metric) {
-        const names = {
-            avgTestDuration: 'Average Test Duration',
-            p95TestDuration: 'P95 Test Duration',
-            compileDuration: 'Compile Duration',
-            bundleSize: 'Bundle Size',
-            peakMemory: 'Peak Memory Usage',
-            avgCpu: 'Average CPU Usage',
-        };
-        return names[metric] || metric;
+        return metric === 'avgTestDuration' ? 'Average Test Duration' : 'Total Test Duration';
     }
-    async updateBaseline(context, metrics, baseline) {
-        // Use exponential moving average to update baseline
-        const alpha = 0.1; // Weight for new values
-        const updatedBaseline = {
+    /** Blend a measured run into a comparable baseline, or start a new one from it. */
+    nextBaseline(current, comparable) {
+        const prev = comparable?.testExecution;
+        const blend = (base, value) => base * (1 - EMA_ALPHA) + value * EMA_ALPHA;
+        return {
+            measured: true,
+            schemaVersion: SCHEMA_VERSION,
+            updatedAt: new Date().toISOString(),
             testExecution: {
-                avgDurationMs: baseline.testExecution.avgDurationMs * (1 - alpha) +
-                    metrics.testExecution.avgTestDurationMs * alpha,
-                p95DurationMs: baseline.testExecution.p95DurationMs * (1 - alpha) +
-                    metrics.testExecution.p95DurationMs * alpha,
-                threshold: baseline.testExecution.threshold,
-            },
-            build: {
-                avgCompileMs: baseline.build.avgCompileMs * (1 - alpha) +
-                    metrics.build.compileDurationMs * alpha,
-                avgBundleSizeKb: baseline.build.avgBundleSizeKb * (1 - alpha) +
-                    metrics.build.bundleSizeKb * alpha,
-                threshold: baseline.build.threshold,
-            },
-            resources: {
-                avgMemoryMb: baseline.resources.avgMemoryMb * (1 - alpha) +
-                    metrics.resources.peakMemoryMb * alpha,
-                avgCpuPercent: baseline.resources.avgCpuPercent * (1 - alpha) +
-                    metrics.resources.avgCpuPercent * alpha,
-                threshold: baseline.resources.threshold,
+                avgTestDurationMs: prev ? round(blend(prev.avgTestDurationMs, current.avgTestDurationMs)) : current.avgTestDurationMs,
+                totalDurationMs: prev ? round(blend(prev.totalDurationMs, current.totalDurationMs)) : current.totalDurationMs,
+                samples: prev ? prev.samples + 1 : 1,
+                lastRunId: current.runId,
+                testSet: current.testSet,
             },
         };
-        await context.memory.set('performance:baseline', updatedBaseline);
     }
-    async storeMetricsHistory(context, metrics) {
-        const history = await context.memory.get('performance:history') || [];
-        history.push(metrics);
-        // Keep last 168 data points (1 week of hourly data)
-        while (history.length > 168) {
+    async appendHistory(context, run) {
+        const stored = await context.memory.get(HISTORY_KEY);
+        const history = Array.isArray(stored) ? stored : [];
+        history.push(run);
+        while (history.length > MAX_HISTORY)
             history.shift();
-        }
-        await context.memory.set('performance:history', history);
+        await context.memory.set(HISTORY_KEY, history);
     }
     calculateHealthScore(anomalies) {
-        if (anomalies.length === 0)
-            return 100;
         let score = 100;
         for (const anomaly of anomalies) {
-            // Penalty based on severity and deviation
-            const basePenalty = {
-                critical: 25,
-                high: 15,
-                medium: 8,
-                low: 3,
-            }[anomaly.severity];
-            // Additional penalty for large deviations
-            const deviationPenalty = Math.min(10, anomaly.deviationPercent / 10);
-            score -= basePenalty + deviationPenalty;
+            const basePenalty = anomaly.severity === 'high' ? 15 : 8;
+            score -= basePenalty + Math.min(10, anomaly.deviationPercent / 10);
         }
         return Math.max(0, Math.round(score));
     }

package/dist/workers/workers/quality-gate.d.ts

@@ -2,22 +2,24 @@
  * Agentic QE v3 - Quality Gate Worker
  * ADR-014: Background Workers for QE Monitoring
  *
- * Continuous quality gate evaluation including:
- * - Multi-criteria quality assessment
- * - Release readiness scoring
- * - Blocking issue detection
- * - Quality trend tracking
+ * Continuously evaluates the measured quality gate and tracks its verdict.
+ *
+ * #1043: the gate is the canonical measured gate — the same evidence
+ * validation (`inspectQualityEvidence`) and thresholds
+ * (`evaluateQualityEvidence` / `resolveQualityThresholds`) the quality_assess
+ * tool uses. When any metric lacks usable evidence (absent, stale, malformed)
+ * the gate is not evaluated: nothing is stored and an info finding names the
+ * unmeasured metrics. A status without the measured stamp (the invented one
+ * written by <= 3.15.6) is ignored and replaced by the next measured verdict.
  */
 import { BaseWorker } from '../base-worker';
 import { WorkerContext, WorkerResult } from '../interfaces';
 export declare class QualityGateWorker extends BaseWorker {
     constructor();
     protected doExecute(context: WorkerContext): Promise<WorkerResult>;
-    private evaluateQualityGates;
-    private evaluateRule;
     private analyzeGateResults;
-    private checkBlockers;
-    private compareToHistory;
+    /** Compare with the previous verdict — only a measured one (#1043). */
+    private compareToPrevious;
     private calculateHealthScore;
 }
 //# sourceMappingURL=quality-gate.d.ts.map