agentic-qe 3.13.4 → 3.13.5

package/dist/cli/commands/test.js

@@ -5,8 +5,9 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { walkSourceFiles } from '../utils/file-discovery.js';
+import { filterTestFilesForFramework, walkSourceFiles } from '../utils/file-discovery.js';
 import { writeOutput, toJSON, toJUnit, testRunToMarkdown } from '../utils/ci-output.js';
+import { writeQualityEvidence } from '../../domains/quality-assessment/quality-evidence.js';
 export function createTestCommand(context, cleanupAndExit, ensureInitialized) {
     const testCmd = new Command('test')
         .description('Test generation, execution, scheduling, and load testing')
@@ -52,6 +53,20 @@ export function createTestCommand(context, cleanupAndExit, ensureInitialized) {
                 if (result.success && result.value) {
                     const generated = result.value;
                     const format = options.format;
+                    const rejected = generated.tests.filter(test => test.qualityGateResult?.passed !== true);
+                    if (rejected.length > 0) {
+                        const details = rejected.map(test => {
+                            const issues = test.qualityGateResult?.issues
+                                ?.map(issue => issue.description)
+                                .filter(Boolean)
+                                .join('; ') || 'missing passing quality evidence';
+                            return `${test.sourceFile}: ${issues}`;
+                        });
+                        console.error(chalk.red(`Generation rejected ${rejected.length} invalid or unvalidated test artifact(s):`));
+                        for (const detail of details)
+                            console.error(chalk.red(`  - ${detail}`));
+                        await cleanupAndExit(1);
+                    }
                     if (format === 'json') {
                         writeOutput(toJSON(generated), options.output);
                     }
@@ -105,7 +120,8 @@ export function createTestCommand(context, cleanupAndExit, ensureInitialized) {
                 const path = await import('path');
                 const targetPath = path.resolve(target || '.');
                 // Fix #280: Use shared file discovery supporting all languages
-                const testFiles = walkSourceFiles(targetPath, { testsOnly: true });
+                const discoveredTestFiles = walkSourceFiles(targetPath, { testsOnly: true });
+                const testFiles = filterTestFilesForFramework(discoveredTestFiles, options.framework);
                 if (testFiles.length === 0) {
                     console.log(chalk.yellow('No test files found'));
                     return;
@@ -113,12 +129,27 @@ export function createTestCommand(context, cleanupAndExit, ensureInitialized) {
                 console.log(chalk.gray(`  Found ${testFiles.length} test files\n`));
                 const result = await testExecAPI.runTests({
                     testFiles,
+                    framework: options.framework,
                     parallel: true,
                     retryCount: 2,
                 });
                 if (result.success && result.value) {
                     const run = result.value;
                     const format = options.format;
+                    const total = run.passed + run.failed + run.skipped;
+                    await context.kernel.memory.set('test-run:latest', {
+                        passed: run.passed,
+                        failed: run.failed,
+                        skipped: run.skipped,
+                        duration: run.duration,
+                        measuredAt: new Date().toISOString(),
+                    }, { namespace: 'test-execution', persist: true });
+                    await writeQualityEvidence(context.kernel.memory, {
+                        testsPassing: total > 0 ? (run.passed / total) * 100 : 0,
+                    }, {
+                        measuredAt: new Date().toISOString(),
+                        source: 'aqe test execute',
+                    });
                     if (format === 'json') {
                         writeOutput(toJSON(run), options.output);
                     }
@@ -130,7 +161,6 @@ export function createTestCommand(context, cleanupAndExit, ensureInitialized) {
                     }
                     else {
                         // Default text output
-                        const total = run.passed + run.failed + run.skipped;
                         console.log(chalk.green(`Test run complete`));
                         console.log(`\n  Results:`);
                         console.log(`    Total: ${chalk.white(total)}`);
@@ -143,7 +173,6 @@ export function createTestCommand(context, cleanupAndExit, ensureInitialized) {
                     if (run.failed > 0) {
                         await cleanupAndExit(1);
                     }
-                    const total = run.passed + run.failed + run.skipped;
                     if (total > 0 && run.skipped / total > 0.2) {
                         await cleanupAndExit(2);
                     }

package/dist/cli/handlers/init-handler.d.ts

@@ -104,6 +104,8 @@ interface InitOptions {
     noGovernance?: boolean;
     /** commander negatable flag: `--no-claude` sets this to false (#532). */
     claude?: boolean;
+    /** commander negatable flag: `--no-statusline` sets this to false (#591). */
+    statusline?: boolean;
     modular?: boolean;
 }
 export declare function createInitHandler(cleanupAndExit: (code: number) => Promise<never>): InitHandler;

package/dist/cli/handlers/init-handler.js

@@ -31,6 +31,7 @@ export class InitHandler {
             .option('-m, --max-agents <number>', 'Maximum concurrent agents', '15')
             .option('--memory <backend>', 'Memory backend (sqlite|agentdb|hybrid|memory). "memory" = database-free, in-memory only.', 'hybrid')
             .option('--no-database', 'Database-free install: alias for `--memory memory`. Skips the SQLite database phase and runs any MCP server in-memory — nothing is written to .agentic-qe/.')
+            .option('--no-statusline', 'Do not install AQE\'s Claude Code status line; remove an existing AQE-owned status line while preserving custom ones')
             .option('--lazy', 'Enable lazy loading of domains')
             .option('--wizard', 'Run interactive setup wizard')
             .option('--auto', 'Auto-configure based on project analysis')
@@ -122,7 +123,8 @@ export class InitHandler {
             // silently falls through to runStandardInit and installs the full Claude
             // surface it was meant to suppress.
             const noClaudeRequested = options.claude === false;
-            if (options.modular || platformRequested || databaseFree || noClaudeRequested) {
+            const noStatusLineRequested = options.statusline === false;
+            if (options.modular || platformRequested || databaseFree || noClaudeRequested || noStatusLineRequested) {
                 console.log(chalk.blue('\n  Agentic QE v3 Initialization\n'));
                 await this.runModularInit(options, context);
                 return;
@@ -184,6 +186,7 @@ export class InitHandler {
             noMcp: options.noMcp && !options.withMcp,
             noGovernance: options.noGovernance,
             noClaude,
+            noStatusLine: options.statusline === false,
             memoryBackend: memoryOnly ? 'memory' : undefined,
         });
         console.log(chalk.white('  Analyzing project...\n'));

package/dist/cli/utils/file-discovery.d.ts

@@ -25,4 +25,5 @@ export interface WalkOptions {
  * @returns Array of absolute file paths
  */
 export declare function walkSourceFiles(targetPath: string, options?: WalkOptions): string[];
+export declare function filterTestFilesForFramework(testFiles: string[], framework: string): string[];
 //# sourceMappingURL=file-discovery.d.ts.map

package/dist/cli/utils/file-discovery.js

@@ -6,7 +6,7 @@
  *
  * Fixes #280: CLI commands previously only found .ts files.
  */
-import { existsSync, readdirSync, statSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join, extname } from 'path';
 // ============================================================================
 // Source File Extensions by Language
@@ -102,4 +102,16 @@ export function walkSourceFiles(targetPath, options = {}) {
     walk(targetPath, 0);
     return result;
 }
+export function filterTestFilesForFramework(testFiles, framework) {
+    if (framework !== 'node' && framework !== 'node-test')
+        return testFiles;
+    return testFiles.filter(file => {
+        try {
+            return !/@playwright\/test|require\(\s*['"]playwright['"]\s*\)/.test(readFileSync(file, 'utf8'));
+        }
+        catch {
+            return true;
+        }
+    });
+}
 //# sourceMappingURL=file-discovery.js.map

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

@@ -8,6 +8,7 @@ import { LoggerFactory } from '../../../logging/index.js';
 import { ok, err } from '../../../shared/types';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
+import { writeQualityEvidence } from '../../quality-assessment/quality-evidence.js';
 const DEFAULT_CONFIG = {
     defaultThreshold: 80,
     enableLLMAnalysis: true, // On by default - opt-out
@@ -451,6 +452,10 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
             }
             // Store latest snapshot
             await this.memory.set('coverage:latest', summary, { persist: true });
+            await writeQualityEvidence(this.memory, { coverage: summary.line }, {
+                measuredAt: new Date().toISOString(),
+                source: 'coverage-analysis',
+            });
             // Store historical snapshot
             const timestamp = Date.now();
             await this.memory.set(`coverage:history:${timestamp}`, summary, {

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

@@ -9,6 +9,7 @@ export { QualityAssessmentCoordinator, type IQualityAssessmentCoordinator, type
 export { QualityGateService, type IQualityGateService, type QualityGateConfig, } from './services/quality-gate';
 export { QualityAnalyzerService, type IQualityAnalyzerService, type QualityAnalyzerConfig, } from './services/quality-analyzer';
 export { DeploymentAdvisorService, type IDeploymentAdvisorService, type DeploymentAdvisorConfig, type DeploymentAccuracy, } from './services/deployment-advisor';
+export { DEFAULT_QUALITY_EVIDENCE_MAX_AGE_MS, DEFAULT_QUALITY_THRESHOLDS, QUALITY_EVIDENCE_NAMESPACE, QUALITY_METRICS, evaluateQualityEvidence, loadQualityEvidence, writeQualityEvidence, type EvaluatedQualityCheck, type QualityEvidenceRecord, type QualityEvidenceValues, type QualityMetricName, type QualityThreshold, } from './quality-evidence.js';
 export { CoherenceGateService, createCoherenceGateService, type CoherenceGateResult, type CoherenceGateServiceConfig, } from './services/coherence-gate';
 export * from './coherence';
 export type { QualityAssessmentAPI, GateEvaluationRequest, QualityAnalysisRequest, DeploymentRequest, ComplexityRequest, GateResult, GateCheck, QualityReport, QualityMetricDetail, QualityTrend, Recommendation, DeploymentAdvice, ComplexityReport, FileComplexity, ComplexitySummary, ComplexityHotspot, QualityMetrics, GateThresholds, } from './interfaces';

package/dist/domains/quality-assessment/index.js

@@ -18,6 +18,7 @@ export { QualityAssessmentCoordinator, } from './coordinator';
 export { QualityGateService, } from './services/quality-gate';
 export { QualityAnalyzerService, } from './services/quality-analyzer';
 export { DeploymentAdvisorService, } from './services/deployment-advisor';
+export { DEFAULT_QUALITY_EVIDENCE_MAX_AGE_MS, DEFAULT_QUALITY_THRESHOLDS, QUALITY_EVIDENCE_NAMESPACE, QUALITY_METRICS, evaluateQualityEvidence, loadQualityEvidence, writeQualityEvidence, } from './quality-evidence.js';
 // ============================================================================
 // Coherence-Gated Quality Gates (ADR-030)
 // ============================================================================

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

@@ -0,0 +1,41 @@
+import type { MemoryBackend } from '../../kernel/interfaces.js';
+export declare const QUALITY_EVIDENCE_NAMESPACE = "quality-assessment";
+export declare const DEFAULT_QUALITY_EVIDENCE_MAX_AGE_MS: number;
+export declare const QUALITY_METRICS: readonly ["coverage", "testsPassing", "criticalBugs", "codeSmells", "securityVulnerabilities", "technicalDebt", "duplications"];
+export type QualityMetricName = typeof QUALITY_METRICS[number];
+export type QualityEvidenceValues = Record<QualityMetricName, number>;
+export interface QualityEvidenceRecord {
+    schemaVersion: 1;
+    metric: QualityMetricName;
+    value: number;
+    measuredAt: string;
+    source: string;
+}
+export interface QualityThreshold {
+    direction: 'min' | 'max';
+    value: number;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+}
+export declare const DEFAULT_QUALITY_THRESHOLDS: Record<QualityMetricName, QualityThreshold>;
+export interface EvaluatedQualityCheck {
+    name: QualityMetricName;
+    passed: boolean;
+    value: number;
+    threshold: number;
+    direction: 'min' | 'max';
+    severity: QualityThreshold['severity'];
+}
+export declare function writeQualityEvidence(memory: MemoryBackend, values: Partial<QualityEvidenceValues>, metadata: {
+    measuredAt: string;
+    source: string;
+}): Promise<void>;
+export declare function loadQualityEvidence(memory: MemoryBackend, options?: {
+    now?: number;
+    maxAgeMs?: number;
+}): Promise<QualityEvidenceValues>;
+export declare function evaluateQualityEvidence(values: QualityEvidenceValues): {
+    passed: boolean;
+    checks: EvaluatedQualityCheck[];
+    recommendations: string[];
+};
+//# sourceMappingURL=quality-evidence.d.ts.map

package/dist/domains/quality-assessment/quality-evidence.js

@@ -0,0 +1,115 @@
+export const QUALITY_EVIDENCE_NAMESPACE = 'quality-assessment';
+export const DEFAULT_QUALITY_EVIDENCE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export const QUALITY_METRICS = [
+    'coverage',
+    'testsPassing',
+    'criticalBugs',
+    'codeSmells',
+    'securityVulnerabilities',
+    'technicalDebt',
+    'duplications',
+];
+export const DEFAULT_QUALITY_THRESHOLDS = {
+    coverage: { direction: 'min', value: 80, severity: 'high' },
+    testsPassing: { direction: 'min', value: 95, severity: 'critical' },
+    criticalBugs: { direction: 'max', value: 0, severity: 'critical' },
+    codeSmells: { direction: 'max', value: 20, severity: 'medium' },
+    securityVulnerabilities: { direction: 'max', value: 0, severity: 'critical' },
+    technicalDebt: { direction: 'max', value: 5, severity: 'medium' },
+    duplications: { direction: 'max', value: 5, severity: 'low' },
+};
+function evidenceKey(metric) {
+    return `quality-evidence:${metric}:latest`;
+}
+function parseMeasuredAt(measuredAt, now, maxAgeMs) {
+    if (typeof measuredAt !== 'string') {
+        throw new Error('Measured quality evidence is malformed: measuredAt is required.');
+    }
+    const timestamp = Date.parse(measuredAt);
+    if (!Number.isFinite(timestamp)) {
+        throw new Error('Measured quality evidence is malformed: measuredAt is invalid.');
+    }
+    if (timestamp > now + 60_000) {
+        throw new Error('Measured quality evidence is malformed: measuredAt is in the future.');
+    }
+    if (now - timestamp > maxAgeMs) {
+        throw new Error('Measured quality evidence is stale. Run the relevant quality analyzers again.');
+    }
+    return timestamp;
+}
+function validateRecord(record, metric, now, maxAgeMs) {
+    if (!record || typeof record !== 'object') {
+        throw new Error(`No measured quality evidence found for ${metric}.`);
+    }
+    const candidate = record;
+    if (candidate.schemaVersion !== 1
+        || candidate.metric !== metric
+        || !Number.isFinite(candidate.value)
+        || candidate.value < 0
+        || typeof candidate.source !== 'string'
+        || candidate.source.trim().length === 0) {
+        throw new Error(`Measured quality evidence for ${metric} is malformed or incomplete.`);
+    }
+    parseMeasuredAt(candidate.measuredAt, now, maxAgeMs);
+}
+export async function writeQualityEvidence(memory, values, metadata) {
+    const now = Date.now();
+    parseMeasuredAt(metadata.measuredAt, now, Number.POSITIVE_INFINITY);
+    if (metadata.source.trim().length === 0) {
+        throw new Error('Quality evidence source is required.');
+    }
+    for (const metric of QUALITY_METRICS) {
+        const value = values[metric];
+        if (value === undefined)
+            continue;
+        if (!Number.isFinite(value) || value < 0) {
+            throw new Error(`Quality evidence value for ${metric} must be a non-negative finite number.`);
+        }
+        const record = {
+            schemaVersion: 1,
+            metric,
+            value,
+            measuredAt: metadata.measuredAt,
+            source: metadata.source,
+        };
+        await memory.set(evidenceKey(metric), record, {
+            namespace: QUALITY_EVIDENCE_NAMESPACE,
+            persist: true,
+        });
+    }
+}
+export async function loadQualityEvidence(memory, options = {}) {
+    const now = options.now ?? Date.now();
+    const maxAgeMs = options.maxAgeMs ?? DEFAULT_QUALITY_EVIDENCE_MAX_AGE_MS;
+    const values = {};
+    for (const metric of QUALITY_METRICS) {
+        const record = await memory.get(evidenceKey(metric), {
+            namespace: QUALITY_EVIDENCE_NAMESPACE,
+        });
+        validateRecord(record, metric, now, maxAgeMs);
+        values[metric] = record.value;
+    }
+    return values;
+}
+export function evaluateQualityEvidence(values) {
+    const checks = QUALITY_METRICS.map((name) => {
+        const threshold = DEFAULT_QUALITY_THRESHOLDS[name];
+        const value = values[name];
+        return {
+            name,
+            value,
+            threshold: threshold.value,
+            direction: threshold.direction,
+            severity: threshold.severity,
+            passed: threshold.direction === 'min' ? value >= threshold.value : value <= threshold.value,
+        };
+    });
+    return {
+        passed: checks.every((check) => check.passed),
+        checks,
+        recommendations: checks
+            .filter((check) => !check.passed)
+            .map((check) => `${check.name} failed its measured ${check.direction} threshold.`),
+    };
+}
+//# sourceMappingURL=quality-evidence.js.map

package/dist/domains/test-execution/coordinator.d.ts

@@ -20,6 +20,7 @@ import type { WeakVertex } from '../../coordination/mincut/interfaces';
 import { BaseDomainCoordinator, type BaseDomainCoordinatorConfig } from '../base-domain-coordinator.js';
 import type { InfraHealingOrchestrator } from '../../strange-loop/infra-healing/infra-healing-orchestrator.js';
 import { type TestNode, type TestOptimizationResult } from './services/mincut-test-optimizer.js';
+export declare function calculateRetryStrategyConfidence(testCount: number): number;
 /**
  * Configuration for the test execution coordinator
  */

package/dist/domains/test-execution/coordinator.js

@@ -16,6 +16,12 @@ import { createDomainFinding, } from '../../coordination/consensus/domain-findin
 import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 import { toError } from '../../shared/error-utils.js';
 import { createMinCutTestOptimizer, } from './services/mincut-test-optimizer.js';
+// ============================================================================
+// Coordinator Configuration
+// ============================================================================
+export function calculateRetryStrategyConfidence(testCount) {
+    return Math.min(1, 0.7 + (testCount / 100));
+}
 const DEFAULT_COORDINATOR_CONFIG = {
     simulateForTesting: false,
     enablePrioritization: true,
@@ -127,9 +133,11 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 failed: 0, skipped: 0, duration: 0, failedTests: [],
             });
         }
-        const framework = this.detectFramework(testsToRun);
+        const framework = request.framework ?? this.detectFramework(testsToRun);
         const workers = request.workers ?? Math.min(4, Math.max(1, testsToRun.length));
-        const timeout = request.timeout ?? 60000;
+        // Batched runners own internal parallelism, so the timeout applies to the
+        // whole discovered suite rather than one file.
+        const timeout = request.timeout ?? Math.max(60000, testsToRun.length * 2000);
         // Use parallel execution by default (unless explicitly disabled)
         if (request.parallel !== false && testsToRun.length > 1) {
             const result = await this.executeParallel({
@@ -473,8 +481,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 testCount: testsToRetry.length,
                 maxRetries: request.maxRetries,
                 backoffType: request.backoff ?? 'exponential',
-            }, 0.7 + (testsToRetry.length / 100) // Higher confidence for larger batches
-            );
+            }, calculateRetryStrategyConfidence(testsToRetry.length));
             if (!isStrategyVerified) {
                 logger.warn(`Retry strategy not verified, proceeding with reduced retries`);
                 request = { ...request, maxRetries: Math.max(1, Math.floor(request.maxRetries / 2)) };

package/dist/domains/test-execution/interfaces.d.ts

@@ -37,6 +37,8 @@ export type TestExecutionAPI = ITestExecutionAPI;
 export interface ISimpleTestRequest {
     /** Test files to execute */
     testFiles: string[];
+    /** Explicit test framework; auto-detected when omitted */
+    framework?: string;
     /** Run tests in parallel (default: true) */
     parallel?: boolean;
     /** Number of retry attempts for failed tests (default: 0) */

package/dist/domains/test-execution/services/retry-handler.js

@@ -339,7 +339,7 @@ export class RetryHandlerService {
                 // vitest run --reporter=json testFile -t "testName"
                 {
                     const vitestArgs = ['vitest', 'run', '--reporter=json', testFile];
-                    if (testName) {
+                    if (testName && testName !== testFile) {
                         vitestArgs.push('-t', testName);
                     }
                     return { command: npx, args: vitestArgs };
@@ -348,7 +348,7 @@ export class RetryHandlerService {
                 // jest --json testFile -t "testName"
                 {
                     const jestArgs = ['jest', '--json', '--testPathPattern', testFile];
-                    if (testName) {
+                    if (testName && testName !== testFile) {
                         jestArgs.push('-t', testName);
                     }
                     return { command: npx, args: jestArgs };
@@ -357,7 +357,7 @@ export class RetryHandlerService {
                 // mocha --reporter json testFile --grep "testName"
                 {
                     const mochaArgs = ['mocha', '--reporter', 'json', testFile];
-                    if (testName) {
+                    if (testName && testName !== testFile) {
                         mochaArgs.push('--grep', testName);
                     }
                     return { command: npx, args: mochaArgs };

package/dist/domains/test-execution/services/test-executor.d.ts

@@ -105,6 +105,7 @@ export declare class TestExecutorService implements ITestExecutionService {
     private validateParallelRequest;
     private runTests;
     private executeTestFile;
+    private executeTestFiles;
     /**
      * Spawn actual test runner process (vitest, jest, mocha)
      */
@@ -117,6 +118,10 @@ export declare class TestExecutorService implements ITestExecutionService {
      * Parse test runner output to extract results
      */
     private parseTestOutput;
+    /**
+     * Parse the TAP or spec summary emitted by Node's built-in test runner.
+     */
+    private parseNodeTestOutput;
     /**
      * Parse vitest JSON output
      */