agentic-qe 3.14.7 → 3.15.0

package/dist/cli/commands/quality-gate.js

@@ -104,7 +104,12 @@ function resolveArtifact(options) {
 function resolveOracle(options) {
     if (options.oracleFile) {
         const raw = JSON.parse(fs.readFileSync(options.oracleFile, 'utf8'));
-        return { passed: !!raw.passed, baselinePassed: !!raw.baselinePassed };
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)
+            || !('passed' in raw) || typeof raw.passed !== 'boolean'
+            || !('baselinePassed' in raw) || typeof raw.baselinePassed !== 'boolean') {
+            throw new Error('oracle-file must contain boolean passed and baselinePassed fields');
+        }
+        return { passed: raw.passed, baselinePassed: raw.baselinePassed };
     }
     if (options.oraclePassed === undefined && options.baselinePassed === undefined) {
         return null;

package/dist/cli/index.js

@@ -22,7 +22,11 @@ import { ALL_DOMAINS } from '../shared/types/index.js';
 import { applyCommandVerbosity, installCliLogGate, isCliLogLevelEnabled } from './log-gate.js';
 import { LogLevel } from '../logging/index.js';
 import { formatErrorForLog } from '../logging/redaction.js';
+import { releaseCliProcessStores } from './process-store-cleanup.js';
 installCliLogGate();
+// Backstop for direct process.exit() paths as well as cleanupAndExit(). An
+// in-process MCP owner still drains before exit; this callback is synchronous.
+process.on('exit', releaseCliProcessStores);
 // ============================================================================
 // CLI State
 // ============================================================================
@@ -180,11 +184,12 @@ async function cleanupAndExit(code = 0) {
         }
     }
     catch { /* best effort */ }
-    // Force exit immediately. Native NAPI handles (@ruvector/rvf-node and
+    releaseCliProcessStores();
+    // Force exit after synchronous store cleanup. Native NAPI handles (@ruvector/rvf-node and
     // historically @ruvector/router, replaced by hnswlib-node in #399 /
     // ADR-090) create ref'd event loop handles that prevent natural exit,
     // and dynamic import() of cleanup modules can load more native
-    // bindings that make it worse. Exit now, clean later.
+    // bindings that make it worse. Do not wait for asynchronous disposers here.
     process.exit(code);
 }
 // ============================================================================

package/dist/cli/process-store-cleanup.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Release the CLI's process-wide stores without awaiting native work (#814).
+ * Each closer owns its handle; never remove a lock file by path. Synchronous
+ * cleanup also runs when Commander or another module calls process.exit().
+ */
+export declare function releaseCliProcessStores(): void;
+//# sourceMappingURL=process-store-cleanup.d.ts.map

package/dist/cli/process-store-cleanup.js

@@ -0,0 +1,27 @@
+import { resetSharedRvfAdapter } from '../integrations/ruvector/shared-rvf-adapter.js';
+import { resetSharedRvfDualWriter } from '../integrations/ruvector/shared-rvf-dual-writer.js';
+import { closeRegisteredStores } from '../kernel/process-lifecycle.js';
+let released = false;
+/**
+ * Release the CLI's process-wide stores without awaiting native work (#814).
+ * Each closer owns its handle; never remove a lock file by path. Synchronous
+ * cleanup also runs when Commander or another module calls process.exit().
+ */
+export function releaseCliProcessStores() {
+    if (released)
+        return;
+    released = true;
+    try {
+        resetSharedRvfDualWriter();
+    }
+    catch { /* keep closing other stores */ }
+    try {
+        resetSharedRvfAdapter();
+    }
+    catch { /* keep closing other stores */ }
+    try {
+        closeRegisteredStores();
+    }
+    catch { /* best effort on process exit */ }
+}
+//# sourceMappingURL=process-store-cleanup.js.map

package/dist/cli/utils/ci-config.d.ts

@@ -67,6 +67,8 @@ export interface CIPhaseResult {
 }
 /** Result of the full CI run */
 export interface CIRunResult {
+    /** Invalid phase selections fail before execution and retain a fresh report. */
+    configurationError?: string;
     config: string;
     startedAt: Date;
     completedAt: Date;
@@ -93,9 +95,7 @@ export interface CIConfigParseResult {
  * Parse a .aqe-ci.yml file into a CIConfig.
  */
 export declare function parseCIConfigFile(filePath: string): CIConfigParseResult;
-/**
- * Parse CI config YAML content.
- */
+/** Parse CI YAML faithfully, validating typed fields before any phase executes. */
 export declare function parseCIConfigContent(content: string, sourcePath?: string): CIConfigParseResult;
 /**
  * Get the default CI config (used when no .aqe-ci.yml exists).

package/dist/cli/utils/ci-config.js

@@ -6,7 +6,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { parseYAMLContent } from './workflow-parser.js';
+import { isCollection, isScalar, parseDocument, visit } from 'yaml';
 // ============================================================================
 // Default Config
 // ============================================================================
@@ -100,89 +100,223 @@ export function parseCIConfigFile(filePath) {
     }
     return parseCIConfigContent(content, filePath);
 }
-/**
- * Parse CI config YAML content.
- */
+const YAML_MAX_LINES = 10000;
+const YAML_MAX_LINE_LENGTH = 10000;
+const YAML_MAX_DEPTH = 20;
+const UNSAFE_YAML_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) &&
+        (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+/** Keep the previous parser's input bounds; reject unsafe expanded aliases too. */
+function parseCIYAML(content) {
+    const lines = content.split('\n');
+    if (lines.length > YAML_MAX_LINES)
+        throw new Error(`YAML exceeds maximum allowed lines (${YAML_MAX_LINES})`);
+    if (lines.some(line => line.length > YAML_MAX_LINE_LENGTH)) {
+        throw new Error(`YAML exceeds maximum line length (${YAML_MAX_LINE_LENGTH})`);
+    }
+    const document = parseDocument(content, { prettyErrors: false, merge: true });
+    if (document.errors.length)
+        throw new Error(document.errors.map(error => error.message).join('; '));
+    visit(document, {
+        Collection: (_key, _node, ancestry) => {
+            if (ancestry.filter(isCollection).length >= YAML_MAX_DEPTH) {
+                throw new Error(`YAML exceeds maximum depth (${YAML_MAX_DEPTH})`);
+            }
+        },
+        Pair: (_key, pair) => {
+            if (isScalar(pair.key) && UNSAFE_YAML_KEYS.has(String(pair.key.value))) {
+                throw new Error(`Unsafe YAML key: ${pair.key.value}`);
+            }
+        },
+    });
+    const parsed = document.contents === null ? {} : document.toJS({ maxAliasCount: 100 });
+    // Alias references may add nesting or cycles that the syntax tree does not show.
+    function checkExpanded(value, depth, ancestors) {
+        if (value === null || typeof value !== 'object')
+            return;
+        if (depth > YAML_MAX_DEPTH)
+            throw new Error(`YAML exceeds maximum depth (${YAML_MAX_DEPTH})`);
+        if (ancestors.has(value))
+            throw new Error('Cyclic YAML aliases are not supported');
+        ancestors.add(value);
+        for (const child of Object.values(value))
+            checkExpanded(child, depth + 1, ancestors);
+        ancestors.delete(value);
+    }
+    checkExpanded(parsed, 0, new Set());
+    if (!isRecord(parsed))
+        throw new Error('CI config must be a YAML mapping');
+    return parsed;
+}
+/** Parse CI YAML faithfully, validating typed fields before any phase executes. */
 export function parseCIConfigContent(content, sourcePath) {
-    const errors = [];
     let parsed;
     try {
-        parsed = parseYAMLContent(content);
+        parsed = parseCIYAML(content);
     }
     catch (err) {
         return { success: false, errors: [`Invalid YAML: ${err}`] };
     }
-    // Build config with defaults
-    const config = {
-        version: parsed.version || DEFAULT_CI_CONFIG.version,
-        name: parsed.name || DEFAULT_CI_CONFIG.name,
-        phases: [],
-        output: { ...DEFAULT_CI_CONFIG.output },
-        qualityGate: { ...DEFAULT_CI_CONFIG.qualityGate, thresholds: { ...DEFAULT_CI_CONFIG.qualityGate.thresholds } },
-    };
-    // Parse output section
-    if (parsed.output && typeof parsed.output === 'object') {
-        const out = parsed.output;
-        if (out.format)
-            config.output.format = out.format;
-        if (out.directory)
-            config.output.directory = out.directory;
-        if (out.combined_report !== undefined)
-            config.output.combinedReport = out.combined_report;
-    }
-    // Parse quality_gate section
-    if (parsed.quality_gate && typeof parsed.quality_gate === 'object') {
-        const qg = parsed.quality_gate;
-        if (qg.enforced !== undefined)
-            config.qualityGate.enforced = qg.enforced;
-        if (qg.thresholds && typeof qg.thresholds === 'object') {
-            const th = qg.thresholds;
-            if (th.coverage !== undefined)
-                config.qualityGate.thresholds.coverage = th.coverage;
-            if (th.security !== undefined)
-                config.qualityGate.thresholds.security = th.security;
-            if (th.quality !== undefined)
-                config.qualityGate.thresholds.quality = th.quality;
+    const errors = [];
+    const config = getDefaultCIConfig();
+    function readString(record, key, fallback, label) {
+        const value = record[key];
+        if (value === undefined)
+            return fallback;
+        if (typeof value !== 'string' || !value.trim()) {
+            errors.push(`${label} must be a non-empty string`);
+            return fallback;
         }
+        return value;
     }
-    // Parse phases
-    if (parsed.phases && Array.isArray(parsed.phases)) {
-        for (let i = 0; i < parsed.phases.length; i++) {
-            const p = parsed.phases[i];
-            if (!p.name) {
-                errors.push(`Phase ${i + 1} must have a "name" field`);
-                continue;
-            }
-            if (!p.type) {
-                errors.push(`Phase "${p.name}" must have a "type" field`);
-                continue;
-            }
-            const validTypes = ['test', 'coverage', 'security', 'quality-gate', 'code-intelligence', 'custom'];
-            if (!validTypes.includes(p.type)) {
-                errors.push(`Phase "${p.name}" has invalid type "${p.type}". Valid: ${validTypes.join(', ')}`);
-                continue;
+    function readBoolean(record, key, fallback, label) {
+        const value = record[key];
+        if (value === undefined)
+            return fallback;
+        if (typeof value !== 'boolean') {
+            errors.push(`${label} must be a boolean`);
+            return fallback;
+        }
+        return value;
+    }
+    if (parsed.version !== undefined) {
+        if (typeof parsed.version === 'number' && Number.isFinite(parsed.version))
+            config.version = String(parsed.version);
+        else
+            config.version = readString(parsed, 'version', config.version, 'version');
+    }
+    config.name = readString(parsed, 'name', config.name, 'name');
+    if (parsed.output !== undefined) {
+        if (!isRecord(parsed.output))
+            errors.push('output must be a mapping');
+        else {
+            config.output.format = readString(parsed.output, 'format', config.output.format, 'output.format');
+            config.output.directory = readString(parsed.output, 'directory', config.output.directory, 'output.directory');
+            config.output.combinedReport = readBoolean(parsed.output, 'combined_report', config.output.combinedReport, 'output.combined_report');
+        }
+    }
+    if (parsed.quality_gate !== undefined) {
+        if (!isRecord(parsed.quality_gate))
+            errors.push('quality_gate must be a mapping');
+        else {
+            const gate = parsed.quality_gate;
+            config.qualityGate.enforced = readBoolean(gate, 'enforced', config.qualityGate.enforced, 'quality_gate.enforced');
+            if (gate.thresholds !== undefined) {
+                if (!isRecord(gate.thresholds))
+                    errors.push('quality_gate.thresholds must be a mapping');
+                else {
+                    for (const key of ['coverage', 'quality']) {
+                        const value = gate.thresholds[key];
+                        if (value === undefined)
+                            continue;
+                        if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 100) {
+                            errors.push(`quality_gate.thresholds.${key} must be a finite number between 0 and 100`);
+                        }
+                        else
+                            config.qualityGate.thresholds[key] = value;
+                    }
+                    if (gate.thresholds.security !== undefined) {
+                        const value = gate.thresholds.security;
+                        if (typeof value !== 'string' || !['none', 'low', 'medium', 'high'].includes(value)) {
+                            errors.push('quality_gate.thresholds.security must be none, low, medium or high');
+                        }
+                        else
+                            config.qualityGate.thresholds.security = value;
+                    }
+                }
             }
-            const phase = {
-                name: p.name,
-                type: p.type,
-                enabled: p.enabled !== false,
-                config: p.config || {},
-                continueOnFailure: p.continue_on_failure || false,
-                timeout: p.timeout || 300,
-            };
-            config.phases.push(phase);
         }
     }
-    else {
-        // Use defaults if no phases specified
-        config.phases = [...DEFAULT_CI_CONFIG.phases];
+    if (parsed.phases !== undefined) {
+        config.phases = [];
+        if (!Array.isArray(parsed.phases))
+            errors.push('phases must be a sequence');
+        else
+            for (const [index, value] of parsed.phases.entries()) {
+                if (!isRecord(value)) {
+                    errors.push(`Phase ${index + 1} must be a mapping`);
+                    continue;
+                }
+                if (value.name === undefined)
+                    errors.push(`Phase ${index + 1} must have a name`);
+                const name = readString(value, 'name', '', `Phase ${index + 1} name`);
+                const validTypes = ['test', 'coverage', 'security', 'quality-gate', 'code-intelligence', 'custom'];
+                if (!validTypes.includes(value.type)) {
+                    errors.push(`Phase "${name}" has invalid type "${value.type}". Valid: ${validTypes.join(', ')}`);
+                    continue;
+                }
+                let timeout = 300;
+                if (value.timeout !== undefined) {
+                    if (typeof value.timeout !== 'number' || !Number.isFinite(value.timeout) || value.timeout <= 0) {
+                        errors.push(`Phase "${name}" timeout must be a positive finite number`);
+                    }
+                    else
+                        timeout = value.timeout;
+                }
+                if (value.config !== undefined && !isRecord(value.config))
+                    errors.push(`Phase "${name}" config must be a mapping`);
+                config.phases.push({
+                    name, type: value.type, timeout,
+                    enabled: readBoolean(value, 'enabled', true, `Phase "${name}" enabled`),
+                    continueOnFailure: readBoolean(value, 'continue_on_failure', false, `Phase "${name}" continue_on_failure`),
+                    config: isRecord(value.config) ? { ...value.config } : {},
+                });
+            }
     }
-    if (config.phases.length === 0) {
+    if (config.phases.length === 0)
         errors.push('Config must have at least one phase');
+    // Paths in a file are relative to that file's project, not the caller's cwd.
+    // Resolve existing ancestors too so a symlink cannot bypass containment.
+    const root = path.resolve(sourcePath ? path.dirname(sourcePath) : process.cwd());
+    function canonicalAncestor(candidate) {
+        let ancestor = candidate;
+        const suffix = [];
+        while (!fs.existsSync(ancestor)) {
+            const parent = path.dirname(ancestor);
+            if (parent === ancestor)
+                break;
+            suffix.unshift(path.basename(ancestor));
+            ancestor = parent;
+        }
+        return path.resolve(fs.realpathSync(ancestor), ...suffix);
     }
-    if (errors.length > 0) {
-        return { success: false, config, errors };
+    function containedPath(value, label) {
+        if (typeof value !== 'string' || !value.trim() || value.includes('\0')) {
+            errors.push(`${label} must be a non-empty relative path`);
+            return undefined;
+        }
+        const resolved = path.resolve(root, value);
+        const relative = path.relative(root, resolved);
+        if (path.isAbsolute(value) || path.win32.isAbsolute(value) ||
+            relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            errors.push(`${label} must stay inside the project and use a relative path`);
+            return undefined;
+        }
+        try {
+            const realRelative = path.relative(canonicalAncestor(root), canonicalAncestor(resolved));
+            if (realRelative === '..' || realRelative.startsWith(`..${path.sep}`) || path.isAbsolute(realRelative)) {
+                errors.push(`${label} must stay inside the project (symlink escapes are not allowed)`);
+                return undefined;
+            }
+        }
+        catch (error) {
+            errors.push(`${label} cannot be resolved safely: ${error}`);
+            return undefined;
+        }
+        return sourcePath ? resolved : value;
+    }
+    config.output.directory = containedPath(config.output.directory, 'output.directory') ?? config.output.directory;
+    for (const phase of config.phases) {
+        if (phase.config.target !== undefined) {
+            const target = containedPath(phase.config.target, `Phase "${phase.name}" config.target`);
+            if (target !== undefined)
+                phase.config.target = target;
+        }
     }
+    if (errors.length > 0)
+        return { success: false, config, errors };
     return { success: true, config, errors: [], configPath: sourcePath };
 }
 /**

package/dist/cli/utils/workflow-parser.js

@@ -694,33 +694,50 @@ function detectCircularDependencies(stages) {
  * Validate cron expression (basic validation)
  */
 export function isValidCronExpression(expression) {
-    // Check for aliases
-    if (Object.keys(CRON_PATTERNS).includes(expression)) {
-        return true;
-    }
-    // Basic cron validation: 5 fields separated by spaces
-    const parts = expression.trim().split(/\s+/);
-    if (parts.length !== 5) {
-        return false;
-    }
-    // Validate each field
-    const fieldPatterns = [
-        /^(\*|[0-5]?\d)(-[0-5]?\d)?(\/\d+)?$/, // minute (0-59)
-        /^(\*|1?\d|2[0-3])(-\d+)?(\/\d+)?$/, // hour (0-23)
-        /^(\*|[1-9]|[12]\d|3[01])(-\d+)?(\/\d+)?$/, // day of month (1-31)
-        /^(\*|[1-9]|1[0-2])(-\d+)?(\/\d+)?$/, // month (1-12)
-        /^(\*|[0-7])(-[0-7])?(\/\d+)?$/, // day of week (0-7)
+    return parseCronFields(expression) !== undefined;
+}
+/** Parse the existing numeric five-field grammar and its four named aliases. */
+function parseCronFields(expression) {
+    const normalized = Object.hasOwn(CRON_PATTERNS, expression)
+        ? CRON_PATTERNS[expression]
+        : expression;
+    const parts = normalized.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return undefined;
+    const bounds = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 7]];
+    const syntax = [
+        /^(\*|[0-5]?\d)(-[0-5]?\d)?(\/\d+)?$/,
+        /^(\*|1?\d|2[0-3])(-\d+)?(\/\d+)?$/,
+        /^(\*|[1-9]|[12]\d|3[01])(-\d+)?(\/\d+)?$/,
+        /^(\*|[1-9]|1[0-2])(-\d+)?(\/\d+)?$/,
+        /^(\*|[0-7])(-[0-7])?(\/\d+)?$/,
     ];
-    for (let i = 0; i < 5; i++) {
-        // Allow comma-separated values
-        const values = parts[i].split(',');
-        for (const value of values) {
-            if (!fieldPatterns[i].test(value) && value !== '*') {
-                return false;
+    const fields = [];
+    for (let index = 0; index < parts.length; index++) {
+        const [minimum, maximum] = bounds[index];
+        const values = new Set();
+        for (const item of parts[index].split(',')) {
+            if (!syntax[index].test(item))
+                return undefined;
+            const match = /^(\*|\d+)(?:-(\d+))?(?:\/(\d+))?$/.exec(item);
+            if (!match || (match[1] === '*' && match[2] !== undefined))
+                return undefined;
+            const start = match[1] === '*' ? minimum : Number(match[1]);
+            const end = match[2] !== undefined ? Number(match[2])
+                : match[1] === '*' || match[3] !== undefined ? maximum : start;
+            const step = match[3] === undefined ? 1 : Number(match[3]);
+            if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) ||
+                !Number.isSafeInteger(step) || step <= 0 ||
+                start < minimum || end > maximum || start > end)
+                return undefined;
+            for (let value = start; value <= end; value += step) {
+                values.add(index === 4 && value === 7 ? 0 : value);
             }
         }
+        fields.push(values);
     }
-    return true;
+    // Cronie records DOM_STAR/DOW_STAR from the first character, before parsing lists.
+    return { fields: fields, wildcardDay: parts[2].startsWith('*') || parts[4].startsWith('*') };
 }
 /**
  * Parse cron expression to human-readable string
@@ -773,40 +790,39 @@ export function describeCronSchedule(expression) {
  * Calculate next run time from cron expression
  */
 export function calculateNextRun(cronExpression, fromDate = new Date()) {
-    // Simplified next run calculation
-    const parts = cronExpression.trim().split(/\s+/);
-    if (parts.length !== 5) {
-        // Default to 1 day from now
-        return new Date(fromDate.getTime() + 24 * 60 * 60 * 1000);
-    }
-    const [minute, hour] = parts;
-    const nextRun = new Date(fromDate);
-    // Handle specific hour and minute
-    if (hour !== '*' && minute !== '*') {
-        nextRun.setHours(parseInt(hour, 10), parseInt(minute, 10), 0, 0);
-        if (nextRun <= fromDate) {
-            nextRun.setDate(nextRun.getDate() + 1);
-        }
-    }
-    else if (hour !== '*') {
-        // Every day at specific hour
-        nextRun.setHours(parseInt(hour, 10), 0, 0, 0);
-        if (nextRun <= fromDate) {
-            nextRun.setDate(nextRun.getDate() + 1);
-        }
-    }
-    else if (minute !== '*') {
-        // Every hour at specific minute
-        nextRun.setMinutes(parseInt(minute, 10), 0, 0);
-        if (nextRun <= fromDate) {
-            nextRun.setHours(nextRun.getHours() + 1);
+    const parsed = parseCronFields(cronExpression);
+    if (!parsed)
+        throw new Error(`Invalid cron expression: ${cronExpression}`);
+    if (!Number.isFinite(fromDate.getTime()))
+        throw new Error('Invalid schedule start date');
+    const [minutes, hours, days, months, weekdays] = parsed.fields;
+    // Preserve the existing host-local timezone. Advance elapsed minutes to
+    // skip absent DST times and inspect both occurrences of repeated times.
+    let candidate = new Date(Math.floor(fromDate.getTime() / 60000) * 60000 + 60000);
+    const deadline = new Date(fromDate);
+    deadline.setFullYear(fromDate.getFullYear() + 400);
+    // A complete Gregorian cycle contains 146097 days and repeats weekdays.
+    // Near the Date maximum a full cycle is not representable: clamp the
+    // search to that finite boundary and report the limitation on exhaustion.
+    const deadlineMs = Number.isFinite(deadline.getTime())
+        ? deadline.getTime() : 8_640_000_000_000_000;
+    while (Number.isFinite(candidate.getTime()) && candidate.getTime() <= deadlineMs) {
+        const dayMatches = days.has(candidate.getDate());
+        const weekdayMatches = weekdays.has(candidate.getDay());
+        const calendarMatches = months.has(candidate.getMonth() + 1) &&
+            (parsed.wildcardDay ? dayMatches && weekdayMatches : dayMatches || weekdayMatches);
+        if (!calendarMatches) {
+            // Skip a nonmatching local calendar day instead of scanning its minutes.
+            candidate.setHours(24, 0, 0, 0);
+            continue;
         }
-    }
-    else {
-        // Every minute
-        nextRun.setSeconds(0, 0);
-        nextRun.setMinutes(nextRun.getMinutes() + 1);
-    }
-    return nextRun;
+        if (hours.has(candidate.getHours()) && minutes.has(candidate.getMinutes()))
+            return candidate;
+        candidate = new Date(candidate.getTime() + 60000);
+    }
+    // An impossible date such as February 31 must not spin indefinitely or
+    // silently become a daily schedule. Leap-day/weekday intersections may
+    // exceed a leap-day-only horizon, so search one complete Gregorian cycle.
+    throw new Error(`No matching cron date within a 400-year Gregorian cycle and the supported Date range: ${cronExpression}`);
 }
 //# sourceMappingURL=workflow-parser.js.map

package/dist/domains/code-intelligence/services/metric-collector/test-counter.d.ts

@@ -6,7 +6,7 @@
  *
  * Detection priority by project type:
  * 1. Node.js: vitest > jest > fallback pattern matching
- * 2. Rust: cargo test --list
+ * 2. Rust: cargo test -- --list
  * 3. Python: pytest --collect-only
  * 4. Go: go test -list
  *

package/dist/domains/code-intelligence/services/metric-collector/test-counter.js

@@ -6,7 +6,7 @@
  *
  * Detection priority by project type:
  * 1. Node.js: vitest > jest > fallback pattern matching
- * 2. Rust: cargo test --list
+ * 2. Rust: cargo test -- --list
  * 3. Python: pytest --collect-only
  * 4. Go: go test -list
  *
@@ -262,11 +262,11 @@ function countJestTests(projectPath, config) {
 }
 /**
  * Count tests using Cargo (Rust)
- * Uses `cargo test --list` for accurate test enumeration
+ * Uses `cargo test -- --list` for accurate test enumeration
  */
 function countCargoTests(projectPath, config) {
     try {
-        const output = execSync('cargo test --list', {
+        const output = execSync('cargo test -- --list', {
             cwd: projectPath,
             encoding: 'utf-8',
             timeout: config.timeout,
@@ -310,13 +310,14 @@ function countPytestTests(projectPath, config) {
         // Count test function lines (format: "tests/test_foo.py::test_bar")
         const testLines = output.split('\n').filter(line => line.includes('::test_') || line.includes('::Test'));
         const total = testLines.length;
-        // Classify by path patterns
-        const unit = testLines.filter(t => t.includes('unit') || (!t.includes('integration') && !t.includes('e2e'))).length;
-        const integration = testLines.filter(t => t.includes('integration') || t.includes('_integration')).length;
+        // Match fallback classification precedence so every collected test belongs
+        // to exactly one category, even when its path names multiple categories.
         const e2e = testLines.filter(t => t.includes('e2e') || t.includes('end_to_end')).length;
+        const integration = testLines.filter(t => !t.includes('e2e') && !t.includes('end_to_end') && t.includes('integration')).length;
+        const unit = total - integration - e2e;
         return {
             total,
-            unit: unit - integration - e2e, // Exclude overlap
+            unit,
             integration,
             e2e,
             source: 'pytest',
@@ -343,13 +344,14 @@ function countGoTests(projectPath, config) {
             encoding: 'utf-8',
             timeout: config.timeout,
         });
-        // Count lines starting with "Test" (Go test naming convention)
-        const testLines = output.split('\n').filter(line => line.startsWith('Test') || line.startsWith('Example') || line.startsWith('Benchmark'));
-        const total = testLines.filter(l => l.startsWith('Test')).length;
-        // Classify by test name patterns
-        const unit = testLines.filter(t => t.startsWith('Test') && !t.includes('Integration') && !t.includes('E2E')).length;
-        const integration = testLines.filter(t => t.includes('Integration')).length;
+        // Benchmarks and examples are listed too, but are not included in the
+        // test total. Apply that same selection to every category.
+        const testLines = output.split('\n').filter(line => line.startsWith('Test'));
+        const total = testLines.length;
+        // Use disjoint categories, with e2e taking precedence over integration.
         const e2e = testLines.filter(t => t.includes('E2E')).length;
+        const integration = testLines.filter(t => !t.includes('E2E') && t.includes('Integration')).length;
+        const unit = total - integration - e2e;
         return {
             total,
             unit,
@@ -474,8 +476,8 @@ function countTestsInPythonFile(filePath) {
         const content = readFileSync(filePath, 'utf-8');
         // Count def test_ functions and async def test_ functions
         const funcMatches = content.match(/\bdef\s+test_\w+\s*\(/g) || [];
-        const asyncMatches = content.match(/\basync\s+def\s+test_\w+\s*\(/g) || [];
-        return funcMatches.length + asyncMatches.length;
+        // The def pattern also matches async def; every declaration counts once.
+        return funcMatches.length;
     }
     catch {
         return 0;

package/dist/domains/quality-assessment/quality-evidence.d.ts

@@ -33,7 +33,9 @@ export declare function loadQualityEvidence(memory: MemoryBackend, options?: {
     now?: number;
     maxAgeMs?: number;
 }): Promise<QualityEvidenceValues>;
-export declare function evaluateQualityEvidence(values: QualityEvidenceValues): {
+export declare function evaluateQualityEvidence(values: QualityEvidenceValues, thresholds?: {
+    coverage?: number;
+}): {
     passed: boolean;
     checks: EvaluatedQualityCheck[];
     recommendations: string[];