agentic-qe 3.15.5 → 3.15.7

package/dist/workers/quality-daemon/persistent-memory.d.ts

@@ -7,7 +7,7 @@
  *
  * Resolves Finding 2: CLI daemon previously used throwaway in-memory Map.
  */
-import type { WorkerMemory } from '../interfaces';
+import type { WorkerMemory, WorkerMemoryReadOptions } from '../interfaces';
 /**
  * Interface matching the subset of UnifiedMemoryManager we need,
  * to avoid circular dependency on the full kernel module.
@@ -24,8 +24,8 @@ export interface KVBackend {
 export declare class PersistentWorkerMemory implements WorkerMemory {
     private readonly backend;
     constructor(backend: KVBackend);
-    get<T>(key: string): Promise<T | undefined>;
+    get<T>(key: string, options?: WorkerMemoryReadOptions): Promise<T | undefined>;
     set<T>(key: string, value: T): Promise<void>;
-    search(pattern: string): Promise<string[]>;
+    search(pattern: string, limit?: number, options?: WorkerMemoryReadOptions): Promise<string[]>;
 }
 //# sourceMappingURL=persistent-memory.d.ts.map

package/dist/workers/quality-daemon/persistent-memory.js

@@ -17,14 +17,14 @@ export class PersistentWorkerMemory {
     constructor(backend) {
         this.backend = backend;
     }
-    async get(key) {
-        return this.backend.kvGet(key, NAMESPACE);
+    async get(key, options) {
+        return this.backend.kvGet(key, options?.namespace ?? NAMESPACE);
     }
     async set(key, value) {
         await this.backend.kvSet(key, value, NAMESPACE);
     }
-    async search(pattern) {
-        return this.backend.kvSearch(pattern, NAMESPACE);
+    async search(pattern, limit, options) {
+        return this.backend.kvSearch(pattern, options?.namespace ?? NAMESPACE, limit);
     }
 }
 //# sourceMappingURL=persistent-memory.js.map

package/dist/workers/worker-manager.js

@@ -48,16 +48,23 @@ class InMemoryWorkerEventBus {
  */
 class InMemoryWorkerMemory {
     store = new Map();
-    async get(key) {
+    async get(key, options) {
+        // This process-local store holds only worker keys: no other domain's
+        // namespace (e.g. quality evidence) lives here.
+        if (options?.namespace)
+            return undefined;
         return this.store.get(key);
     }
     async set(key, value) {
         this.store.set(key, value);
     }
-    async search(pattern) {
+    async search(pattern, limit, options) {
+        if (options?.namespace)
+            return [];
         const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
         const regex = new RegExp(escaped.replace(/\*/g, '.*'));
-        return Array.from(this.store.keys()).filter((key) => regex.test(key));
+        const keys = Array.from(this.store.keys()).filter((key) => regex.test(key));
+        return limit === undefined ? keys : keys.slice(0, limit);
     }
     /**
      * Clear all stored data

package/dist/workers/workers/coverage-tracker.js

@@ -9,6 +9,7 @@
  * - Uncovered critical paths
  */
 import { BaseWorker } from '../base-worker.js';
+import { measuredCoverageSummary } from '../../domains/quality-assessment/coverage-report-event.js';
 const CONFIG = {
     id: 'coverage-tracker',
     name: 'Coverage Tracker',
@@ -33,46 +34,69 @@ export class CoverageTrackerWorker extends BaseWorker {
         // Collect coverage metrics
         const trend = await this.collectCoverageTrend(context);
         const gaps = await this.identifyCoverageGaps(context);
-        // Analyze coverage thresholds
-        this.analyzeCoverageThresholds(trend.current, findings, recommendations);
         // Analyze coverage gaps
         this.analyzeCoverageGaps(gaps, findings, recommendations);
-        // Analyze trends
-        this.analyzeCoverageTrends(trend, findings, recommendations);
-        // Store current metrics
-        await context.memory.set('coverage:current', trend.current);
+        // #1018: with no measured coverage there is nothing to compare, nothing
+        // to store, and no figure to report — never a fake 0% record.
+        const current = trend.current;
+        if (current) {
+            this.analyzeCoverageThresholds(current, findings, recommendations);
+            this.analyzeCoverageTrends({ ...trend, current }, findings, recommendations);
+            await context.memory.set('coverage:current', current);
+        }
+        else {
+            findings.push({
+                type: 'coverage-unmeasured',
+                severity: 'info',
+                domain: 'coverage-analysis',
+                title: 'Coverage Unmeasured',
+                description: 'No measured coverage exists yet (no instrumented coverage:latest). Nothing was ' +
+                    'tracked; this is not 0% coverage. Run tests with coverage or coverage_analyze_sublinear.',
+            });
+        }
         await context.memory.set('coverage:gaps', gaps);
-        const healthScore = this.calculateHealthScore(trend.current, gaps);
+        const healthScore = this.calculateHealthScore(current, gaps);
         context.logger.info('Coverage tracking complete', {
             healthScore,
+            measured: current !== null,
             findingsCount: findings.length,
             gapsFound: gaps.length,
         });
+        const pct = (v) => (v === null || v === undefined ? 'n/a' : `${v}%`);
         return this.createResult(Date.now() - startTime, {
-            itemsAnalyzed: gaps.length + 4, // 4 coverage types + gaps
-            issuesFound: findings.length,
+            itemsAnalyzed: gaps.length + (current ? 4 : 0), // 4 coverage types + gaps
+            issuesFound: findings.filter(f => f.severity !== 'info').length,
             healthScore,
-            trend: this.determineTrend(trend),
+            trend: current ? this.determineTrend({ ...trend, current }) : 'stable',
             domainMetrics: {
-                lineCoverage: `${trend.current.line}%`,
-                branchCoverage: `${trend.current.branch}%`,
-                functionCoverage: `${trend.current.function}%`,
-                statementCoverage: `${trend.current.statement}%`,
+                coverageMeasured: current ? 'true' : 'false',
+                lineCoverage: current ? pct(current.line) : 'unmeasured',
+                branchCoverage: current ? pct(current.branch) : 'unmeasured',
+                functionCoverage: current ? pct(current.function) : 'unmeasured',
+                statementCoverage: current ? pct(current.statement) : 'unmeasured',
                 gapsCount: gaps.length,
             },
         }, findings, recommendations);
     }
     async collectCoverageTrend(context) {
-        const previous = await context.memory.get('coverage:current');
-        // Read real coverage data from coverage:latest (written by coverage-analyzer
-        // and test-executor). Fall back to zeros when no data is available.
-        const latest = await context.memory.get('coverage:latest');
+        // A previous record is a baseline only if it was measured (#1018): older
+        // versions wrote an all-zero coverage:current when nothing was measured.
+        const stored = await context.memory.get('coverage:current');
+        const previous = stored && stored.measured === true && Number.isFinite(stored.line) ? stored : undefined;
+        // Real coverage comes from coverage:latest (written by coverage-analyzer,
+        // test-executor and the quality-assessment listener). Only a record
+        // stamped measured:true with finite figures counts (#1008/#1018); a
+        // missing, legacy or estimated record means "unmeasured" — never zeros.
+        const latest = measuredCoverageSummary(await context.memory.get('coverage:latest'));
+        if (!latest)
+            return { current: null, previous };
         const current = {
-            line: latest?.line ?? 0,
-            branch: latest?.branch ?? 0,
-            function: latest?.function ?? 0,
-            statement: latest?.statement ?? 0,
+            line: latest.line,
+            branch: latest.branch,
+            function: latest.function,
+            statement: latest.statement,
             timestamp: new Date(),
+            measured: true,
         };
         return { current, previous };
     }
@@ -112,7 +136,7 @@ export class CoverageTrackerWorker extends BaseWorker {
                 context: { current: coverage.line, target: thresholds.line },
             });
         }
-        if (coverage.branch < thresholds.branch) {
+        if (coverage.branch !== null && coverage.branch < thresholds.branch) {
             findings.push({
                 type: 'low-branch-coverage',
                 severity: coverage.branch < 50 ? 'high' : 'medium',
@@ -131,7 +155,7 @@ export class CoverageTrackerWorker extends BaseWorker {
                 autoFixable: true,
             });
         }
-        if (coverage.function < thresholds.function) {
+        if (coverage.function !== null && coverage.function < thresholds.function) {
             findings.push({
                 type: 'low-function-coverage',
                 severity: 'medium',
@@ -195,7 +219,8 @@ export class CoverageTrackerWorker extends BaseWorker {
         if (!trend.previous)
             return;
         const lineChange = trend.current.line - trend.previous.line;
-        const branchChange = trend.current.branch - trend.previous.branch;
+        const branchChange = trend.current.branch !== null && trend.previous.branch !== null
+            ? trend.current.branch - trend.previous.branch : 0;
         if (lineChange < -2) {
             findings.push({
                 type: 'coverage-regression',
@@ -235,21 +260,32 @@ export class CoverageTrackerWorker extends BaseWorker {
         }
     }
     calculateHealthScore(coverage, gaps) {
-        // Weight: line 25%, branch 25%, function 20%, statement 20%, gaps 10%
-        const lineScore = (coverage.line / 100) * 25;
-        const branchScore = (coverage.branch / 100) * 25;
-        const functionScore = (coverage.function / 100) * 20;
-        const statementScore = (coverage.statement / 100) * 20;
         // Gaps penalty
         const highRiskGaps = gaps.filter((g) => g.riskScore > 0.8).length;
         const gapsScore = Math.max(0, 10 - highRiskGaps * 2);
-        return Math.round(lineScore + branchScore + functionScore + statementScore + gapsScore);
+        // #1018: with no measurement, only the gap component is known; it is
+        // scaled to 0-100 rather than mixed with invented 0% coverage.
+        if (!coverage)
+            return gapsScore * 10;
+        // Weight: line 25%, branch 25%, function 20%, statement 20%, gaps 10%.
+        // An uncollected metric is left out and the rest are re-weighted.
+        const parts = [
+            [coverage.line, 25], [coverage.branch, 25], [coverage.function, 20], [coverage.statement, 20],
+        ];
+        const present = parts.filter((p) => p[0] !== null);
+        const weight = present.reduce((a, [, w]) => a + w, 0);
+        const coverageScore = present.reduce((a, [v, w]) => a + (v / 100) * w, 0) * (90 / weight);
+        return Math.round(coverageScore + gapsScore);
     }
     determineTrend(trend) {
         if (!trend.previous)
             return 'stable';
-        const avgCurrent = (trend.current.line + trend.current.branch + trend.current.function + trend.current.statement) / 4;
-        const avgPrevious = (trend.previous.line + trend.previous.branch + trend.previous.function + trend.previous.statement) / 4;
+        const avg = (c) => {
+            const values = [c.line, c.branch, c.function, c.statement].filter((v) => v !== null);
+            return values.reduce((a, v) => a + v, 0) / values.length;
+        };
+        const avgCurrent = avg(trend.current);
+        const avgPrevious = avg(trend.previous);
         if (avgCurrent > avgPrevious + 1)
             return 'improving';
         if (avgCurrent < avgPrevious - 1)

package/dist/workers/workers/defect-predictor.d.ts

@@ -2,21 +2,38 @@
  * Agentic QE v3 - Defect Predictor Worker
  * ADR-014: Background Workers for QE Monitoring
  *
- * ML-based defect prediction including:
- * - Code change risk analysis
- * - Historical defect pattern matching
- * - Hotspot identification
- * - Predictive maintenance suggestions
+ * Surfaces the defect-intelligence domain's latest predictions:
+ * - High-risk files and their contributing factors
+ * - Targeted review / refactoring / coverage recommendations
+ *
+ * #1043: every prediction comes from a run of the defect-intelligence
+ * predictor (`defect-intelligence:predictor:prediction:<id>` in the
+ * `defect-intelligence` namespace, written by DefectPredictorService), and
+ * only files that exist in the project are kept. Code hotspots have no
+ * measured source and are reported unmeasured. Nothing predicted → nothing
+ * stored, an "unmeasured" info finding. A `defect:predictions` record 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';
 import { WorkerContext, WorkerResult } from '../interfaces';
 export declare class DefectPredictorWorker extends BaseWorker {
     constructor();
     protected doExecute(context: WorkerContext): Promise<WorkerResult>;
-    private analyzeCodeForDefects;
-    private identifyHotspots;
+    /**
+     * #1043 round 2b: the newest prediction names no usable file, so a stored
+     * measured record from an older prediction is no longer current — stamp it
+     * stale (once) instead of leaving it looking like the latest analysis.
+     */
+    private markPreviousStale;
+    /**
+     * #1043: the most recent prediction run the defect-intelligence predictor
+     * recorded, restricted to regular files whose real path is inside the
+     * project root. `measured` is `null` when there is no such prediction;
+     * `unusable` describes a newest prediction none of whose files qualify.
+     */
+    private readLatestPrediction;
     private analyzeHighRiskPredictions;
-    private analyzeHotspots;
     private calculateHealthScore;
 }
 //# sourceMappingURL=defect-predictor.d.ts.map