agentic-qe 3.15.16 → 3.15.17

package/dist/coordination/handlers/test-execution-handlers.js

@@ -11,10 +11,11 @@ import { toError } from '../../shared/error-utils.js';
 import { capDiagnostics, getTestRunnerExecutionError, TestRunnerExecutionError } from '../../shared/test-runner-verdict.js';
 import { createVitestJsonReport } from '../../shared/vitest-json-report.js';
 import { jestExactPathPattern, runnerFilePath } from '../../shared/test-runner-args.js';
-import { testCasesFromRunnerReport } from '../../domains/test-execution/services/runner-test-cases.js';
+import { testCaseFailureMessage, testCasesFromRunnerReport } from '../../domains/test-execution/services/runner-test-cases.js';
+import { createPytestJunitReport, isPythonTestFile, pytestCommand, pytestRunFromReport, PYTEST_ENV } from '../../shared/pytest-junit-report.js';
 import { runTestRunnerProcess } from '../../shared/test-runner-process.js';
 import { MAX_PAYLOAD_FILE_BYTES, requirePayloadFiles } from '../../shared/io/payload-path-guard.js';
-import { groupByRunnerProject, requireTestRunTargets } from '../../shared/test-runner-project.js';
+import { groupByRunnerProject, requireTestRunTargets, runnerFrameworkFor } from '../../shared/test-runner-project.js';
 function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -58,36 +59,76 @@ export function rewriteTempPathsInGeneratedTest(testCode, sourceFile, tempPath,
     const newRef = sourceFile === tempPath ? (originalFilePath || sourceFile) : sourceFile;
     return { testCode: newCode, sourceFile: newRef };
 }
+/** #1248: run Python test files with pytest, reading its JUnit report. */
+async function runPytestTests(testFiles, cwd) {
+    const report = createPytestJunitReport();
+    try {
+        const { command, args } = pytestCommand(testFiles.map(file => runnerFilePath(file)), report.path);
+        const execution = await runTestRunnerProcess(command, args, { cwd, timeout: 120000, env: { ...process.env, ...PYTEST_ENV } });
+        const output = [execution.stderr, execution.stdout].filter(Boolean).join('\n');
+        if (execution.error || execution.signal) {
+            const reason = execution.error?.message ?? `Terminated by ${execution.signal}`;
+            return err(new TestRunnerExecutionError(`pytest could not complete: ${capDiagnostics(`${reason}\n${output}`)}`));
+        }
+        const run = pytestRunFromReport(report.read(), testFiles, execution.status, output, command);
+        if (!run.success)
+            return run;
+        const testCases = run.value.tests.map(test => {
+            const failureMessage = test.failureMessage && testCaseFailureMessage(test.failureMessage);
+            return {
+                name: test.name, file: test.file, status: test.status,
+                ...(test.duration !== undefined ? { duration: test.duration } : {}),
+                ...(failureMessage ? { failureMessage } : {}),
+            };
+        });
+        const { total, passed, failed, skipped } = run.value;
+        return ok({ total, passed, failed, skipped, testCases });
+    }
+    finally {
+        report.cleanup();
+    }
+}
 /**
  * Run `testFiles` (paths relative to the process cwd, or absolute) with the
  * runner started in `cwd`.
  */
 async function runProjectTests(testFiles, cwd) {
+    if (testFiles.some(isPythonTestFile))
+        return runPytestTests(testFiles, cwd);
     // #1074: run the runner asynchronously so the MCP server keeps serving
     // other requests (task_status, task_cancel, ...) during the test run.
     const options = { cwd, timeout: 120000 };
+    const runJest = () => runTestRunnerProcess('npx', ['jest', ...testFiles.map(file => jestExactPathPattern(file)), '--json'], options);
     let runner = 'vitest';
-    // Vitest 5 writes the JSON report to a file rather than stdout; an explicit
-    // --outputFile gives Vitest 4 and 5 the same contract.
-    const report = createVitestJsonReport();
     let execution;
-    let output;
-    try {
-        // #909: absolute paths cannot be read as flags (e.g. a "--watch" entry).
-        execution = await runTestRunnerProcess('npx', ['vitest', 'run', ...testFiles.map(file => runnerFilePath(file)), '--reporter=json', ...report.args], options);
-        output = execution.error || execution.signal
-            ? ''
-            : report.read(execution.stdout || '') ?? '';
-    }
-    finally {
-        report.cleanup();
-    }
-    // Preserve the existing Jest fallback when Vitest cannot produce a report.
-    if (!output.includes('{') && execution.status !== 0 && !execution.error && !execution.signal) {
+    let output = '';
+    if (runnerFrameworkFor(cwd) === 'jest') {
+        // #1272: a project configured for Jest runs with Jest, never Vitest first.
         runner = 'jest';
-        execution = await runTestRunnerProcess('npx', ['jest', ...testFiles.map(file => jestExactPathPattern(file)), '--json'], options);
+        execution = await runJest();
         output = execution.stdout || '';
     }
+    else {
+        // Vitest 5 writes the JSON report to a file rather than stdout; an explicit
+        // --outputFile gives Vitest 4 and 5 the same contract.
+        const report = createVitestJsonReport();
+        try {
+            // #909: absolute paths cannot be read as flags (e.g. a "--watch" entry).
+            execution = await runTestRunnerProcess('npx', ['vitest', 'run', ...testFiles.map(file => runnerFilePath(file)), '--reporter=json', ...report.args], options);
+            output = execution.error || execution.signal
+                ? ''
+                : report.read(execution.stdout || '') ?? '';
+        }
+        finally {
+            report.cleanup();
+        }
+        // Preserve the existing Jest fallback when Vitest cannot produce a report.
+        if (!output.includes('{') && execution.status !== 0 && !execution.error && !execution.signal) {
+            runner = 'jest';
+            execution = await runJest();
+            output = execution.stdout || '';
+        }
+    }
     const diagnostics = [execution.error?.message, execution.signal && `Terminated by ${execution.signal}`, execution.stderr, output].filter(Boolean).join('\n');
     if (execution.error) {
         return err(new TestRunnerExecutionError(`${runner} could not complete: ${capDiagnostics(diagnostics)}`));
@@ -286,8 +327,11 @@ export function registerTestExecutionHandlers(ctx) {
             }
             // #1247: a runner loads the config of the directory it starts in, so
             // each runner project's files run from that project (or projectRoot).
+            // #1248: Python files run apart from the others, with pytest.
             const groups = projectRoot
-                ? [{ cwd: projectRoot, files: testFiles }]
+                ? [testFiles.filter(isPythonTestFile), testFiles.filter(file => !isPythonTestFile(file))]
+                    .filter(files => files.length > 0)
+                    .map(files => ({ cwd: projectRoot, files }))
                 : groupByRunnerProject(testFiles);
             const totals = { total: 0, passed: 0, failed: 0, skipped: 0 };
             const testCases = [];

package/dist/domains/code-intelligence/services/semantic-analyzer.d.ts

@@ -164,15 +164,20 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
      * vector, so vector search cannot rank them. Match those by text, label the
      * hits 'lexical', and report the result as 'partial-vector' with the counts.
      * Cosine and text-match scores are not comparable, so vector hits come
-     * first (by cosine), then lexical hits (by share of query words found); the
-     * reason says how many text matches the limit left out.
+     * first (by cosine), then lexical hits (by share of query words found, ties
+     * by text relevance, #1287); the reason says how many text matches the
+     * limit left out.
      */
     private withVectorlessFiles;
     /** Word-overlap matching for a semantic query when no vectors can be used. */
     private lexicalSearch;
     private exactSearch;
     private fuzzySearch;
-    /** Token-overlap match of one indexed file, or null when it is filtered out or scores too low. */
+    /**
+     * Token-overlap match of one indexed file, or null when it is filtered out or
+     * scores too low. The score is the share of query words found; `relevance`
+     * only orders equal scores (#1287).
+     */
     private fuzzyMatch;
     private extractConcepts;
     private detectPatterns;

package/dist/domains/code-intelligence/services/semantic-analyzer.js

@@ -6,12 +6,15 @@ import { createHash } from 'node:crypto';
 import { ok, err } from '../../../shared/types/index.js';
 import { NomicEmbedder, EMBEDDING_CONFIG, } from '../../../shared/embeddings/index.js';
 import { toError } from '../../../shared/error-utils.js';
+import { compareTextRelevance, textRelevance } from './text-relevance.js';
 /**
  * #1224: the message for a search over an empty index. "No results" is only
  * reported after searching an index that holds code.
  */
 export const NOTHING_INDEXED_FOR_SEARCH = 'No code is indexed for search yet, so the search was not run. ' +
     'Index the project first (MCP code_index, or `aqe code index <path>`), then search again.';
+/** Highest score first; equal scores by text relevance (#1287). */
+const byScoreThenRelevance = (a, b) => b.hit.score - a.hit.score || compareTextRelevance(a.relevance, b.relevance);
 /** Upper bound on indexed files one exact/fuzzy search reads. */
 const MAX_INDEXED_FILES_SCANNED = 100_000;
 const DEFAULT_CONFIG = {
@@ -60,17 +63,17 @@ export class SemanticAnalyzerService {
                 ...this.config.nomicConfig,
                 enableFallback: false,
             });
-            // Check if Ollama is available
-            const isAvailable = await nomicEmbedder.healthCheck();
-            if (isAvailable) {
+            // #1229: Ollama lists the model under its own name (all-minilm:22m);
+            // the reason says whether Ollama is down or lacks the model.
+            const check = await nomicEmbedder.checkModel();
+            if (check.status === 'available') {
                 this.embedder = nomicEmbedder;
                 // Update dimension to match Nomic's output
                 this.config.embeddingDimension =
                     EMBEDDING_CONFIG.DIMENSIONS;
             }
             else {
-                this.embedderUnavailableReason =
-                    `no embedding model available (Ollama model '${EMBEDDING_CONFIG.MODEL}' is not reachable)`;
+                this.embedderUnavailableReason = `no embedding model available (${check.reason})`;
             }
         }
         else {
@@ -276,7 +279,7 @@ export class SemanticAnalyzerService {
     }
     /** Identifies the model behind stored vectors, so vectors from another model are not compared. */
     embeddingModelId() {
-        return this.embedder instanceof NomicEmbedder ? EMBEDDING_CONFIG.MODEL : 'injected-provider';
+        return this.embedder instanceof NomicEmbedder ? this.embedder.getModelId() : 'injected-provider';
     }
     isCurrentModelVector(metadata) {
         return metadata.embeddingModel === this.embeddingModelId();
@@ -366,8 +369,9 @@ export class SemanticAnalyzerService {
      * vector, so vector search cannot rank them. Match those by text, label the
      * hits 'lexical', and report the result as 'partial-vector' with the counts.
      * Cosine and text-match scores are not comparable, so vector hits come
-     * first (by cosine), then lexical hits (by share of query words found); the
-     * reason says how many text matches the limit left out.
+     * first (by cosine), then lexical hits (by share of query words found, ties
+     * by text relevance, #1287); the reason says how many text matches the
+     * limit left out.
      */
     async withVectorlessFiles(query, vectorHits, limit, scope, filters) {
         const model = this.embeddingModelId();
@@ -383,16 +387,19 @@ export class SemanticAnalyzerService {
             withoutVector++;
             if (vectorFiles.has(stored.file))
                 return;
-            const hit = this.fuzzyMatch(queryTokens, stored, scope, filters);
-            if (hit)
-                lexicalHits.push({ ...hit, matchType: 'lexical' });
+            const match = this.fuzzyMatch(query, queryTokens, stored, scope, filters);
+            if (match)
+                lexicalHits.push({ ...match, hit: { ...match.hit, matchType: 'lexical' } });
         });
         const coverage = { indexedFiles, filesWithVector: indexedFiles - withoutVector };
         if (withoutVector === 0) {
             return { results: vectorHits, mode: 'vector', coverage };
         }
         const byScore = (a, b) => b.score - a.score;
-        const results = [...[...vectorHits].sort(byScore), ...lexicalHits.sort(byScore)].slice(0, limit);
+        const results = [
+            ...[...vectorHits].sort(byScore),
+            ...lexicalHits.sort(byScoreThenRelevance).map((match) => match.hit),
+        ].slice(0, limit);
         const droppedLexical = vectorHits.length + lexicalHits.length - results.length;
         return {
             results,
@@ -449,18 +456,22 @@ export class SemanticAnalyzerService {
         return results;
     }
     async fuzzySearch(query, limit, scope, filters) {
-        const results = [];
+        const matches = [];
         const queryTokens = this.tokenize(query.toLowerCase());
         await this.forEachIndexed((stored) => {
-            const hit = this.fuzzyMatch(queryTokens, stored, scope, filters);
-            if (hit)
-                results.push(hit);
+            const match = this.fuzzyMatch(query, queryTokens, stored, scope, filters);
+            if (match)
+                matches.push(match);
         });
-        // Sort by score and limit
-        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+        // Sort by score, ties by relevance (#1287), and limit
+        return matches.sort(byScoreThenRelevance).slice(0, limit).map((match) => match.hit);
     }
-    /** Token-overlap match of one indexed file, or null when it is filtered out or scores too low. */
-    fuzzyMatch(queryTokens, stored, scope, filters) {
+    /**
+     * Token-overlap match of one indexed file, or null when it is filtered out or
+     * scores too low. The score is the share of query words found; `relevance`
+     * only orders equal scores (#1287).
+     */
+    fuzzyMatch(query, queryTokens, stored, scope, filters) {
         // Apply scope filter
         if (scope && scope.length > 0 && !scope.some((s) => stored.file.includes(s))) {
             return null;
@@ -475,11 +486,14 @@ export class SemanticAnalyzerService {
         if (score < this.config.minScore)
             return null;
         return {
-            file: stored.file,
-            snippet: this.extractSnippet(stored.content, 200),
-            score,
-            highlights: queryTokens.filter((t) => contentTokens.some((ct) => this.tokensMatch(t, ct))),
-            metadata: stored.metadata,
+            hit: {
+                file: stored.file,
+                snippet: this.extractSnippet(stored.content, 200),
+                score,
+                highlights: queryTokens.filter((t) => contentTokens.some((ct) => this.tokensMatch(t, ct))),
+                metadata: stored.metadata,
+            },
+            relevance: textRelevance(query, stored.content),
         };
     }
     // ============================================================================

package/dist/domains/code-intelligence/services/text-relevance.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Agentic QE v3 - Text match relevance (#1287)
+ *
+ * Text matching scores a file by the share of query words it contains, so
+ * every file containing all of them scores 1.0. This ranks those ties by how
+ * well the file matches the query, without changing the score itself.
+ */
+/** How well one file's text matches a query. Higher fields rank first, in this order. */
+export interface TextRelevance {
+    /**
+     * 2: an identifier is exactly the query words (`processOrder`, `process_order`
+     * for "process order"); 1: the query words appear next to each other
+     * (`process the order` does not, `process order` and `processOrderItems` do);
+     * 0: scattered, or the query is a single word.
+     */
+    adjacency: number;
+    /** Share of query words found as a whole word (`order`), not only inside one (`orders`, `reorder`). */
+    exactWords: number;
+    /** Number of words in the file that contain a query word. */
+    occurrences: number;
+}
+/** Splits an identifier into lowercase words: `processOrder`, `process_order`, `PROCESS_ORDER` → process, order. */
+export declare function identifierWords(identifier: string): string[];
+/**
+ * Relevance of `content` to `query`. Words are compared case-insensitively,
+ * and identifiers are split into words, so the query `process order` matches
+ * the identifier `processOrder` as adjacent whole words.
+ */
+export declare function textRelevance(query: string, content: string): TextRelevance;
+/** Sort comparator: more relevant first. */
+export declare function compareTextRelevance(a: TextRelevance, b: TextRelevance): number;
+//# sourceMappingURL=text-relevance.d.ts.map

package/dist/domains/code-intelligence/services/text-relevance.js

@@ -0,0 +1,63 @@
+/**
+ * Agentic QE v3 - Text match relevance (#1287)
+ *
+ * Text matching scores a file by the share of query words it contains, so
+ * every file containing all of them scores 1.0. This ranks those ties by how
+ * well the file matches the query, without changing the score itself.
+ */
+/** Splits an identifier into lowercase words: `processOrder`, `process_order`, `PROCESS_ORDER` → process, order. */
+export function identifierWords(identifier) {
+    return identifier
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .split(/[^A-Za-z0-9]+/)
+        .filter((word) => word.length > 0)
+        .map((word) => word.toLowerCase());
+}
+function identifiers(text) {
+    return text.split(/[^\w]+/).filter((token) => token.length > 0);
+}
+/** Whether `words` appears in `stream` as consecutive entries. */
+function containsRun(stream, words) {
+    outer: for (let i = 0; i + words.length <= stream.length; i++) {
+        for (let j = 0; j < words.length; j++) {
+            if (stream[i + j] !== words[j])
+                continue outer;
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Relevance of `content` to `query`. Words are compared case-insensitively,
+ * and identifiers are split into words, so the query `process order` matches
+ * the identifier `processOrder` as adjacent whole words.
+ */
+export function textRelevance(query, content) {
+    const queryWords = identifiers(query).flatMap(identifierWords);
+    const contentIdentifiers = identifiers(content);
+    const lowerIdentifiers = contentIdentifiers.map((token) => token.toLowerCase());
+    const splitIdentifiers = contentIdentifiers.map(identifierWords);
+    const contentWords = new Set([...lowerIdentifiers, ...splitIdentifiers.flat()]);
+    const queryTokens = identifiers(query.toLowerCase());
+    let adjacency = 0;
+    if (queryWords.length > 1) {
+        const phrase = queryWords.join(' ');
+        if (splitIdentifiers.some((words) => words.join(' ') === phrase))
+            adjacency = 2;
+        else if (containsRun(splitIdentifiers.flat(), queryWords))
+            adjacency = 1;
+    }
+    return {
+        adjacency,
+        exactWords: queryWords.length === 0
+            ? 0
+            : queryWords.filter((word) => contentWords.has(word)).length / queryWords.length,
+        occurrences: lowerIdentifiers.filter((token) => queryTokens.some((qt) => token.includes(qt))).length,
+    };
+}
+/** Sort comparator: more relevant first. */
+export function compareTextRelevance(a, b) {
+    return b.adjacency - a.adjacency || b.exactWords - a.exactWords || b.occurrences - a.occurrences;
+}
+//# sourceMappingURL=text-relevance.js.map

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

@@ -131,7 +131,9 @@ export declare class TestExecutionCoordinator extends BaseDomainCoordinator<Test
      */
     private retryFailures;
     /**
-     * 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).
      */
     private detectFramework;
     /**

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,6 +160,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             return this.executeParallel({
                 testFiles: testsToRun,
                 framework,
+                frameworkFromConfig,
                 workers,
                 timeout,
                 retryCount: request.retryCount,
@@ -167,6 +171,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
         return this.execute({
             testFiles: testsToRun,
             framework,
+            frameworkFromConfig,
             timeout,
             retryCount: request.retryCount,
             projectRoot: request.projectRoot,
@@ -198,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.'));
@@ -209,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';
     }
     /**
@@ -299,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, projectRoot: request.projectRoot });
+                    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;
                 }
@@ -410,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, projectRoot: request.projectRoot });
+                    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;
                 }
@@ -631,6 +639,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
         return this.execute({
             testFiles: [...filesToRerun],
             framework,
+            frameworkFromConfig: originalRequest.frameworkFromConfig,
             timeout: originalRequest.timeout,
             env: originalRequest.env,
             retryCount: originalRequest.retryCount,

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

@@ -56,6 +56,11 @@ export interface ISimpleTestRequest {
 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[];

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

@@ -80,6 +80,8 @@ export class TestExecutionPlugin extends BaseDomainPlugin {
                         // 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,

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
  */
@@ -159,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
      */