@boyingliu01/xp-gate 0.11.3 → 0.11.4

package/mutation/gate-m.ts

@@ -13,7 +13,6 @@ import { detectAITestCharacteristics } from './detect-ai-test';
 import {
   resolveRunner,
   registerAllRunners,
-  RunMutationOptions,
   MutationRunOutcome,
 } from './runners';
 
@@ -81,6 +80,10 @@ function filterSourceFiles(files: string[]): string[] {
     const ext = path.extname(file);
     // Skip test files
     if (file.includes('.test.') || file.includes('_test.')) return false;
+    // Skip Java/Kotlin test files: FooTest.java, FooSpec.kt, etc.
+    if (/[A-Z]Test\.(java|kt|kts)$/.test(file)) return false;
+    if (/[A-Z]Tests\.(java|kt|kts)$/.test(file)) return false;
+    if (/[A-Z](IT|Spec)\.(java|kt|kts)$/.test(file)) return false;
     // Skip declaration files
     if (file.endsWith('.d.ts')) return false;
     // Skip adapter files
@@ -100,36 +103,85 @@ async function fileExists(filePath: string): Promise<boolean> {
   }
 }
 
+async function findFirstExist(candidates: string[]): Promise<string | null> {
+  for (const c of candidates) {
+    if (await fileExists(c)) return c;
+  }
+  return null;
+}
+
+async function findTsTestFile(sourceFile: string, dir: string, baseName: string): Promise<string | null> {
+  return findFirstExist([
+    sourceFile.replace(/\.tsx?$/, '.test.ts'),
+    path.join(dir, '__tests__', `${baseName}.test.ts`),
+  ]);
+}
+
+async function findPyTestFile(dir: string, baseName: string): Promise<string | null> {
+  return findFirstExist([
+    '', // placeholder for the side-by-side _test.py case (handled inline below)
+    path.join('tests', `test_${baseName}.py`),
+    path.join(dir, '__tests__', `test_${baseName}.py`),
+  ]);
+}
+
+async function findJavaTestFile(dir: string, baseName: string): Promise<string | null> {
+  const dirs = [
+    dir.replace(/\/src\/main\//, '/src/test/'),
+    dir.replace(/^src\//, 'src/test/'),
+  ];
+  const suffixes = ['Test.java', 'Tests.java', 'IT.java'];
+  for (const d of dirs) {
+    for (const s of suffixes) {
+      const c = path.join(d, `${baseName}${s}`);
+      if (await fileExists(c)) return c;
+    }
+  }
+  return null;
+}
+
+async function findKotlinTestFile(dir: string, baseName: string): Promise<string | null> {
+  const dirs = [
+    dir.replace(/\/src\/main\//, '/src/test/'),
+    dir.replace(/^src\//, 'src/test/'),
+  ];
+  const suffixes = ['Test.kt', 'Tests.kt', 'Spec.kt'];
+  for (const d of dirs) {
+    for (const s of suffixes) {
+      const c = path.join(d, `${baseName}${s}`);
+      if (await fileExists(c)) return c;
+    }
+  }
+  return null;
+}
+
 async function findTestFileForSource(sourceFile: string): Promise<string | null> {
   const ext = path.extname(sourceFile);
   const baseName = path.basename(sourceFile, ext);
   const dir = path.dirname(sourceFile);
 
   if (ext === '.ts' || ext === '.tsx') {
-    // TypeScript: foo.ts → foo.test.ts
-    const testFile1 = sourceFile.replace(/\.tsx?$/, '.test.ts');
-    if (await fileExists(testFile1)) return testFile1;
-
-    const testFile2 = path.join(dir, '__tests__', `${baseName}.test.ts`);
-    if (await fileExists(testFile2)) return testFile2;
+    return findTsTestFile(sourceFile, dir, baseName);
   }
 
   if (ext === '.py') {
-    // Python: foo.py → foo_test.py or tests/test_foo.py
-    const testFile1 = sourceFile.replace(/\.py$/, '_test.py');
-    if (await fileExists(testFile1)) return testFile1;
+    const pyTest = sourceFile.replace(/\.py$/, '_test.py');
+    if (await fileExists(pyTest)) return pyTest;
+    return findPyTestFile(dir, baseName);
+  }
 
-    const testFile2 = path.join('tests', `test_${baseName}.py`);
-    if (await fileExists(testFile2)) return testFile2;
+  if (ext === '.go') {
+    const goTest = sourceFile.replace(/\.go$/, '_test.go');
+    if (await fileExists(goTest)) return goTest;
+    return null;
+  }
 
-    const testFile3 = path.join(dir, '__tests__', `test_${baseName}.py`);
-    if (await fileExists(testFile3)) return testFile3;
+  if (ext === '.java') {
+    return findJavaTestFile(dir, baseName);
   }
 
-  if (ext === '.go') {
-    // Go: foo.go → foo_test.go (same directory, idiomatic convention)
-    const testFile1 = sourceFile.replace(/\.go$/, '_test.go');
-    if (await fileExists(testFile1)) return testFile1;
+  if (ext === '.kt' || ext === '.kts') {
+    return findKotlinTestFile(dir, baseName);
   }
 
   return null;
@@ -375,123 +427,115 @@ async function runAllRunners(
     if (!runner) continue;
 
     if (!await runner.isAvailable()) {
-      for (const f of files) fileScores[f] = null;
+      applyNullScores(files, fileScores);
       continue;
     }
 
-    const options: RunMutationOptions = {
-      files,
-      timeoutMs,
-      cwd,
-    };
-
-    const outcome: MutationRunOutcome = await runner.run(options);
+    const result = await runner.run({ files, timeoutMs, cwd });
+    applyMutationResult(result, files, fileScores);
+  }
 
-    if (outcome.timedOut) {
-      for (const f of files) fileScores[f] = null;
-      continue;
-    }
+  return fileScores;
+}
 
-    if (outcome.error) {
-      for (const f of files) fileScores[f] = null;
-      continue;
-    }
+function applyNullScores(files: string[], scores: Record<string, number | null>): void {
+  for (const f of files) scores[f] = null;
+}
 
-    if (!outcome.report) {
-      for (const f of files) fileScores[f] = null;
-      continue;
-    }
+function applyMutationResult(
+  outcome: MutationRunOutcome,
+  files: string[],
+  scores: Record<string, number | null>,
+): void {
+  if (outcome.timedOut || outcome.error || !outcome.report) {
+    for (const f of files) scores[f] = null;
+    return;
+  }
 
-    // If per-file scores exist, use them
-    if (outcome.report.files) {
-      for (const [fileKey, fileReport] of Object.entries(outcome.report.files)) {
-        fileScores[fileKey] = fileReport.mutationScore;
-      }
-    } else {
-      // Top-level score applies to all files
-      for (const f of files) {
-        fileScores[f] = outcome.report.mutationScore;
-      }
+  if (outcome.report.files) {
+    for (const [fileKey, fileReport] of Object.entries(outcome.report.files)) {
+      scores[fileKey] = fileReport.mutationScore;
     }
+    return;
   }
 
-  return fileScores;
+  for (const f of files) scores[f] = outcome.report.mutationScore;
 }
 
 // ── Main gateway ──
 
+function logThresholdDetails(thresholds: FileThreshold[], baseline: MutationBaseline | null): void {
+  if (baseline) {
+    console.log(`  Loaded baseline (${Object.keys(baseline.scores).length} files)`);
+  }
+  for (const ft of thresholds) {
+    const level = ft.isCriticalPath ? 'critical path' : 'default';
+    const thresholdSource = ft.explicitThreshold !== undefined
+      ? 'explicit annotation'
+      : ft.isCriticalPath
+        ? 'critical path config'
+        : 'default';
+    console.log(`  ${ft.file}: threshold=${ft.threshold}% (${level}, ${thresholdSource})`);
+  }
+}
+
+function buildMutationScores(fileScores: Record<string, number>): Record<string, MutationScore> {
+  const scores: Record<string, MutationScore> = {};
+  for (const [file, score] of Object.entries(fileScores)) {
+    scores[file] = { score, mutants: 0, killed: 0, survived: 0 };
+  }
+  return scores;
+}
+
 export async function runGateM(options: GateMOptions): Promise<GateMResult> {
   const warnings: string[] = [];
   const errors: string[] = [];
 
   const sourceFiles = filterSourceFiles(options.changedFiles);
-
   if (sourceFiles.length === 0) {
     return buildResult('skip', 0, {}, warnings, errors);
   }
 
-  // Test intent check (async, fire-and-forget warning)
   await collectTestIntentWarnings(sourceFiles, warnings);
 
   const thresholds = await determineThresholds(sourceFiles, await loadCriticalPaths(options.criticalPathsPath));
   const baseline = await loadBaseline(options.baselinePath);
 
-  if (baseline) {
-    console.log(`  Loaded baseline from ${options.baselinePath} (${Object.keys(baseline.scores).length} files)`);
-  }
-
-  for (const ft of thresholds) {
-    const level = ft.isCriticalPath ? 'critical path' : 'default';
-    const thresholdSource = ft.explicitThreshold !== undefined
-      ? 'explicit annotation'
-      : ft.isCriticalPath
-        ? 'critical path config'
-        : 'default';
-    console.log(`  ${ft.file}: threshold=${ft.threshold}% (${level}, ${thresholdSource})`);
-  }
+  logThresholdDetails(thresholds, baseline);
 
-  // Route to runners by file extension
   const groups = groupByRunner(sourceFiles);
-  const cwd = process.cwd();
-  const fileScoresNullable = await runAllRunners(groups, options.timeoutMs, cwd);
-
-  // Build final scores map
-  const fileScores: Record<string, number> = {};
-  const timeoutFiles: string[] = [];
-
-  for (const [file, maybeScore] of Object.entries(fileScoresNullable)) {
-    if (maybeScore === null) {
-      timeoutFiles.push(file);
-    } else {
-      fileScores[file] = maybeScore;
-    }
-  }
+  const fileScoresNullable = await runAllRunners(groups, options.timeoutMs, process.cwd());
 
+  const { fileScores, timeoutFiles } = partitionScores(fileScoresNullable);
   if (timeoutFiles.length > 0) {
     warnings.push(`Mutation testing timed out for: ${timeoutFiles.join(', ')}. Run locally for full report.`);
   }
 
   const evalResult = evaluateScores(fileScores, thresholds, baseline);
+  for (const msg of evalResult.messages) console.log(`  ${msg}`);
 
-  for (const msg of evalResult.messages) {
-    console.log(`  ${msg}`);
+  if (evalResult.blocked) {
+    return buildResult('block', sourceFiles.length, buildMutationScores(fileScores), warnings, errors);
   }
+  return buildResult('pass', sourceFiles.length, buildMutationScores(fileScores), warnings, errors);
+}
 
-  const mutationScores: Record<string, MutationScore> = {};
-  for (const [file, score] of Object.entries(fileScores)) {
-    mutationScores[file] = {
-      score,
-      mutants: 0, // Detailed stats only available from per-file reports
-      killed: 0,
-      survived: 0,
-    };
-  }
+interface PartitionedScores {
+  fileScores: Record<string, number>;
+  timeoutFiles: string[];
+}
 
-  if (evalResult.blocked) {
-    return buildResult('block', sourceFiles.length, mutationScores, warnings, errors);
+function partitionScores(input: Record<string, number | null>): PartitionedScores {
+  const fileScores: Record<string, number> = {};
+  const timeoutFiles: string[] = [];
+  for (const [file, maybeScore] of Object.entries(input)) {
+    if (maybeScore === null) {
+      timeoutFiles.push(file);
+    } else {
+      fileScores[file] = maybeScore;
+    }
   }
-
-  return buildResult('pass', sourceFiles.length, mutationScores, warnings, errors);
+  return { fileScores, timeoutFiles };
 }
 
 async function collectTestIntentWarnings(sourceFiles: string[], warnings: string[]): Promise<void> {

package/mutation/runners/index.ts

@@ -12,10 +12,12 @@ export { registerRunner, resolveRunner, runnerRegistry } from './types';
 export { StrykerRunner } from './stryker-runner';
 export { MutmutRunner } from './mutmut-runner';
 export { GoMutantRunner } from './go-mutant-runner';
+export { PitestRunner } from './pitest-runner';
 
 import { StrykerRunner } from './stryker-runner';
 import { MutmutRunner } from './mutmut-runner';
 import { GoMutantRunner } from './go-mutant-runner';
+import { PitestRunner } from './pitest-runner';
 import { registerRunner } from './types';
 
 /** Auto-register all known runners. */
@@ -23,4 +25,5 @@ export function registerAllRunners(): void {
   registerRunner(new StrykerRunner());
   registerRunner(new MutmutRunner());
   registerRunner(new GoMutantRunner());
+  registerRunner(new PitestRunner());
 }

package/mutation/runners/pitest-runner.ts

@@ -0,0 +1,290 @@
+// @no-test-required: PITest wrapper — tested via gate-m integration + pre-push Gate M
+import { execSync, spawn } from 'child_process';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import type {
+  MutationRunner,
+  RunMutationOptions,
+  MutationRunOutcome,
+  MutationRunResult,
+} from './types';
+
+/** JSON shape emitted by PITest when run with -DoutputFormats=JSON */
+interface PitestJsonReport {
+  mutations?: {
+    /** One of: KILLED, SURVIVED, NO_COVERAGE, TIMED_OUT, NON_VIABLE, MEMORY_ERROR, RUN_ERROR */
+    status?: string;
+    mutatedClass?: string;
+    sourceFile?: string;
+  }[];
+  /** PITest also writes "totals" in some versions — prefer counting from mutations array */
+}
+
+/**
+ * PITest mutation runner for Java and Kotlin files.
+ *
+ * Supports Maven (pom.xml with pitest-maven plugin) and Gradle
+ * (build.gradle/build.gradle.kts with info.solidsoft.pitest plugin).
+ *
+ * PITest CLI:
+ *   Maven:  mvn org.pitest:pitest-maven:mutationCoverage -DoutputFormats=JSON
+ *   Gradle: ./gradlew pitest
+ *
+ * Parses the target/pit-reports/.../mutations.json (Maven) or
+ * build/reports/pitest/mutations.json (Gradle) into MutationRunResult.
+ */
+export class PitestRunner implements MutationRunner {
+  readonly name = 'pitest';
+  readonly extensions = ['java', 'kt', 'kts'];
+
+  async isAvailable(): Promise<boolean> {
+    // Check Maven availability: mvn exists + pom.xml with pitest-maven plugin
+    try {
+      execSync('mvn --version', { stdio: 'pipe', timeout: 5000 });
+      if (existsSync('pom.xml')) {
+        const pom = readFileSync('pom.xml', 'utf-8');
+        if (
+          pom.includes('pitest-maven') ||
+          pom.includes('org.pitest')
+        ) {
+          return true;
+        }
+      }
+    } catch {
+      // Maven not available
+    }
+
+    // Check Gradle availability: gradle/gradlew exists + build.gradle(.kts) with pitest plugin
+    const gradlewPath = './gradlew';
+    const hasGradlew = existsSync(gradlewPath);
+    try {
+      if (!hasGradlew) {
+        execSync('gradle --version', { stdio: 'pipe', timeout: 5000 });
+      }
+      const buildGradle = existsSync('build.gradle.kts')
+        ? 'build.gradle.kts'
+        : existsSync('build.gradle')
+          ? 'build.gradle'
+          : null;
+      if (buildGradle) {
+        const content = readFileSync(buildGradle, 'utf-8');
+        if (
+          content.includes('info.solidsoft.pitest') ||
+          content.includes('info.solidsoft.gradle.pitest')
+        ) {
+          return true;
+        }
+      }
+    } catch {
+      return false;
+    }
+
+    return false;
+  }
+
+  async run(options: RunMutationOptions): Promise<MutationRunOutcome> {
+    const buildTool = this.detectBuildTool(options.cwd);
+
+    if (buildTool === 'maven') {
+      return this.runMaven(options);
+    } else if (buildTool === 'gradle') {
+      return this.runGradle(options);
+    }
+
+    return {
+      report: null,
+      timedOut: false,
+      error: 'No supported build tool found (need Maven pom.xml with pitest-maven or Gradle with info.solidsoft.pitest)',
+    };
+  }
+
+  private detectBuildTool(cwd: string): 'maven' | 'gradle' | null {
+    if (existsSync(join(cwd, 'pom.xml'))) {
+      try {
+        execSync('mvn --version', { stdio: 'pipe', timeout: 5000 });
+        return 'maven';
+      } catch {
+        // mvn not available
+      }
+    }
+
+    if (
+      existsSync(join(cwd, 'build.gradle')) ||
+      existsSync(join(cwd, 'build.gradle.kts'))
+    ) {
+      if (existsSync(join(cwd, 'gradlew'))) {
+        return 'gradle';
+      }
+      try {
+        execSync('gradle --version', { stdio: 'pipe', timeout: 5000 });
+        return 'gradle';
+      } catch {
+        // gradle not available
+      }
+    }
+
+    return null;
+  }
+
+  private runMaven(options: RunMutationOptions): Promise<MutationRunOutcome> {
+    return new Promise((resolve) => {
+      const child = spawn(
+        'mvn',
+        [
+          'test-compile',
+          'org.pitest:pitest-maven:mutationCoverage',
+          '-DoutputFormats=JSON',
+        ],
+        {
+          stdio: 'pipe',
+          shell: false,
+          cwd: options.cwd,
+        },
+      );
+
+      let stderr = '';
+      let stdout = '';
+
+      child.stdout?.on('data', (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        setTimeout(() => {
+          if (!child.killed) child.kill('SIGKILL');
+        }, 5000);
+      }, options.timeoutMs);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+
+        if (code === null) {
+          resolve({ report: null, timedOut: true });
+          return;
+        }
+
+        const report = this.parsePitestJson(options.cwd, 'maven');
+        resolve({
+          report,
+          timedOut: false,
+          error: code !== 0 ? stderr || stdout : undefined,
+        });
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timeoutId);
+        resolve({ report: null, timedOut: false, error: err.message });
+      });
+    });
+  }
+
+  private runGradle(options: RunMutationOptions): Promise<MutationRunOutcome> {
+    return new Promise((resolve) => {
+      const gradlewPath = join(options.cwd, 'gradlew');
+      const gradleCmd = existsSync(gradlewPath) ? gradlewPath : 'gradle';
+
+      const child = spawn(gradleCmd, ['pitest'], {
+        stdio: 'pipe',
+        shell: false,
+        cwd: options.cwd,
+      });
+
+      let stderr = '';
+      let stdout = '';
+
+      child.stdout?.on('data', (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill('SIGTERM');
+        setTimeout(() => {
+          if (!child.killed) child.kill('SIGKILL');
+        }, 5000);
+      }, options.timeoutMs);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+
+        if (code === null) {
+          resolve({ report: null, timedOut: true });
+          return;
+        }
+
+        const report = this.parsePitestJson(options.cwd, 'gradle');
+        resolve({
+          report,
+          timedOut: false,
+          error: code !== 0 ? stderr || stdout : undefined,
+        });
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timeoutId);
+        resolve({ report: null, timedOut: false, error: err.message });
+      });
+    });
+  }
+
+  private findMavenReportPath(cwd: string): string | null {
+    const reportsDir = join(cwd, 'target', 'pit-reports');
+    if (!existsSync(reportsDir)) return null;
+    for (const entry of readdirSync(reportsDir)) {
+      const candidate = join(reportsDir, entry, 'mutations.json');
+      if (existsSync(candidate)) return candidate;
+    }
+    return null;
+  }
+
+  private findGradleReportPath(cwd: string): string | null {
+    const candidate = join(cwd, 'build', 'reports', 'pitest', 'mutations.json');
+    return existsSync(candidate) ? candidate : null;
+  }
+
+  private computeScore(data: PitestJsonReport): MutationRunResult | null {
+    if (!data.mutations || data.mutations.length === 0) return null;
+    const nrOfKilledMutants = data.mutations.filter(
+      (m) => m.status === 'KILLED',
+    ).length;
+    const nrOfMutants = data.mutations.length;
+    const nrOfSurvivedMutants = nrOfMutants - nrOfKilledMutants;
+    const mutationScore = nrOfMutants === 0
+      ? 0
+      : (nrOfKilledMutants / nrOfMutants) * 100;
+    return { mutationScore, nrOfMutants, nrOfKilledMutants, nrOfSurvivedMutants };
+  }
+
+  /**
+   * Locate and parse the PITest JSON report file.
+   *
+   * Maven writes mutations.json under a timestamped subdirectory:
+   *   target/pit-reports/<YYYYMMDDHHMM>/mutations.json
+   * This method scans all subdirectories to find the latest report.
+   *
+   * Gradle writes to: build/reports/pitest/mutations.json
+   */
+  private parsePitestJson(
+    cwd: string,
+    buildTool: 'maven' | 'gradle',
+  ): MutationRunResult | null {
+    try {
+      const jsonPath = buildTool === 'maven'
+        ? this.findMavenReportPath(cwd)
+        : this.findGradleReportPath(cwd);
+      if (!jsonPath) return null;
+      const data: PitestJsonReport = JSON.parse(readFileSync(jsonPath, 'utf-8'));
+      return this.computeScore(data);
+    } catch {
+      return null;
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/xp-gate",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "description": "AI-driven development workflow: 6 quality gates + Delphi review + Sprint Flow",
   "bin": {
     "xp-gate": "./bin/xp-gate.js"

package/plugins/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "xp-gate",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "displayName": "XP-Gate",
   "description": "Extreme Programming quality gates + AI workflow skills for Claude Code. Includes 10 quality gates (Gate 0-9), Sprint Flow (11 phases), and Delphi multi-expert review (>=90% consensus).",
   "author": {

package/plugins/claude-code/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-06-30
-**Commit:** f1117d4
-**Branch:** main
-**Version:** 0.11.3.0
+**Generated:** 2026-07-01
+**Commit:** a5ef11d
+**Branch:** sprint/2026-06-30-01
+**Version:** 0.11.4.0
 
 ## OVERVIEW
 Delphi Consensus Review — multi-round anonymous expert review (≥90% threshold, 3 experts from ≥2 providers, domestic models only). Supports design + code-walkthrough modes.

package/plugins/claude-code/skills/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
-**Generated:** 2026-06-30
-**Commit:** f1117d4
-**Branch:** main
-**Version:** 0.11.3.0
+**Generated:** 2026-07-01
+**Commit:** a5ef11d
+**Branch:** sprint/2026-06-30-01
+**Version:** 0.11.4.0
 
 ## OVERVIEW
 **11-phase** development pipeline: ISOLATE → AUTO-ESTIMATE → THINK → PLAN → BUILD → REVIEW → SHIP → LAND → USER ACCEPTANCE → FEEDBACK → CLEANUP. Phase 2 default build mode is **ralph-loop** (REQ-level iteration, 40-67% token savings vs parallel). HARD-GATE in Phase 1: design must pass Delphi review (≥90% consensus) before any coding.

package/plugins/claude-code/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
-**Generated:** 2026-06-30
-**Commit:** f1117d4
-**Branch:** main
-**Version:** 0.11.3.0
+**Generated:** 2026-07-01
+**Commit:** a5ef11d
+**Branch:** sprint/2026-06-30-01
+**Version:** 0.11.4.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.