agentic-qe 3.13.4 → 3.13.6

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
      */

package/dist/domains/test-execution/services/test-executor.js

@@ -12,6 +12,7 @@ import { TEST_EXECUTION_CONSTANTS, LLM_ANALYSIS_CONSTANTS } from '../../constant
 import { toErrorMessage, toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { secureRandom, secureRandomInt } from '../../../shared/utils/crypto-random.js';
+import { writeQualityEvidence } from '../../quality-assessment/quality-evidence.js';
 const DEFAULT_CONFIG = {
     simulateForTesting: false,
     simulatedTestsPerFile: 5,
@@ -102,8 +103,10 @@ export class TestExecutorService {
                 return err(validation.error);
             }
             const { workers, sharding = 'file', isolation = 'process' } = request;
+            const runnerOwnsParallelism = ['vitest', 'jest'].includes(request.framework.toLowerCase());
+            const processWorkers = runnerOwnsParallelism ? 1 : workers;
             // Shard tests across workers
-            const shards = this.shardTests(request.testFiles, workers, sharding);
+            const shards = this.shardTests(request.testFiles, processWorkers, sharding);
             // Execute shards in parallel
             const shardResults = await Promise.all(shards.map((shard, index) => this.executeWorker(shard, index, isolation, request)));
             // Aggregate results
@@ -132,7 +135,7 @@ export class TestExecutorService {
                 endTime,
                 duration,
                 testsPerSecond: aggregated.total / (duration / 1000),
-                workers,
+                workers: processWorkers,
                 memoryUsage: process.memoryUsage?.().heapUsed ?? 0,
             };
             this.runStats.set(runId, stats);
@@ -327,26 +330,29 @@ Provide:
         };
     }
     async executeTestFile(file, framework, timeout) {
+        return this.executeTestFiles([file], framework, timeout);
+    }
+    async executeTestFiles(files, framework, timeout) {
         // In simulation mode (for unit testing), use random behavior
         if (this.config.simulateForTesting) {
-            return this.simulateTestExecution(file);
+            return this.aggregateResults(files.map(file => this.simulateTestExecution(file)));
         }
         // Production mode: spawn actual test runner process
-        const result = await this.spawnTestRunner(file, framework, timeout);
+        const result = await this.spawnTestRunner(files, framework, timeout);
         if (result.success === false) {
             // Return as a failed test rather than throwing — allows other files to still run
             return {
-                total: 1,
+                total: files.length,
                 passed: 0,
-                failed: 1,
+                failed: files.length,
                 skipped: 0,
-                failedTests: [{
-                        testId: file,
-                        testName: file,
-                        file,
-                        error: result.error.message,
-                        duration: 0,
-                    }],
+                failedTests: files.map(file => ({
+                    testId: file,
+                    testName: file,
+                    file,
+                    error: result.error.message,
+                    duration: 0,
+                })),
                 coverage: this.aggregateCoverage([]),
             };
         }
@@ -355,13 +361,15 @@ Provide:
     /**
      * Spawn actual test runner process (vitest, jest, mocha)
      */
-    async spawnTestRunner(file, framework, timeout) {
+    async spawnTestRunner(files, framework, timeout) {
         // Verify test file exists
-        if (!existsSync(file)) {
-            return err(new Error(`Test file not found: ${file}`));
+        const missingFile = files.find(file => !existsSync(file));
+        if (missingFile) {
+            return err(new Error(`Test file not found: ${missingFile}`));
         }
         // Build command based on framework
-        const { command, args } = this.buildTestCommand(file, framework);
+        const { command, args } = this.buildTestCommand(files, framework);
+        const fileLabel = files.join(', ');
         return new Promise((resolve) => {
             let stdout = '';
             let stderr = '';
@@ -381,7 +389,7 @@ Provide:
             const timeoutId = setTimeout(() => {
                 killed = true;
                 proc.kill('SIGTERM');
-                resolve(err(new Error(`Test execution timed out after ${timeout}ms for file: ${file}`)));
+                resolve(err(new Error(`Test execution timed out after ${timeout}ms for files: ${fileLabel}`)));
             }, timeout);
             proc.stdout?.on('data', (data) => {
                 stdout += data.toString();
@@ -395,10 +403,10 @@ Provide:
                     return; // Already handled by timeout
                 }
                 // Parse results based on framework
-                const parseResult = this.parseTestOutput(stdout, stderr, file, framework, code);
+                const parseResult = this.parseTestOutput(stdout, stderr, fileLabel, framework, code);
                 // If no coverage in stdout JSON, try reading from disk
                 // (vitest/jest write coverage to coverage/coverage-summary.json)
-                if (parseResult.success && !parseResult.value.coverage) {
+                if (parseResult.success && !parseResult.value.coverage && ['vitest', 'jest'].includes(framework.toLowerCase())) {
                     const diskCoverage = this.readCoverageFromDisk();
                     if (diskCoverage) {
                         parseResult.value.coverage = diskCoverage.summary;
@@ -418,33 +426,37 @@ Provide:
     /**
      * Build test command based on framework
      */
-    buildTestCommand(file, framework) {
+    buildTestCommand(fileOrFiles, framework) {
+        const files = Array.isArray(fileOrFiles) ? fileOrFiles : [fileOrFiles];
         switch (framework.toLowerCase()) {
             case 'vitest':
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', file, '--reporter=json', '--no-color',
-                        '--coverage', '--coverage.reporter=json'],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color'],
                 };
             case 'jest':
                 return {
                     command: 'npx',
-                    args: ['jest', file, '--json', '--no-colors', '--testLocationInResults',
-                        '--coverage', '--coverageReporters=json'],
+                    args: ['jest', ...files, '--json', '--no-colors', '--testLocationInResults'],
                 };
             case 'mocha':
                 // Note: mocha has no built-in coverage — requires external nyc/c8 wrapper.
                 // Coverage data will be unavailable for mocha-based test runs.
                 return {
                     command: 'npx',
-                    args: ['mocha', file, '--reporter=json'],
+                    args: ['mocha', ...files, '--reporter=json'],
+                };
+            case 'node':
+            case 'node-test':
+                return {
+                    command: process.execPath,
+                    args: ['--test', ...files],
                 };
             default:
                 // Default to vitest
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', file, '--reporter=json', '--no-color',
-                        '--coverage', '--coverage.reporter=json'],
+                    args: ['vitest', 'run', ...files, '--reporter=json', '--no-color'],
                 };
         }
     }
@@ -460,6 +472,9 @@ Provide:
                     return this.parseJestOutput(stdout, stderr, file, exitCode);
                 case 'mocha':
                     return this.parseMochaOutput(stdout, stderr, file, exitCode);
+                case 'node':
+                case 'node-test':
+                    return this.parseNodeTestOutput(stdout, stderr, file, exitCode);
                 default:
                     return this.parseVitestOutput(stdout, stderr, file, exitCode);
             }
@@ -469,6 +484,47 @@ Provide:
                 `stdout: ${stdout.slice(0, 500)}\nstderr: ${stderr.slice(0, 500)}`));
         }
     }
+    /**
+     * Parse the TAP or spec summary emitted by Node's built-in test runner.
+     */
+    parseNodeTestOutput(stdout, stderr, file, exitCode) {
+        const output = `${stdout}\n${stderr}`;
+        const summary = new Map();
+        for (const match of output.matchAll(/^(?:#|ℹ) (tests|pass|fail|cancelled|skipped|todo) (\d+)\s*$/gm)) {
+            summary.set(match[1], Number(match[2]));
+        }
+        const total = summary.get('tests') ?? 0;
+        if (total === 0) {
+            return err(new Error(`node:test reported zero tests for ${file}`));
+        }
+        const passed = summary.get('pass') ?? 0;
+        const failed = summary.get('fail') ?? 0;
+        const skipped = (summary.get('skipped') ?? 0) +
+            (summary.get('cancelled') ?? 0) +
+            (summary.get('todo') ?? 0);
+        if (exitCode !== 0 && failed === 0) {
+            return err(new Error(`node:test exited with code ${exitCode ?? 'unknown'} for ${file}`));
+        }
+        const failedNames = [
+            ...Array.from(output.matchAll(/^not ok \d+ - (.+)$/gm), match => match[1].trim()),
+            ...Array.from(output.matchAll(/^✖ (.+?)(?: \(|$)/gm), match => match[1].trim()),
+        ];
+        const failedTests = Array.from({ length: failed }, (_, index) => ({
+            testId: uuidv4(),
+            testName: failedNames[index] ?? `node:test failure ${index + 1}`,
+            file,
+            error: stderr.trim() || failedNames[index] || 'Test failed',
+            duration: 0,
+        }));
+        return ok({
+            total,
+            passed,
+            failed,
+            skipped,
+            failedTests,
+            coverage: undefined,
+        });
+    }
     /**
      * Parse vitest JSON output
      */
@@ -762,8 +818,7 @@ Provide:
         return shards;
     }
     async executeWorker(files, _workerIndex, _isolation, request) {
-        const results = await Promise.all(files.map(file => this.executeTestFile(file, request.framework, request.timeout ?? 30000)));
-        return this.aggregateResults(results);
+        return this.executeTestFiles(files, request.framework, request.timeout ?? 30000);
     }
     aggregateResults(results) {
         const aggregated = {
@@ -973,6 +1028,14 @@ Provide:
                     statement: result.coverage.statement ?? 0,
                     files: result.fileCoverages?.length ?? 0,
                 }, { persist: true });
+                if (Number.isFinite(result.coverage.line)) {
+                    await writeQualityEvidence(this.memory, {
+                        coverage: result.coverage.line,
+                    }, {
+                        measuredAt: new Date().toISOString(),
+                        source: 'test-execution coverage',
+                    });
+                }
                 // Store per-file coverage via memory.set() (not storeVector) so that
                 // quality-analyzer's getStoredCoverage() can read it with memory.get()
                 if (result.fileCoverages) {

package/dist/domains/test-generation/gates/test-quality-gate.d.ts

@@ -8,9 +8,9 @@
  * 3. Empty test bodies - it('...', () => {}) with no assertions
  * 4. Mirrored assertions - expected values copy-pasted from source literals
  *
- * All detection is regex-based, no LLM calls.
+ * Detection is deterministic (TypeScript parser plus structural checks), with no LLM calls.
  */
-export type TestQualityIssueType = 'no-source-import' | 'tautological-assertion' | 'empty-test-body' | 'mirrored-assertion';
+export type TestQualityIssueType = 'syntax-error' | 'no-assertions' | 'no-source-import' | 'tautological-assertion' | 'empty-test-body' | 'mirrored-assertion';
 export interface TestQualityIssue {
     type: TestQualityIssueType;
     severity: 'error' | 'warning';
@@ -35,6 +35,12 @@ export interface TestQualityGateConfig {
     /** Minimum score to pass (default: 60) */
     minPassScore: number;
 }
+/**
+ * Return parser errors for generated JavaScript/TypeScript.
+ * This is deliberately exported so generation can reject malformed LLM output
+ * before replacing a valid deterministic template.
+ */
+export declare function getGeneratedTestSyntaxIssues(testCode: string, sourceFilePath: string): TestQualityIssue[];
 export declare class TestQualityGate {
     private readonly config;
     constructor(config?: Partial<TestQualityGateConfig>);

package/dist/domains/test-generation/gates/test-quality-gate.js

@@ -8,8 +8,87 @@
  * 3. Empty test bodies - it('...', () => {}) with no assertions
  * 4. Mirrored assertions - expected values copy-pasted from source literals
  *
- * All detection is regex-based, no LLM calls.
+ * Detection is deterministic (TypeScript parser plus structural checks), with no LLM calls.
  */
+import ts from 'typescript';
+function scriptKindFor(filePath) {
+    if (/\.(?:jsx)$/i.test(filePath))
+        return ts.ScriptKind.JSX;
+    if (/\.(?:tsx)$/i.test(filePath))
+        return ts.ScriptKind.TSX;
+    if (/\.(?:js|mjs|cjs)$/i.test(filePath))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+function isJavaScriptFamily(filePath) {
+    return /\.(?:tsx?|jsx?|mjs|cjs|mts|cts)$/i.test(filePath);
+}
+function parseGeneratedTest(testCode, sourceFilePath) {
+    const extension = sourceFilePath.match(/\.(?:tsx?|jsx?|mjs|cjs|mts|cts)$/i)?.[0] ?? '.ts';
+    return ts.createSourceFile(`generated.test${extension}`, testCode, ts.ScriptTarget.Latest, true, scriptKindFor(sourceFilePath));
+}
+/**
+ * Return parser errors for generated JavaScript/TypeScript.
+ * This is deliberately exported so generation can reject malformed LLM output
+ * before replacing a valid deterministic template.
+ */
+export function getGeneratedTestSyntaxIssues(testCode, sourceFilePath) {
+    if (!isJavaScriptFamily(sourceFilePath))
+        return [];
+    const diagnostics = ts.transpileModule(testCode, {
+        fileName: sourceFilePath,
+        reportDiagnostics: true,
+        compilerOptions: {
+            jsx: ts.JsxEmit.Preserve,
+            module: ts.ModuleKind.ESNext,
+            target: ts.ScriptTarget.Latest,
+        },
+    }).diagnostics ?? [];
+    return diagnostics.map((diagnostic) => {
+        const position = diagnostic.file?.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+        return {
+            type: 'syntax-error',
+            severity: 'error',
+            line: position ? position.line + 1 : undefined,
+            description: `Generated test has invalid syntax: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, ' ')}`,
+            suggestion: 'Repair the generated test syntax before accepting or executing it.',
+        };
+    });
+}
+function hasExecutableAssertion(testCode, sourceFilePath) {
+    if (!isJavaScriptFamily(sourceFilePath)) {
+        return /\b(?:assert\w*|expect)\s*(?:[.(])/i.test(testCode);
+    }
+    const sourceFile = parseGeneratedTest(testCode, sourceFilePath);
+    let found = false;
+    const visit = (node) => {
+        if (found)
+            return;
+        if (ts.isCallExpression(node)) {
+            const expression = node.expression;
+            if (ts.isIdentifier(expression)) {
+                found = expression.text === 'expect' || expression.text === 'assert';
+            }
+            else if (ts.isPropertyAccessExpression(expression)) {
+                let root = expression.expression;
+                while (ts.isPropertyAccessExpression(root))
+                    root = root.expression;
+                if (ts.isIdentifier(root) && root.text === 'assert') {
+                    found = true;
+                }
+                else if (ts.isIdentifier(root)
+                    && root.text === 'expect'
+                    && expression.name.text !== 'assertions'
+                    && expression.name.text !== 'hasAssertions') {
+                    found = true;
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+}
 const DEFAULT_CONFIG = {
     checkSourceImports: true,
     checkTautologicalAssertions: true,
@@ -34,7 +113,15 @@ export class TestQualityGate {
      * @returns Gate result with pass/fail, issues, and score
      */
     validate(testCode, sourceFilePath, sourceCode) {
-        const issues = [];
+        const issues = getGeneratedTestSyntaxIssues(testCode, sourceFilePath);
+        if (!hasExecutableAssertion(testCode, sourceFilePath)) {
+            issues.push({
+                type: 'no-assertions',
+                severity: 'error',
+                description: 'Generated test contains no executable assertions.',
+                suggestion: 'Add at least one assertion that observes behavior from the source under test.',
+            });
+        }
         if (this.config.checkSourceImports) {
             issues.push(...this.detectMissingSourceImports(testCode, sourceFilePath));
         }
@@ -47,8 +134,10 @@ export class TestQualityGate {
         if (this.config.checkMirroredAssertions && sourceCode) {
             issues.push(...this.detectMirroredAssertions(testCode, sourceCode));
         }
-        const score = this.calculateScore(issues);
-        const passed = score >= this.config.minPassScore;
+        const mechanicallyInvalid = issues.some(issue => issue.type === 'syntax-error' || issue.type === 'no-assertions');
+        const hasError = issues.some(issue => issue.severity === 'error');
+        const score = mechanicallyInvalid ? 0 : this.calculateScore(issues);
+        const passed = !hasError && score >= this.config.minPassScore;
         return { passed, issues, score };
     }
     // ============================================================================

package/dist/domains/test-generation/generators/base-test-generator.js

@@ -157,21 +157,6 @@ export class BaseTestGenerator {
                         assertion: 'expect(action).toThrow();',
                     });
                 }
-                else {
-                    // Function has no explicit throw — but may still crash on property access.
-                    // Use try-catch pattern that accepts either behavior.
-                    const undefinedCall = fn.isAsync
-                        ? `await ${fn.name}(${paramsWithUndefined})`
-                        : `${fn.name}(${paramsWithUndefined})`;
-                    testCases.push({
-                        description: `should handle undefined ${param.name}`,
-                        type: 'edge-case',
-                        action: fn.isAsync
-                            ? `let threw = false;\n    try {\n      await ${fn.name}(${paramsWithUndefined});\n    } catch (e) {\n      threw = true;\n      expect(e).toBeInstanceOf(Error);\n    }`
-                            : `let threw = false;\n    try {\n      ${fn.name}(${paramsWithUndefined});\n    } catch (e) {\n      threw = true;\n      expect(e).toBeInstanceOf(Error);\n    }`,
-                        assertion: `expect(true).toBe(true); // function either handles undefined or throws TypeError`,
-                    });
-                }
             }
             // Type-specific boundary tests
             testCases.push(...this.generateBoundaryTestCases(fn, param));