agentic-qe 3.15.15 → 3.15.17

package/dist/domains/code-intelligence/interfaces.d.ts

@@ -75,9 +75,18 @@ export interface SearchResults {
      * #1224, semantic searches only: 'vector' when an embedding model ranked the
      * results, 'lexical-only' when none was available and query words were
      * matched against the indexed text instead (`reason` says why).
+     * #1231: 'partial-vector' when only some indexed files have a vector; the
+     * others were matched by text (hits with `matchType: 'lexical'`) and
+     * `coverage` gives the counts.
      */
-    mode?: 'vector' | 'lexical-only';
+    mode?: 'vector' | 'partial-vector' | 'lexical-only';
     reason?: string;
+    /** #1231, semantic searches that ranked by vector: how many indexed files have a vector. */
+    coverage?: SearchVectorCoverage;
+}
+export interface SearchVectorCoverage {
+    indexedFiles: number;
+    filesWithVector: number;
 }
 export interface SearchResult {
     file: string;

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

@@ -11,6 +11,17 @@ import { SearchRequest, SearchResults, SearchResult } from '../interfaces';
  * reported after searching an index that holds code.
  */
 export declare const NOTHING_INDEXED_FOR_SEARCH: string;
+export interface IndexCodeOptions {
+    /** false: store the text only, without asking the embedding model (#1230: it kept failing this run). */
+    embed?: boolean;
+}
+/** What indexCode stored for a file. */
+export interface IndexedCode {
+    /** A vector from the current embedding model was stored. */
+    vector: boolean;
+    /** Set when an embedding model is configured but failed for this file. */
+    vectorFailure?: string;
+}
 /**
  * Interface for the semantic analyzer service
  */
@@ -18,7 +29,7 @@ export interface ISemanticAnalyzerService {
     /** Perform semantic search across codebase */
     search(request: SearchRequest): Promise<Result<SearchResults, Error>>;
     /** Index code for semantic search */
-    indexCode(file: string, content: string): Promise<Result<void, Error>>;
+    indexCode(file: string, content: string, options?: IndexCodeOptions): Promise<Result<IndexedCode, Error>>;
     /** Find semantically similar code */
     findSimilar(code: string, limit?: number): Promise<Result<SearchResult[], Error>>;
     /** Analyze code semantics */
@@ -113,7 +124,7 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     /**
      * Index code content for semantic search
      */
-    indexCode(file: string, content: string): Promise<Result<void, Error>>;
+    indexCode(file: string, content: string, options?: IndexCodeOptions): Promise<Result<IndexedCode, Error>>;
     /**
      * Find semantically similar code
      */
@@ -139,17 +150,35 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     private isCurrentModelVector;
     private vectorKeyPrefix;
     private contentKeyPattern;
+    /** Visits every indexed file's stored content, one at a time. */
+    private forEachIndexed;
     /**
      * #1224: vector search when an embedding model is available. Otherwise (or
      * when no indexed file has a vector from that model) it matches query words
-     * against the indexed text and says so through `lexicalOnlyReason`; no
-     * similarity is invented for those hits.
+     * against the indexed text and reports `mode: 'lexical-only'` with the
+     * reason; no similarity is invented for those hits.
      */
     private semanticSearch;
+    /**
+     * #1231: files indexed while the embedding model was unavailable have no
+     * 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, 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. The score is the share of query words found; `relevance`
+     * only orders equal scores (#1287).
+     */
+    private fuzzyMatch;
     private extractConcepts;
     private detectPatterns;
     private calculateComplexity;
@@ -160,9 +189,10 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     private tokenize;
     private calculateFuzzyScore;
     /**
-     * A content token matches a query token it contains, or that contains it.
-     * #1224: the second direction needs a content token of 3+ characters, so a
-     * one-letter variable such as `i` does not match the query "login".
+     * A query word is found when a content word contains it (or equals it):
+     * "login" is found in `loginWithPassword`. #1279: not the reverse; a query
+     * word such as `stepHandler450` is not found just because the file has the
+     * shorter word `step`, which made almost every file a full match.
      */
     private tokensMatch;
     private matchesFilters;

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 {
@@ -94,12 +97,12 @@ export class SemanticAnalyzerService {
                 return err(new Error(NOTHING_INDEXED_FOR_SEARCH));
             }
             let results;
-            let lexicalOnlyReason;
+            let semanticOutcome = {};
             switch (type) {
                 case 'semantic': {
-                    const semantic = await this.semanticSearch(query, limit, scope, filters);
-                    results = semantic.results;
-                    lexicalOnlyReason = semantic.lexicalOnlyReason;
+                    const { results: hits, ...outcome } = await this.semanticSearch(query, limit, scope, filters);
+                    results = hits;
+                    semanticOutcome = outcome;
                     break;
                 }
                 case 'exact':
@@ -116,11 +119,7 @@ export class SemanticAnalyzerService {
                 results,
                 total: results.length,
                 searchTime,
-                ...(type === 'semantic'
-                    ? lexicalOnlyReason === undefined
-                        ? { mode: 'vector' }
-                        : { mode: 'lexical-only', reason: lexicalOnlyReason }
-                    : {}),
+                ...semanticOutcome,
             });
         }
         catch (error) {
@@ -130,13 +129,13 @@ export class SemanticAnalyzerService {
     /**
      * Index code content for semantic search
      */
-    async indexCode(file, content) {
+    async indexCode(file, content, options = {}) {
         try {
             // Extract code metadata
             const metadata = this.extractCodeMetadata(file, content);
             // #1224: store a vector only when a real embedding model produced one;
             // without it the file is still searchable by text.
-            const embedded = await this.tryEmbed(content);
+            const embedded = options.embed === false ? {} : await this.tryEmbed(content);
             if (embedded.vector) {
                 const key = `${this.vectorKeyPrefix()}${this.fileToKey(file)}`;
                 await this.memory.storeVector(key, embedded.vector, {
@@ -153,8 +152,15 @@ export class SemanticAnalyzerService {
             // namespace, and a write with {namespace} could not be read back without
             // the same option (issue #491 Bug 2) — which silently dropped every
             // search result (#511 follow-up).
-            await this.memory.set(`${this.config.namespace}:content:${this.fileToKey(file)}`, { file, content, metadata });
-            return ok(undefined);
+            const stored = embedded.vector
+                ? { file, content, metadata, embeddingModel: this.embeddingModelId() }
+                : { file, content, metadata };
+            await this.memory.set(`${this.config.namespace}:content:${this.fileToKey(file)}`, stored);
+            return ok(embedded.vector
+                ? { vector: true }
+                : this.embedder && embedded.reason
+                    ? { vector: false, vectorFailure: embedded.reason }
+                    : { vector: false });
         }
         catch (error) {
             return err(toError(error));
@@ -273,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();
@@ -284,21 +290,31 @@ export class SemanticAnalyzerService {
     contentKeyPattern() {
         return `${this.config.namespace}:content:*`;
     }
+    /** Visits every indexed file's stored content, one at a time. */
+    async forEachIndexed(visit) {
+        const keys = await this.memory.search(this.contentKeyPattern(), MAX_INDEXED_FILES_SCANNED);
+        for (const key of keys) {
+            const stored = await this.memory.get(key);
+            if (stored)
+                visit(stored);
+        }
+    }
     // ============================================================================
     // Private Search Methods
     // ============================================================================
     /**
      * #1224: vector search when an embedding model is available. Otherwise (or
      * when no indexed file has a vector from that model) it matches query words
-     * against the indexed text and says so through `lexicalOnlyReason`; no
-     * similarity is invented for those hits.
+     * against the indexed text and reports `mode: 'lexical-only'` with the
+     * reason; no similarity is invented for those hits.
      */
     async semanticSearch(query, limit, scope, filters) {
         const embedded = await this.tryEmbed(query);
         if (!embedded.vector) {
             return {
                 results: await this.lexicalSearch(query, limit, scope, filters),
-                lexicalOnlyReason: embedded.reason,
+                mode: 'lexical-only',
+                reason: embedded.reason,
             };
         }
         // Only this namespace's vectors, from the model that embedded the query.
@@ -310,7 +326,8 @@ export class SemanticAnalyzerService {
         if (vectorResults.length === 0) {
             return {
                 results: await this.lexicalSearch(query, limit, scope, filters),
-                lexicalOnlyReason: `no indexed file has an embedding from ${this.embeddingModelId()}; re-index to enable vector search`,
+                mode: 'lexical-only',
+                reason: `no indexed file has an embedding from ${this.embeddingModelId()}; re-index to enable vector search`,
             };
         }
         // Convert to search results with filtering
@@ -345,7 +362,57 @@ export class SemanticAnalyzerService {
                     break;
             }
         }
-        return { results };
+        return this.withVectorlessFiles(query, results, limit, scope, filters);
+    }
+    /**
+     * #1231: files indexed while the embedding model was unavailable have no
+     * 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, 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();
+        const vectorFiles = new Set(vectorHits.map((hit) => hit.file));
+        const queryTokens = this.tokenize(query.toLowerCase());
+        const lexicalHits = [];
+        let indexedFiles = 0;
+        let withoutVector = 0;
+        await this.forEachIndexed((stored) => {
+            indexedFiles++;
+            if (stored.embeddingModel === model)
+                return;
+            withoutVector++;
+            if (vectorFiles.has(stored.file))
+                return;
+            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(byScoreThenRelevance).map((match) => match.hit),
+        ].slice(0, limit);
+        const droppedLexical = vectorHits.length + lexicalHits.length - results.length;
+        return {
+            results,
+            mode: 'partial-vector',
+            reason: `${withoutVector} of ${indexedFiles} indexed files have no embedding from ${model} ` +
+                '(it was unavailable when they were indexed, or an older aqe version indexed them), ' +
+                'so they were matched by text only (matchType "lexical", listed after the vector hits); ' +
+                (droppedLexical > 0
+                    ? `${droppedLexical} more text match(es) were left out by the limit of ${limit}; `
+                    : '') +
+                're-index to rank them by vector',
+            coverage,
+        };
     }
     /** Word-overlap matching for a semantic query when no vectors can be used. */
     async lexicalSearch(query, limit, scope, filters) {
@@ -389,39 +456,45 @@ export class SemanticAnalyzerService {
         return results;
     }
     async fuzzySearch(query, limit, scope, filters) {
-        const results = [];
-        const keys = await this.memory.search(this.contentKeyPattern(), MAX_INDEXED_FILES_SCANNED);
+        const matches = [];
         const queryTokens = this.tokenize(query.toLowerCase());
-        for (const key of keys) {
-            const stored = await this.memory.get(key);
-            if (!stored)
-                continue;
-            // Apply scope filter
-            if (scope && scope.length > 0) {
-                const matchesScope = scope.some((s) => stored.file.includes(s));
-                if (!matchesScope)
-                    continue;
-            }
-            // Apply filters
-            if (filters && !this.matchesFilters(stored.metadata, filters)) {
-                continue;
-            }
-            // Fuzzy match using token overlap
-            const contentTokens = this.tokenize(stored.content.toLowerCase());
-            const score = this.calculateFuzzyScore(queryTokens, contentTokens);
-            if (score >= this.config.minScore) {
-                const matchedTokens = queryTokens.filter((t) => contentTokens.some((ct) => this.tokensMatch(t, ct)));
-                results.push({
-                    file: stored.file,
-                    snippet: this.extractSnippet(stored.content, 200),
-                    score,
-                    highlights: matchedTokens,
-                    metadata: stored.metadata,
-                });
-            }
-        }
-        // Sort by score and limit
-        return results.sort((a, b) => b.score - a.score).slice(0, limit);
+        await this.forEachIndexed((stored) => {
+            const match = this.fuzzyMatch(query, queryTokens, stored, scope, filters);
+            if (match)
+                matches.push(match);
+        });
+        // 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. 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;
+        }
+        // Apply filters
+        if (filters && !this.matchesFilters(stored.metadata, filters)) {
+            return null;
+        }
+        // Fuzzy match using token overlap
+        const contentTokens = this.tokenize(stored.content.toLowerCase());
+        const score = this.calculateFuzzyScore(queryTokens, contentTokens);
+        if (score < this.config.minScore)
+            return null;
+        return {
+            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),
+        };
     }
     // ============================================================================
     // Private Analysis Methods
@@ -625,13 +698,13 @@ export class SemanticAnalyzerService {
         return matches / queryTokens.length;
     }
     /**
-     * A content token matches a query token it contains, or that contains it.
-     * #1224: the second direction needs a content token of 3+ characters, so a
-     * one-letter variable such as `i` does not match the query "login".
+     * A query word is found when a content word contains it (or equals it):
+     * "login" is found in `loginWithPassword`. #1279: not the reverse; a query
+     * word such as `stepHandler450` is not found just because the file has the
+     * shorter word `step`, which made almost every file a full match.
      */
     tokensMatch(queryToken, contentToken) {
-        return contentToken.includes(queryToken) ||
-            (contentToken.length >= 3 && queryToken.includes(contentToken));
+        return contentToken.includes(queryToken);
     }
     matchesFilters(metadata, filters) {
         for (const filter of filters) {
@@ -683,7 +756,7 @@ export class SemanticAnalyzerService {
         const queryTokens = this.tokenize(query.toLowerCase());
         const contentTokens = this.tokenize(content.toLowerCase());
         for (const qt of queryTokens) {
-            const match = contentTokens.find((ct) => ct.includes(qt) || qt.includes(ct));
+            const match = contentTokens.find((ct) => this.tokensMatch(qt, ct));
             if (match && !highlights.includes(match)) {
                 highlights.push(match);
             }

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/learning-optimization/services/learning-coordinator.js

@@ -512,7 +512,7 @@ Provide:
         const contextFingerprint = `${experience.domain}:${experience.action}`;
         for (const patternId of experience.appliedPatternIds ?? []) {
             try {
-                nullStore.recordNull({
+                await nullStore.recordNullWhenUnlocked({
                     patternId,
                     contextFingerprint,
                     failureMode: String(experience.result.outcome?.error ?? experience.action),

package/dist/domains/quality-assessment/coordinator.js

@@ -284,7 +284,8 @@ export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
             // ADR-070: Record quality gate decision in witness chain
             try {
                 const wc = await getWitnessChain();
-                wc.append(finalResult.passed ? 'QUALITY_GATE_PASS' : 'QUALITY_GATE_FAIL', { gateName: request.gateName, passed: finalResult.passed, score: finalResult.overallScore, failedChecks: finalResult.failedChecks }, 'quality-gate');
+                // #1283: queued, so a locked memory.db does not freeze the MCP server.
+                await wc.appendWhenUnlocked(finalResult.passed ? 'QUALITY_GATE_PASS' : 'QUALITY_GATE_FAIL', { gateName: request.gateName, passed: finalResult.passed, score: finalResult.overallScore, failedChecks: finalResult.failedChecks }, 'quality-gate');
             }
             catch (_wcErr) { /* non-critical */ }
             // ADR-062: Monotonic gate threshold ratcheting

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