agentic-qe 3.15.15 → 3.15.16

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

@@ -94,12 +94,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 +116,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 +126,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 +149,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));
@@ -284,21 +287,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 +323,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 +359,53 @@ 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); 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 hit = this.fuzzyMatch(queryTokens, stored, scope, filters);
+            if (hit)
+                lexicalHits.push({ ...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 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) {
@@ -390,39 +450,38 @@ export class SemanticAnalyzerService {
     }
     async fuzzySearch(query, limit, scope, filters) {
         const results = [];
-        const keys = await this.memory.search(this.contentKeyPattern(), MAX_INDEXED_FILES_SCANNED);
         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,
-                });
-            }
-        }
+        await this.forEachIndexed((stored) => {
+            const hit = this.fuzzyMatch(queryTokens, stored, scope, filters);
+            if (hit)
+                results.push(hit);
+        });
         // Sort by score and limit
         return results.sort((a, b) => b.score - a.score).slice(0, limit);
     }
+    /** Token-overlap match of one indexed file, or null when it is filtered out or scores too low. */
+    fuzzyMatch(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 {
+            file: stored.file,
+            snippet: this.extractSnippet(stored.content, 200),
+            score,
+            highlights: queryTokens.filter((t) => contentTokens.some((ct) => this.tokensMatch(t, ct))),
+            metadata: stored.metadata,
+        };
+    }
     // ============================================================================
     // Private Analysis Methods
     // ============================================================================
@@ -625,13 +684,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 +742,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/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.js

@@ -160,6 +160,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
                 workers,
                 timeout,
                 retryCount: request.retryCount,
+                projectRoot: request.projectRoot,
             });
         }
         // Sequential execution
@@ -168,6 +169,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             framework,
             timeout,
             retryCount: request.retryCount,
+            projectRoot: request.projectRoot,
         });
     }
     /**
@@ -176,7 +178,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 +190,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             failedTests: run.failedTests.map(t => t.testId),
             maxRetries: retryCount,
             backoff: 'exponential',
+            projectRoot,
         });
         if (!retried.success)
             return;
@@ -258,7 +261,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 +299,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 });
                     if (rerunResult)
                         return rerunResult;
                 }
@@ -367,7 +370,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 +410,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 });
                     if (rerunResult)
                         return rerunResult;
                 }
@@ -510,6 +513,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;
@@ -630,6 +634,7 @@ export class TestExecutionCoordinator extends BaseDomainCoordinator {
             timeout: originalRequest.timeout,
             env: originalRequest.env,
             retryCount: originalRequest.retryCount,
+            projectRoot: originalRequest.projectRoot,
         });
     }
     /**

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

@@ -47,6 +47,11 @@ 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[];
@@ -59,6 +64,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 +183,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,12 +66,14 @@ 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) {
@@ -81,6 +84,7 @@ export class TestExecutionPlugin extends BaseDomainPlugin {
                             retryCount: payload.retryCount,
                             timeout: payload.timeout,
                             workers: payload.workers,
+                            projectRoot,
                         };
                         return this.coordinator.runTests(request);
                     }

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

@@ -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;

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

@@ -6,6 +6,7 @@ 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 { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 import { ok, err } from '../../../shared/types/index.js';
@@ -92,7 +93,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 +109,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 +229,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 +247,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 +273,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 +283,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 +296,12 @@ export class RetryHandlerService {
         if (!existsSync(testFile)) {
             throw new Error(`Test file not found: ${testFile}. Cannot retry non-existent test file.`);
         }
+        // #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
-        const runner = await this.detectTestRunner(cwd);
+        const runner = 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 +309,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);
     }
     /**
      * Detect which test runner is available in the project

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

@@ -113,6 +113,7 @@ export declare class TestExecutorService implements ITestExecutionService {
     private mergeSequentialCoverage;
     private executeTestFile;
     private executeTestFiles;
+    private executeProjectFiles;
     /**
      * Spawn actual test runner process (vitest, jest, mocha)
      */

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

@@ -21,6 +21,7 @@ import { mergeTestCases, redactFailedTests, redactFailureText, testCasesFromRunn
 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 { groupByRunnerProject } from '../../../shared/test-runner-project.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
 import { terminateTestRunner, trackTestRunnerExit } from '../../../shared/test-runner-process.js';
 const DEFAULT_CONFIG = {
@@ -314,7 +315,7 @@ Provide:
         return ok(undefined);
     }
     async runTests(request) {
-        const { testFiles, framework, timeout = 30000 } = request;
+        const { testFiles, framework, timeout = 30000, projectRoot } = request;
         const failedTests = [];
         const coverages = [];
         const allFileCoverages = [];
@@ -323,7 +324,7 @@ Provide:
         let failed = 0;
         let skipped = 0;
         for (const file of testFiles) {
-            const result = await this.executeTestFile(file, framework, timeout);
+            const result = await this.executeTestFile(file, framework, timeout, projectRoot);
             executionResults.push(result);
             passed += result.passed;
             failed += result.failed;
@@ -393,16 +394,34 @@ Provide:
         const coverage = this.extractCoverageFromJson({ coverageMap: merged });
         return coverage.summary ? { summary: coverage.summary, perFile: coverage.perFile } : undefined;
     }
-    async executeTestFile(file, framework, timeout) {
-        return this.executeTestFiles([file], framework, timeout);
+    async executeTestFile(file, framework, timeout, projectRoot) {
+        return this.executeTestFiles([file], framework, timeout, projectRoot);
     }
-    async executeTestFiles(files, framework, timeout) {
+    async executeTestFiles(files, framework, timeout, projectRoot) {
         // In simulation mode (for unit testing), use random behavior
         if (this.config.simulateForTesting) {
             return this.aggregateResults(files.map(file => this.simulateTestExecution(file)));
         }
+        // #1247: a runner loads the config of the directory it starts in, so each
+        // file runs from its own runner project (or the caller's projectRoot).
+        const groups = projectRoot
+            ? [{ cwd: projectRoot, files }]
+            : groupByRunnerProject(files);
+        if (groups.length === 1) {
+            return this.executeProjectFiles(groups[0].files, framework, timeout, groups[0].cwd);
+        }
+        // Each project gets its own runner and timeout. Their coverage maps are
+        // merged from raw counters, or left unmeasured (#1030).
+        const results = await Promise.all(groups.map(group => this.executeProjectFiles(group.files, framework, timeout, group.cwd)));
+        const combined = this.aggregateResults(results);
+        const merged = this.mergeSequentialCoverage(results);
+        combined.coverage = merged?.summary;
+        combined.fileCoverages = merged?.perFile;
+        return combined;
+    }
+    async executeProjectFiles(files, framework, timeout, cwd) {
         // Production mode: spawn actual test runner process
-        const result = await this.spawnTestRunner(files, framework, timeout);
+        const result = await this.spawnTestRunner(files, framework, timeout, cwd);
         if (result.success === false) {
             // Runner/suite errors have no trustworthy assertion receipt to aggregate.
             if (result.error instanceof TestRunnerExecutionError)
@@ -428,7 +447,7 @@ Provide:
     /**
      * Spawn actual test runner process (vitest, jest, mocha)
      */
-    async spawnTestRunner(files, framework, timeout) {
+    async spawnTestRunner(files, framework, timeout, cwd = process.cwd()) {
         // Verify test file exists
         const missingFile = files.find(file => !existsSync(file));
         if (missingFile) {
@@ -466,7 +485,7 @@ Provide:
             let proc;
             try {
                 proc = spawn(command, args, {
-                    cwd: process.cwd(),
+                    cwd,
                     detached: process.platform !== 'win32',
                     env: {
                         ...process.env,
@@ -999,7 +1018,7 @@ Provide:
         return shards;
     }
     async executeWorker(files, _workerIndex, _isolation, request) {
-        return this.executeTestFiles(files, request.framework, request.timeout ?? 30000);
+        return this.executeTestFiles(files, request.framework, request.timeout ?? 30000, request.projectRoot);
     }
     aggregateResults(results) {
         const aggregated = {