agentic-qe 3.13.3 → 3.13.5

package/dist/cli/commands/platform.js

@@ -12,6 +12,7 @@ import chalk from 'chalk';
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { PLATFORM_REGISTRY, } from '../../init/platform-config-generator.js';
+import { selectCodexSkills } from '../../init/codex-skill-manifest.js';
 import { toErrorMessage } from '../../shared/error-utils.js';
 // ============================================================================
 // Helpers
@@ -55,7 +56,7 @@ function parseConfigFile(filePath, format) {
         return { valid: false, error: toErrorMessage(error) };
     }
 }
-function checkAqeEntry(filePath, platform) {
+function checkAqeEntry(filePath, _platform) {
     try {
         const content = readFileSync(filePath, 'utf-8');
         return content.includes('agentic-qe');
@@ -64,6 +65,72 @@ function checkAqeEntry(filePath, platform) {
         return false;
     }
 }
+/** Inspect the complete installed surface for a platform without changing it. */
+export function verifyPlatformConfiguration(projectRoot, platformId, options = {}) {
+    const platform = PLATFORM_REGISTRY[platformId];
+    const checks = [];
+    const add = (label, passed, detail) => {
+        checks.push({ label, passed, detail });
+    };
+    const expectMcp = options.expectMcp !== false;
+    const configPath = path.join(projectRoot, platform.configPath);
+    const configExists = existsSync(configPath);
+    if (expectMcp) {
+        add('Config file', configExists, configExists ? platform.configPath : `missing: ${platform.configPath}`);
+    }
+    else {
+        add('MCP configuration', true, configExists ? `${platform.configPath} preserved` : 'intentionally disabled');
+    }
+    if (configExists && expectMcp) {
+        const parsed = parseConfigFile(configPath, platform.configFormat);
+        add('Config syntax', parsed.valid, parsed.valid
+            ? `valid ${platform.configFormat.toUpperCase()}`
+            : parsed.error || 'invalid configuration');
+        add('AQE MCP entry', checkAqeEntry(configPath, platform), 'agentic-qe server entry');
+    }
+    const rulesPath = path.join(projectRoot, platform.rulesPath);
+    const rulesExists = existsSync(rulesPath);
+    add('Behavioral rules', rulesExists, rulesExists ? platform.rulesPath : `missing: ${platform.rulesPath}`);
+    if (platformId === 'codex' && rulesExists) {
+        const rules = readFileSync(rulesPath, 'utf-8');
+        add('AQE instructions', rules.includes('Quality Engineering Standards (Agentic QE)'), 'AGENTS.md contains generated AQE guidance');
+    }
+    if (platformId === 'codex') {
+        const hooksPath = path.join(projectRoot, '.codex', 'hooks.json');
+        let hookCommands = [];
+        let hooksValid = false;
+        if (existsSync(hooksPath)) {
+            try {
+                const parsed = JSON.parse(readFileSync(hooksPath, 'utf-8'));
+                hooksValid = Boolean(parsed.hooks && typeof parsed.hooks === 'object');
+                hookCommands = JSON.stringify(parsed).match(/\.codex\/hooks\/[a-z0-9-]+\.cjs/gi) || [];
+            }
+            catch {
+                hooksValid = false;
+            }
+        }
+        add('Lifecycle hooks', hooksValid, hooksValid ? '.codex/hooks.json is valid' : 'missing or invalid .codex/hooks.json');
+        const referencedAdapters = [...new Set(hookCommands.map((command) => command.split('/').pop()))];
+        const adaptersPresent = referencedAdapters.length > 0
+            && referencedAdapters.every((file) => existsSync(path.join(projectRoot, '.codex', 'hooks', file)));
+        add('Hook adapters', adaptersPresent, referencedAdapters.length > 0 ? `${referencedAdapters.length} referenced adapter(s)` : 'no Codex hook adapters referenced');
+        const runtimes = [
+            'aqe-runtime.cjs',
+            ...(referencedAdapters.includes('ruflo-codex-hook.cjs') ? ['ruflo-runtime.cjs'] : []),
+        ];
+        const missingRuntimes = runtimes.filter((file) => !existsSync(path.join(projectRoot, '.codex', 'hooks', file)));
+        add('Hook runtimes', missingRuntimes.length === 0, missingRuntimes.length === 0 ? `${runtimes.length} runtime(s) present` : `missing: ${missingRuntimes.join(', ')}`);
+        const skillsPath = path.join(projectRoot, '.agents', 'skills');
+        const requiredSkills = selectCodexSkills({ includeRuflo: options.expectRuflo === true });
+        const missingSkills = requiredSkills
+            .filter((skill) => !existsSync(path.join(skillsPath, skill.name, 'SKILL.md')))
+            .map((skill) => skill.name);
+        add('QE skills', missingSkills.length === 0, missingSkills.length === 0
+            ? `${requiredSkills.length} required AQE skill(s) present`
+            : `missing: ${missingSkills.join(', ')}`);
+    }
+    return { platform: platformId, passed: checks.every((check) => check.passed), checks };
+}
 // ============================================================================
 // Platform Command
 // ============================================================================
@@ -107,6 +174,7 @@ export function createPlatformCommand() {
         .command('setup <name>')
         .description('Set up a specific platform configuration')
         .option('--overwrite', 'Overwrite existing configuration files')
+        .option('--with-ruflo', 'Add optional Ruflo guidance and lifecycle hooks (Codex only)')
         .action(async (name, options) => {
         const projectRoot = process.cwd();
         if (!isValidPlatformId(name)) {
@@ -154,6 +222,7 @@ export function createPlatformCommand() {
             const installer = factory({
                 projectRoot,
                 overwrite: options.overwrite,
+                ...(name === 'codex' ? { includeRuflo: options.withRuflo } : {}),
             });
             const result = await installer.install();
             if (result.success) {
@@ -161,9 +230,17 @@ export function createPlatformCommand() {
                 if (result.mcpConfigured) {
                     console.log(chalk.gray(`    MCP config: ${platform.configPath}`));
                 }
-                if (result.rulesInstalled) {
+                if (result.rulesInstalled || result.agentsMdInstalled) {
                     console.log(chalk.gray(`    Rules: ${platform.rulesPath}`));
                 }
+                if (name === 'codex') {
+                    if (result.hooksConfigured)
+                        console.log(chalk.gray('    Hooks: .codex/hooks.json'));
+                    console.log(chalk.gray(`    QE skills: ${result.skillsInstalled ?? 0} installed`));
+                    console.log(options.withRuflo
+                        ? chalk.green('    Ruflo integration: enabled')
+                        : chalk.gray('    Ruflo integration: not installed (opt in with --with-ruflo)'));
+                }
             }
             else {
                 console.log(chalk.red(`  ${platform.name} setup failed`));
@@ -183,7 +260,9 @@ export function createPlatformCommand() {
     platformCmd
         .command('verify <name>')
         .description('Verify a platform configuration is correct')
-        .action(async (name) => {
+        .option('--no-mcp', 'Verify a deliberately MCP-free platform installation')
+        .option('--with-ruflo', 'Require optional Ruflo guidance and lifecycle hooks (Codex only)')
+        .action(async (name, options) => {
         const projectRoot = process.cwd();
         if (!isValidPlatformId(name)) {
             console.log('');
@@ -197,51 +276,22 @@ export function createPlatformCommand() {
         console.log(chalk.bold.blue(`  Verifying ${platform.name}`));
         console.log(chalk.gray('  ─────────────────────────────────'));
         console.log('');
-        let allPassed = true;
-        // Check 1: Config file exists
-        const configPath = path.join(projectRoot, platform.configPath);
-        if (existsSync(configPath)) {
-            console.log(chalk.green(`  [pass] Config file exists: ${platform.configPath}`));
-        }
-        else {
-            console.log(chalk.red(`  [fail] Config file missing: ${platform.configPath}`));
-            allPassed = false;
-        }
-        // Check 2: Config file is valid
-        if (existsSync(configPath)) {
-            const parseResult = parseConfigFile(configPath, platform.configFormat);
-            if (parseResult.valid) {
-                console.log(chalk.green(`  [pass] Config file is valid ${platform.configFormat.toUpperCase()}`));
-            }
-            else {
-                console.log(chalk.red(`  [fail] Config file is invalid: ${parseResult.error}`));
-                allPassed = false;
-            }
-            // Check 3: Config contains agentic-qe entry
-            if (checkAqeEntry(configPath, platform)) {
-                console.log(chalk.green('  [pass] Config contains agentic-qe entry'));
-            }
-            else {
-                console.log(chalk.red('  [fail] Config does not contain agentic-qe entry'));
-                allPassed = false;
-            }
-        }
-        // Check 4: Rules file exists
-        const rulesPath = path.join(projectRoot, platform.rulesPath);
-        if (existsSync(rulesPath)) {
-            console.log(chalk.green(`  [pass] Rules file exists: ${platform.rulesPath}`));
-        }
-        else {
-            console.log(chalk.red(`  [fail] Rules file missing: ${platform.rulesPath}`));
-            allPassed = false;
+        const verification = verifyPlatformConfiguration(projectRoot, name, {
+            expectMcp: options.mcp !== false,
+            expectRuflo: options.withRuflo,
+        });
+        for (const check of verification.checks) {
+            const message = `  [${check.passed ? 'pass' : 'fail'}] ${check.label}: ${check.detail}`;
+            console.log(check.passed ? chalk.green(message) : chalk.red(message));
         }
         console.log('');
-        if (allPassed) {
+        if (verification.passed) {
             console.log(chalk.green(`  ${platform.name} configuration is valid`));
         }
         else {
             console.log(chalk.yellow(`  ${platform.name} configuration has issues`));
             console.log(chalk.gray(`  Run "aqe platform setup ${name}" to fix`));
+            process.exitCode = 1;
         }
         console.log('');
     });

package/dist/cli/commands/quality.d.ts

@@ -5,6 +5,18 @@
  * Supports --format and --output for CI/CD pipeline integration.
  */
 import { Command } from 'commander';
+import type { MemoryBackend } from '../../kernel/interfaces.js';
 import type { CLIContext } from '../handlers/interfaces.js';
+import { type QualityGateResult } from '../utils/ci-output.js';
+import { type QualityEvidenceValues } from '../../domains/quality-assessment/quality-evidence.js';
+export declare function loadQualityEvidence(memory: MemoryBackend): Promise<QualityEvidenceValues>;
+export declare function evaluateMeasuredQualityEvidence(measured: QualityEvidenceValues): QualityGateResult;
+/**
+ * Published quality command exit contract:
+ * 0 = passed with more than five percentage points of headroom
+ * 1 = one or more measured checks failed
+ * 2 = passed, but at least one measured check has less than five points of headroom
+ */
+export declare function getMeasuredQualityExitCode(result: QualityGateResult): 0 | 1 | 2;
 export declare function createQualityCommand(context: CLIContext, cleanupAndExit: (code: number) => Promise<never>, ensureInitialized: () => Promise<boolean>): Command;
 //# sourceMappingURL=quality.d.ts.map

package/dist/cli/commands/quality.js

@@ -7,6 +7,35 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { writeOutput, toJSON, qualityGateToMarkdown } from '../utils/ci-output.js';
+import { evaluateQualityEvidence, loadQualityEvidence as loadCanonicalQualityEvidence, } from '../../domains/quality-assessment/quality-evidence.js';
+export async function loadQualityEvidence(memory) {
+    return loadCanonicalQualityEvidence(memory);
+}
+export function evaluateMeasuredQualityEvidence(measured) {
+    const evaluation = evaluateQualityEvidence(measured);
+    return {
+        passed: evaluation.passed,
+        score: 'N/A',
+        checks: evaluation.checks,
+        recommendations: evaluation.recommendations,
+    };
+}
+/**
+ * Published quality command exit contract:
+ * 0 = passed with more than five percentage points of headroom
+ * 1 = one or more measured checks failed
+ * 2 = passed, but at least one measured check has less than five points of headroom
+ */
+export function getMeasuredQualityExitCode(result) {
+    if (!result.passed)
+        return 1;
+    return result.checks.some(check => (check.direction !== 'max'
+        &&
+            typeof check.value === 'number'
+        && typeof check.threshold === 'number'
+        && check.value >= check.threshold
+        && check.value < check.threshold + 5)) ? 2 : 0;
+}
 export function createQualityCommand(context, cleanupAndExit, ensureInitialized) {
     const qualityCmd = new Command('quality')
         .description('Quality assessment shortcut')
@@ -24,85 +53,32 @@ export function createQualityCommand(context, cleanupAndExit, ensureInitialized)
                 if (format === 'text') {
                     console.log(chalk.blue(`\n Running quality gate evaluation...\n`));
                 }
-                const qualityAPI = await context.kernel.getDomainAPIAsync('quality-assessment');
-                if (!qualityAPI) {
-                    console.log(chalk.red('Quality assessment domain not available'));
-                    await cleanupAndExit(1);
+                const measured = await loadQualityEvidence(context.kernel.memory);
+                const gateResult = evaluateMeasuredQualityEvidence(measured);
+                if (format === 'json') {
+                    writeOutput(toJSON(gateResult), options.output);
                 }
-                // Provide default metrics when user doesn't supply explicit values.
-                // The gate service requires metrics + thresholds to evaluate.
-                const defaultMetrics = {
-                    coverage: 0,
-                    testsPassing: 0,
-                    criticalBugs: 0,
-                    codeSmells: 0,
-                    securityVulnerabilities: 0,
-                    technicalDebt: 0,
-                    duplications: 0,
-                };
-                const defaultThresholds = {
-                    coverage: { min: 80 },
-                    testsPassing: { min: 95 },
-                    criticalBugs: { max: 0 },
-                    codeSmells: { max: 20 },
-                    securityVulnerabilities: { max: 0 },
-                    technicalDebt: { max: 5 },
-                    duplications: { max: 5 },
-                };
-                const result = await qualityAPI.evaluateGate({
-                    gateName: 'standard',
-                    metrics: defaultMetrics,
-                    thresholds: defaultThresholds,
-                });
-                if (result.success && result.value) {
-                    const assessment = result.value;
-                    const gateResult = {
-                        passed: assessment.passed ?? assessment.meetsThreshold ?? true,
-                        score: assessment.score ?? assessment.grade ?? 'N/A',
-                        checks: assessment.checks || [],
-                        recommendations: assessment.recommendations || [],
-                    };
-                    if (format === 'json') {
-                        writeOutput(toJSON(gateResult), options.output);
-                    }
-                    else if (format === 'markdown') {
-                        writeOutput(qualityGateToMarkdown(gateResult), options.output);
+                else if (format === 'markdown') {
+                    writeOutput(qualityGateToMarkdown(gateResult), options.output);
+                }
+                else {
+                    const statusIcon = gateResult.passed ? chalk.green('✓ PASSED') : chalk.red('✗ FAILED');
+                    console.log(`  Quality Gate: ${statusIcon}`);
+                    console.log(`  Score: ${chalk.cyan(gateResult.score)}\n`);
+                    console.log(chalk.cyan('  Checks:'));
+                    for (const check of gateResult.checks) {
+                        const icon = check.passed ? chalk.green('✓') : chalk.red('✗');
+                        console.log(`    ${icon} ${check.name}: ${check.value} (threshold: ${check.threshold})`);
                     }
-                    else {
-                        // Text output
-                        const statusIcon = gateResult.passed ? chalk.green('✓ PASSED') : chalk.red('✗ FAILED');
-                        console.log(`  Quality Gate: ${statusIcon}`);
-                        console.log(`  Score: ${chalk.cyan(gateResult.score)}\n`);
-                        if (gateResult.checks.length > 0) {
-                            console.log(chalk.cyan('  Checks:'));
-                            for (const check of gateResult.checks) {
-                                const icon = check.passed ? chalk.green('✓') : chalk.red('✗');
-                                console.log(`    ${icon} ${check.name}: ${check.value} (threshold: ${check.threshold})`);
-                            }
-                        }
-                        if (gateResult.recommendations && gateResult.recommendations.length > 0) {
-                            console.log(chalk.cyan('\n  Recommendations:'));
-                            for (const rec of gateResult.recommendations) {
-                                console.log(chalk.gray(`    - ${rec}`));
-                            }
+                    if (gateResult.recommendations && gateResult.recommendations.length > 0) {
+                        console.log(chalk.cyan('\n  Recommendations:'));
+                        for (const rec of gateResult.recommendations) {
+                            console.log(chalk.gray(`    - ${rec}`));
                         }
-                        console.log('');
-                    }
-                    // Exit codes: 1 = gate failed, 2 = warning (score within 5% of threshold), 0 = passed
-                    if (!gateResult.passed) {
-                        await cleanupAndExit(1);
                     }
-                    const scoreNum = parseFloat(String(gateResult.score));
-                    if (!isNaN(scoreNum) && scoreNum < 100 && scoreNum >= 95) {
-                        // Score is within 5% of perfect — warn
-                        await cleanupAndExit(2);
-                    }
-                    await cleanupAndExit(0);
-                }
-                else {
-                    console.log(chalk.red(`Quality gate failed: ${result.error?.message || 'Unknown error'}`));
-                    await cleanupAndExit(1);
+                    console.log('');
                 }
+                await cleanupAndExit(getMeasuredQualityExitCode(gateResult));
             }
         }
         catch (error) {

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

@@ -93,6 +93,7 @@ interface InitOptions {
     withKilocode?: boolean;
     withRoocode?: boolean;
     withCodex?: boolean;
+    withRuflo?: boolean;
     withWindsurf?: boolean;
     withContinuedev?: boolean;
     withAllPlatforms?: boolean;
@@ -103,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')
@@ -48,6 +49,7 @@ export class InitHandler {
             .option('--with-kilocode', 'Include Kilo Code MCP config and custom QE mode')
             .option('--with-roocode', 'Include Roo Code MCP config and custom QE mode')
             .option('--with-codex', 'Include OpenAI Codex CLI MCP, AGENTS.md, hooks, and QE skills')
+            .option('--with-ruflo', 'Add optional Ruflo guidance and lifecycle hooks to the Codex setup')
             .option('--with-windsurf', 'Include Windsurf MCP config and rules')
             .option('--with-continuedev', 'Include Continue.dev MCP config and rules')
             .option('--no-mcp', 'Skip MCP server config (MCP is enabled by default)')
@@ -121,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;
@@ -177,11 +180,13 @@ export class InitHandler {
             withKiloCode: options.withKilocode,
             withRooCode: options.withRoocode,
             withCodex: options.withCodex,
+            withRuflo: options.withRuflo,
             withWindsurf: options.withWindsurf,
             withContinueDev: options.withContinuedev,
             noMcp: options.noMcp && !options.withMcp,
             noGovernance: options.noGovernance,
             noClaude,
+            noStatusLine: options.statusline === false,
             memoryBackend: memoryOnly ? 'memory' : undefined,
         });
         console.log(chalk.white('  Analyzing project...\n'));
@@ -440,7 +445,9 @@ Options:
   --minimal                  Minimal configuration (skip optional features)
   --skip-patterns            Skip loading pre-trained patterns
   --with-n8n                 Install n8n workflow testing agents and skills
-  --with-opencode            Include OpenCode agent/skill provisioning
+  --with-opencode            Include OpenCode agent/skill provisioning
+  --with-codex               Include OpenAI Codex hooks, instructions, skills, and MCP
+  --with-ruflo               Opt into Ruflo guidance and lifecycle hooks for Codex
   --auto-migrate             Automatically migrate from v2 if detected
   --with-claude-flow         Force Claude Flow integration setup
   --skip-claude-flow         Skip Claude Flow integration
@@ -461,8 +468,10 @@ Governance:
   Use --no-governance to skip, or set GOVERNANCE_*=false env vars for
   fine-grained control over individual gates (ContinueGate, MemoryWriteGate, etc.)
 
-Examples:
-  aqe init --auto            # Auto-configure based on project (keeps existing skills)
+Examples:
+  aqe init --auto            # Auto-configure based on project (keeps existing skills)
+  aqe init --auto --with-codex --with-ruflo
+                             # Codex plus optional Ruflo coordination
   aqe init --auto --upgrade  # Auto-configure AND update all skills/agents
   aqe init --upgrade         # Upgrade existing installation
   aqe init --wizard          # Run interactive wizard

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