agentic-qe 3.15.15 → 3.15.17

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

@@ -16,6 +16,7 @@ import { createDomainFinding, } from '../../coordination/consensus/domain-findin
 // CQ-002: Base domain coordinator
 import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
 import { toError } from '../../shared/error-utils.js';
+import { isPythonTestFile } from '../../shared/pytest-junit-report.js';
 import { createMinCutTestOptimizer, } from './services/mincut-test-optimizer.js';
 // ============================================================================
 // Coordinator Configuration
@@ -146,6 +147,8 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             });
         }
         const framework = request.framework ?? this.detectFramework(testsToRun);
+        // #1272: without an explicit framework, each runner project's config decides.
+        const frameworkFromConfig = request.framework === undefined;
         const workers = request.workers ?? Math.min(4, Math.max(1, testsToRun.length));
         // Batched runners own internal parallelism, so the timeout applies to the
         // whole discovered suite rather than one file.
@@ -157,17 +160,21 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             return this.executeParallel({
                 testFiles: testsToRun,
                 framework,
+                frameworkFromConfig,
                 workers,
                 timeout,
                 retryCount: request.retryCount,
+                projectRoot: request.projectRoot,
             });
         }
         // Sequential execution
         return this.execute({
             testFiles: testsToRun,
             framework,
+            frameworkFromConfig,
             timeout,
             retryCount: request.retryCount,
+            projectRoot: request.projectRoot,
         });
     }
     /**
@@ -176,7 +183,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
      * as passed and flaky in the run's own counts (#1170). When that changes
      * the outcome, the run is stored again with it (#1176).
      */
-    async retryFailures(run, retryCount, testFiles) {
+    async retryFailures(run, retryCount, testFiles, projectRoot) {
         if (!retryCount || retryCount <= 0)
             return;
         if (run.failed === 0) {
@@ -188,6 +195,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             failedTests: run.failedTests.map(t => t.testId),
             maxRetries: retryCount,
             backoff: 'exponential',
+            projectRoot,
         });
         if (!retried.success)
             return;
@@ -195,9 +203,13 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
         await this.executor.recordFinalOutcome(run, testFiles);
     }
     /**
-     * Detect test framework from file patterns and project configuration
+     * Fallback framework from file names. With no explicit framework, each
+     * runner project's own config still decides between jest and vitest (#1272),
+     * and Python files always run with pytest (#1248).
      */
     detectFramework(testFiles) {
+        if (testFiles.every(isPythonTestFile))
+            return 'pytest';
         // Check file patterns for common framework indicators
         const hasVitestPattern = testFiles.some(f => f.includes('.test.') || f.includes('.spec.'));
         const hasMochaPattern = testFiles.some(f => f.includes('_test.') || f.includes('.mocha.'));
@@ -206,7 +218,6 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             return 'vitest';
         if (hasMochaPattern)
             return 'mocha';
-        // Could add project config detection here (vitest.config.ts, jest.config.js, etc.)
         return 'vitest';
     }
     /**
@@ -258,7 +269,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 // #1176: these first-attempt failures did happen; flaky analysis
                 // records them even when a retry then passes.
                 const firstAttemptFailures = [...result.value.failedTests];
-                await this.retryFailures(result.value, request.retryCount, orderedTestFiles);
+                await this.retryFailures(result.value, request.retryCount, orderedTestFiles, request.projectRoot);
                 // Record execution results for learning
                 if (this.config.enablePrioritization && prioritizationResult) {
                     await this.recordExecutionResults(runId, orderedTestFiles, result.value, prioritizationResult);
@@ -296,7 +307,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 if (this.config.infraHealing && result.value.failedTests.length > 0) {
                     this.feedInfraHealingFromFailures(result.value.failedTests);
                     // ADR-057: Attempt automatic recovery and re-run affected tests
-                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount });
+                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount, projectRoot: request.projectRoot, frameworkFromConfig: request.frameworkFromConfig });
                     if (rerunResult)
                         return rerunResult;
                 }
@@ -367,7 +378,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             this.activeRuns.delete(runId);
             if (result.success) {
                 // #1176: retries finish before the run is recorded or announced.
-                await this.retryFailures(result.value, request.retryCount, orderedTestFiles);
+                await this.retryFailures(result.value, request.retryCount, orderedTestFiles, request.projectRoot);
                 // Record execution results for learning
                 if (this.config.enablePrioritization && prioritizationResult) {
                     await this.recordExecutionResults(runId, orderedTestFiles, result.value, prioritizationResult);
@@ -407,7 +418,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 if (this.config.infraHealing && result.value.failedTests.length > 0) {
                     this.feedInfraHealingFromFailures(result.value.failedTests);
                     // ADR-057: Attempt automatic recovery and re-run affected tests
-                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount });
+                    const rerunResult = await this.attemptAutoRecoveryAndRerun(result.value.failedTests, request.framework, { timeout: request.timeout, env: request.env, retryCount: request.retryCount, projectRoot: request.projectRoot, frameworkFromConfig: request.frameworkFromConfig });
                     if (rerunResult)
                         return rerunResult;
                 }
@@ -510,6 +521,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             failedTests: testsToRetry,
             maxRetries: request.maxRetries,
             backoff: request.backoff ?? 'exponential',
+            projectRoot: request.projectRoot,
             onRetry: (testId, attempt) => {
                 // Could publish individual retry events here
                 void testId;
@@ -627,9 +639,11 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
         return this.execute({
             testFiles: [...filesToRerun],
             framework,
+            frameworkFromConfig: originalRequest.frameworkFromConfig,
             timeout: originalRequest.timeout,
             env: originalRequest.env,
             retryCount: originalRequest.retryCount,
+            projectRoot: originalRequest.projectRoot,
         });
     }
     /**

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

@@ -47,10 +47,20 @@ export interface ISimpleTestRequest {
     timeout?: number;
     /** Number of parallel workers (default: auto based on file count) */
     workers?: number;
+    /**
+     * #1247: directory to run every file from, already checked to be inside the
+     * project. When omitted, each file runs from its nearest runner project.
+     */
+    projectRoot?: string;
 }
 export interface IExecuteTestsRequest {
     testFiles: string[];
     framework: string;
+    /**
+     * #1272: the caller named no framework, so each runner project's own config
+     * chooses jest or vitest; `framework` is used where it names neither.
+     */
+    frameworkFromConfig?: boolean;
     timeout?: number;
     env?: Record<string, string>;
     reporters?: string[];
@@ -59,6 +69,11 @@ export interface IExecuteTestsRequest {
      * or TestRunCompleted is published, so both carry the final outcome.
      */
     retryCount?: number;
+    /**
+     * #1247: directory to run every file from, already checked to be inside the
+     * project. When omitted, each file runs from its nearest runner project.
+     */
+    projectRoot?: string;
 }
 export interface IParallelExecutionRequest extends IExecuteTestsRequest {
     workers: number;
@@ -173,6 +188,8 @@ export interface IRetryRequest {
     failedTests: string[];
     maxRetries: number;
     backoff?: 'linear' | 'exponential';
+    /** #1247: the run's explicit projectRoot; retries run from it too. */
+    projectRoot?: string;
 }
 export interface IRetryResult {
     originalFailed: number;

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

@@ -5,6 +5,7 @@
 import { err } from '../../shared/types/index.js';
 import { BaseDomainPlugin } from '../domain-interface.js';
 import { requirePayloadFiles } from '../../shared/io/payload-path-guard.js';
+import { requireTestRunTargets } from '../../shared/test-runner-project.js';
 import { createTestExecutionCoordinator } from './coordinator.js';
 import { getGlobalInfraHealing } from '../../strange-loop/infra-healing/global-instance.js';
 import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
@@ -65,22 +66,27 @@ export class TestExecutionPlugin extends BaseDomainPlugin {
                     // directories (#909 Jest targets) inside the project, passed on as the
                     // real paths that were checked. A missing one is still reported by the
                     // runner.
+                    // #1247: an explicit projectRoot is confined the same way.
                     let testFiles;
+                    let projectRoot;
                     if (payload.testFiles !== undefined) {
-                        const confined = await requirePayloadFiles('execute-tests', 'testFiles', payload.testFiles, { allowMissing: true, allowDirectory: true });
+                        const confined = await requireTestRunTargets('execute-tests', payload.testFiles, payload.projectRoot);
                         if (!confined.success)
                             return confined;
-                        testFiles = confined.value;
+                        ({ testFiles, projectRoot } = confined.value);
                     }
                     // Support both simple and full request formats
                     if (testFiles) {
                         // Simple request format
                         const request = {
                             testFiles,
+                            // #1272: an explicit framework wins over the project's config.
+                            framework: typeof payload.framework === 'string' ? payload.framework : undefined,
                             parallel: payload.parallel,
                             retryCount: payload.retryCount,
                             timeout: payload.timeout,
                             workers: payload.workers,
+                            projectRoot,
                         };
                         return this.coordinator.runTests(request);
                     }

package/dist/domains/test-execution/services/flaky-detector.d.ts

@@ -39,7 +39,8 @@ export interface FlakyDetectorConfig {
      */
     testRunnerArgs: string[];
     /**
-     * Working directory for test execution.
+     * Working directory for test execution. When omitted, each file runs from
+     * its nearest runner project, as test_execute_parallel does (#1247, #1272).
      */
     cwd?: string;
     /**
@@ -112,6 +113,13 @@ export declare class FlakyDetectorService implements IFlakyTestDetector {
     /** Cache TTL for analysis results (1 hour) */
     private readonly ANALYSIS_CACHE_TTL_MS;
     constructor(memory: MemoryBackend, config?: Partial<FlakyDetectorConfig>);
+    /** True when the caller chose the runner command; else the project's config picks it. */
+    private readonly runnerConfigured;
+    /**
+     * #1272: the runner command for a run started in `cwd`. A configured command
+     * is used as given; the default runs Jest in a project configured for Jest.
+     */
+    private runnerCommandIn;
     /**
      * Detect flaky tests by running them multiple times
      */

package/dist/domains/test-execution/services/flaky-detector.js

@@ -14,6 +14,7 @@ import { safeJsonParse } from '../../../shared/safe-json.js';
 import { getTestRunnerExecutionError } from '../../../shared/test-runner-verdict.js';
 import { createVitestJsonReport, needsVitestJsonReportFile } from '../../../shared/vitest-json-report.js';
 import { isJestCommand, jestExactPathPattern, runnerFilePath } from '../../../shared/test-runner-args.js';
+import { runnerCwdFor, runnerFrameworkFor } from '../../../shared/test-runner-project.js';
 import { secureRandom } from '../../../shared/utils/crypto-random.js';
 import { redactFailureText } from './runner-test-cases.js';
 const DEFAULT_FLAKY_CONFIG = {
@@ -41,6 +42,19 @@ export class FlakyDetectorService {
     constructor(memory, config = {}) {
         this.memory = memory;
         this.config = { ...DEFAULT_FLAKY_CONFIG, ...config };
+        this.runnerConfigured = config.testRunner !== undefined || config.testRunnerArgs !== undefined;
+    }
+    /** True when the caller chose the runner command; else the project's config picks it. */
+    runnerConfigured;
+    /**
+     * #1272: the runner command for a run started in `cwd`. A configured command
+     * is used as given; the default runs Jest in a project configured for Jest.
+     */
+    runnerCommandIn(cwd) {
+        if (!this.runnerConfigured && runnerFrameworkFor(cwd) === 'jest') {
+            return { runner: 'npx', runnerArgs: ['jest', '--json'] };
+        }
+        return { runner: this.config.testRunner, runnerArgs: this.config.testRunnerArgs };
     }
     /**
      * Detect flaky tests by running them multiple times
@@ -259,20 +273,24 @@ export class FlakyDetectorService {
         const runId = uuidv4();
         const startTime = Date.now();
         return new Promise((resolve, reject) => {
-            const cwd = this.config.cwd ?? process.cwd();
+            const fileBase = this.config.cwd ?? process.cwd();
+            // #1272: a runner loads the config of the directory it starts in, so the
+            // file runs from its own runner project (the file path stays absolute).
+            const cwd = this.config.cwd ?? runnerCwdFor(file);
+            const { runner, runnerArgs } = this.runnerCommandIn(cwd);
             // #909: pass an absolute path (never read as a flag); Jest reads it as a
             // regex, so escape and anchor it to select exactly this file.
-            const fileArg = isJestCommand([this.config.testRunner, ...this.config.testRunnerArgs])
-                ? jestExactPathPattern(file, cwd)
-                : runnerFilePath(file, cwd);
-            const baseArgs = [...this.config.testRunnerArgs, fileArg];
+            const fileArg = isJestCommand([runner, ...runnerArgs])
+                ? jestExactPathPattern(file, fileBase)
+                : runnerFilePath(file, fileBase);
+            const baseArgs = [...runnerArgs, fileArg];
             // Vitest 5 writes --reporter=json output to a file, not stdout. Detect
             // Vitest from the runner command too (testRunner: 'vitest', args: ['run', ...]).
-            const report = needsVitestJsonReportFile([this.config.testRunner, ...baseArgs])
+            const report = needsVitestJsonReportFile([runner, ...baseArgs])
                 ? createVitestJsonReport()
                 : undefined;
             const args = report ? [...baseArgs, ...report.args] : baseArgs;
-            const child = spawn(this.config.testRunner, args, {
+            const child = spawn(runner, args, {
                 cwd,
                 env: { ...process.env, ...this.config.env },
                 stdio: ['ignore', 'pipe', 'pipe'],
@@ -295,7 +313,7 @@ export class FlakyDetectorService {
                 clearTimeout(timeout);
                 report?.cleanup();
                 reject(new Error(`Failed to execute test runner: ${error.message}. ` +
-                    `Ensure ${this.config.testRunner} is installed and accessible.`));
+                    `Ensure ${[runner, ...runnerArgs.slice(0, 1)].join(' ')} is installed and accessible.`));
             });
             child.on('close', (code) => {
                 clearTimeout(timeout);

package/dist/domains/test-execution/services/retry-handler.d.ts

@@ -8,7 +8,7 @@ import { MemoryBackend } from '../../../kernel/interfaces';
 /**
  * Supported test runners for retry execution
  */
-export type TestRunner = 'vitest' | 'jest' | 'mocha' | 'auto';
+export type TestRunner = 'vitest' | 'jest' | 'mocha' | 'pytest' | 'auto';
 /**
  * Configuration for the retry handler service
  */
@@ -74,6 +74,8 @@ export interface RetryExecutionRequest {
     baseDelay?: number;
     maxDelay?: number;
     onRetry?: (testId: string, attempt: number) => void;
+    /** #1247: the run's explicit projectRoot; every retry runs from it. */
+    projectRoot?: string;
 }
 export interface RetryStatistics {
     totalRetries: number;
@@ -157,6 +159,12 @@ export declare class RetryHandlerService implements IRetryHandler {
      * Spawn a test process and parse the result
      */
     private spawnTestProcess;
+    /**
+     * #1248: a pytest retry passes only when its JUnit report shows the test
+     * passed. A node id pytest cannot find (exit code 4) or no collected test
+     * (exit code 5) reran nothing.
+     */
+    private parsePytestRetry;
     /**
      * Parse test runner output to determine pass/fail status
      */

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

@@ -6,6 +6,8 @@ import { LoggerFactory } from '../../../logging/index.js';
 import { spawn } from 'node:child_process';
 import { createVitestJsonReport } from '../../../shared/vitest-json-report.js';
 import { jestExactPathPattern, nameFilterArg, runnerFilePath } from '../../../shared/test-runner-args.js';
+import { runnerCwdFor } from '../../../shared/test-runner-project.js';
+import { createPytestJunitReport, isPythonTestFile, parsePytestJunitXml, pytestCommand, PYTEST_ENV, } from '../../../shared/pytest-junit-report.js';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 import { ok, err } from '../../../shared/types/index.js';
@@ -92,7 +94,7 @@ export class RetryHandlerService {
      * Execute failed tests with retry logic
      */
     async executeWithRetry(request) {
-        const { runId, failedTests, maxRetries, backoff, baseDelay = 1000, maxDelay = 30000, onRetry, } = request;
+        const { runId, failedTests, maxRetries, backoff, baseDelay = 1000, maxDelay = 30000, onRetry, projectRoot, } = request;
         try {
             const stats = {
                 runId,
@@ -108,7 +110,7 @@ export class RetryHandlerService {
             const unmatched = [];
             const tests = [];
             for (const test of failedTests) {
-                const result = await this.retryTest(test, maxRetries, backoff, baseDelay, maxDelay, onRetry);
+                const result = await this.retryTest(test, maxRetries, backoff, baseDelay, maxDelay, onRetry, projectRoot);
                 stats.totalRetries += result.attempts;
                 if (result.passed) {
                     nowPassing.push(test.testId);
@@ -228,7 +230,7 @@ export class RetryHandlerService {
                 return false;
         }
     }
-    async retryTest(test, maxRetries, backoff, baseDelay, maxDelay, onRetry) {
+    async retryTest(test, maxRetries, backoff, baseDelay, maxDelay, onRetry, projectRoot) {
         let attempts = 0;
         // #1122: the final error is persisted in retry-history, so keep it redacted.
         let lastError = redactFailureText(test.error);
@@ -246,7 +248,7 @@ export class RetryHandlerService {
                 onRetry(test.testId, attempts + 1);
             }
             // Execute test (simulated - in real implementation, would run actual test)
-            const result = await this.executeTest(test);
+            const result = await this.executeTest(test, projectRoot);
             // #1141: a filter that selected no test reran nothing. Report that
             // instead of counting it as a retry, and stop: another attempt would
             // select nothing again.
@@ -272,7 +274,7 @@ export class RetryHandlerService {
             finalError: lastError,
         };
     }
-    async executeTest(test) {
+    async executeTest(test, projectRoot) {
         // In simulation mode (for unit testing), use random behavior
         if (this.config.simulateForTesting) {
             const passOnRetry = secureRandom() < this.config.simulatedRetrySuccessRate;
@@ -282,12 +284,12 @@ export class RetryHandlerService {
             };
         }
         // In production mode, actually execute the test
-        return this.executeRealTest(test);
+        return this.executeRealTest(test, projectRoot);
     }
     /**
      * Execute a real test using the configured test runner
      */
-    async executeRealTest(test) {
+    async executeRealTest(test, projectRoot) {
         const testFile = test.file;
         const testName = test.testName;
         const cwd = this.config.cwd ?? process.cwd();
@@ -295,8 +297,12 @@ export class RetryHandlerService {
         if (!existsSync(testFile)) {
             throw new Error(`Test file not found: ${testFile}. Cannot retry non-existent test file.`);
         }
-        // Detect or use configured test runner
-        const runner = await this.detectTestRunner(cwd);
+        // #1247: retry from the same directory as the first run: the caller's
+        // projectRoot, else a configured directory, else the file's runner
+        // project. The file path stays relative to `cwd`.
+        const runCwd = projectRoot ?? this.config.cwd ?? runnerCwdFor(testFile);
+        // Detect or use configured test runner. #1248: a Python file is pytest's.
+        const runner = isPythonTestFile(testFile) ? 'pytest' : await this.detectTestRunner(runCwd);
         if (!runner) {
             throw new Error(`No test runner detected or configured. Install vitest, jest, or mocha, ` +
                 `or configure testRunner in RetryHandlerConfig. Cannot execute retry for: ${testFile}`);
@@ -304,7 +310,7 @@ export class RetryHandlerService {
         // Build command based on runner
         const { command, args, report } = this.buildTestCommand(runner, testFile, testName, cwd);
         // Execute the test
-        return this.spawnTestProcess(command, args, cwd, report, runner === 'vitest' ? testFile : undefined);
+        return this.spawnTestProcess(command, args, runCwd, report, runner === 'vitest' ? testFile : undefined, runner === 'pytest' ? (code, reportText, output) => this.parsePytestRetry(code, reportText, output) : undefined);
     }
     /**
      * Detect which test runner is available in the project
@@ -410,6 +416,13 @@ export class RetryHandlerService {
                         mochaArgs.push(nameFilterArg('mocha', testName));
                     return { command: npx, args: mochaArgs };
                 }
+            case 'pytest':
+                // #1248: the failed test's node id is <file>::<name> (name from the run).
+                {
+                    const report = createPytestJunitReport();
+                    const file = runnerFilePath(testFile, cwd);
+                    return { ...pytestCommand([filterByName ? `${file}::${testName}` : file], report.path), report };
+                }
             default:
                 throw new Error(`Unsupported test runner: ${runner}`);
         }
@@ -417,7 +430,7 @@ export class RetryHandlerService {
     /**
      * Spawn a test process and parse the result
      */
-    spawnTestProcess(command, args, cwd, report, targetFile) {
+    spawnTestProcess(command, args, cwd, report, targetFile, parseReport) {
         return new Promise((resolve, reject) => {
             const timeout = this.config.testTimeout;
             let stdout = '';
@@ -434,7 +447,7 @@ export class RetryHandlerService {
             const proc = spawn(command, args, {
                 cwd,
                 detached: process.platform !== 'win32',
-                env: { ...process.env, FORCE_COLOR: '0', CI: 'true' },
+                env: { ...process.env, FORCE_COLOR: '0', CI: 'true', ...PYTEST_ENV },
             });
             const untrackExit = trackTestRunnerExit(proc);
             const timeoutHandle = setTimeout(() => {
@@ -465,6 +478,10 @@ export class RetryHandlerService {
                 // report to the --outputFile; read it back rather than trusting stdout).
                 try {
                     const reportText = report ? report.read(stdout) : stdout;
+                    if (parseReport) {
+                        settle(resolve, parseReport(code, reportText, `${stderr}\n${stdout}`.trim()));
+                        return;
+                    }
                     if (reportText === undefined) {
                         throw new Error('The current Vitest JSON report is missing for the retry run.');
                     }
@@ -484,6 +501,33 @@ export class RetryHandlerService {
             });
         });
     }
+    /**
+     * #1248: a pytest retry passes only when its JUnit report shows the test
+     * passed. A node id pytest cannot find (exit code 4) or no collected test
+     * (exit code 5) reran nothing.
+     */
+    parsePytestRetry(exitCode, report, output) {
+        const failure = (text) => ({
+            passed: false,
+            error: redactFailureText(text || `pytest exited with code ${exitCode}`).substring(0, 1000),
+        });
+        if (exitCode === 4 || exitCode === 5)
+            return UNMATCHED;
+        if (report === undefined)
+            return failure(output);
+        try {
+            const cases = parsePytestJunitXml(report);
+            if (cases.length === 0)
+                return UNMATCHED;
+            const failed = cases.find(c => c.status === 'failed' || c.status === 'error');
+            if (exitCode === 0 && !failed && cases.some(c => c.status === 'passed'))
+                return { passed: true };
+            return failure(failed ? [failed.message, failed.details].filter(Boolean).join('\n') : output);
+        }
+        catch {
+            return failure(output);
+        }
+    }
     /**
      * Parse test runner output to determine pass/fail status
      */

package/dist/domains/test-execution/services/runner-test-cases.d.ts

@@ -6,6 +6,8 @@
  * derived from aggregate counts.
  */
 import type { ITestCaseResult } from '../interfaces';
+/** A test case's failure text: redacted (#1122) and capped. */
+export declare function testCaseFailureMessage(text: string): string | undefined;
 /**
  * #1122: failure text goes back over MCP and into saved results, so
  * credential-shaped values (e.g. a connection string) are redacted first.

package/dist/domains/test-execution/services/runner-test-cases.js

@@ -12,10 +12,14 @@ const MAX_FAILURE_MESSAGE_LENGTH = 4000;
 function failureMessageOf(assertion) {
     if (!Array.isArray(assertion.failureMessages))
         return undefined;
-    const joined = assertion.failureMessages.filter((m) => typeof m === 'string').join('\n').trim();
-    if (!joined)
+    return testCaseFailureMessage(assertion.failureMessages.filter((m) => typeof m === 'string').join('\n'));
+}
+/** A test case's failure text: redacted (#1122) and capped. */
+export function testCaseFailureMessage(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
         return undefined;
-    const message = redactFailureText(joined);
+    const message = redactFailureText(trimmed);
     return message.length > MAX_FAILURE_MESSAGE_LENGTH
         ? `${message.slice(0, MAX_FAILURE_MESSAGE_LENGTH)}… [truncated]`
         : message;

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

@@ -113,8 +113,9 @@ export declare class TestExecutorService implements ITestExecutionService {
     private mergeSequentialCoverage;
     private executeTestFile;
     private executeTestFiles;
+    private executeProjectFiles;
     /**
-     * Spawn actual test runner process (vitest, jest, mocha)
+     * Spawn actual test runner process (vitest, jest, mocha, node:test, pytest)
      */
     private spawnTestRunner;
     /**
@@ -125,6 +126,10 @@ export declare class TestExecutorService implements ITestExecutionService {
      * Parse test runner output to extract results
      */
     private parseTestOutput;
+    /**
+     * #1248: a pytest run from its JUnit report (undefined when pytest wrote none).
+     */
+    private parsePytestOutput;
     /**
      * Parse the TAP or spec summary emitted by Node's built-in test runner.
      */