agentic-qe 3.15.8 → 3.15.9

package/dist/cli/commands/fleet.js

@@ -230,18 +230,25 @@ export function createFleetCommand(context, cleanupAndExit, ensureInitialized, r
             if (!['test', 'analyze', 'scan'].includes(operation)) {
                 throw new Error(`Unsupported operation: ${operation}`);
             }
+            const operationTasks = {
+                test: ['test-generation', 'generate-tests'],
+                analyze: ['coverage-analysis', 'analyze-coverage'],
+                scan: ['security-compliance', 'scan-security'],
+            };
+            const [domain, taskType] = operationTasks[operation];
+            // #1081: refuse an operation whose task no domain plugin executes,
+            // instead of submitting work that can only fail at dispatch.
+            const executable = context.queen.validateTaskExecutable(taskType, [domain]);
+            if (!executable.success) {
+                console.error(chalk.red(`\n Operation '${operation}' cannot run: ${executable.error.message}`));
+                return cleanupAndExit(1);
+            }
             console.log(chalk.blue(`\n Fleet Operation: ${operation}\n`));
             const progress = new FleetProgressManager({
                 title: `${operation.charAt(0).toUpperCase() + operation.slice(1)} Progress`,
                 showEta: true,
             });
             progress.start(parallelCount);
-            const domainMap = {
-                test: 'test-generation',
-                analyze: 'coverage-analysis',
-                scan: 'security-compliance',
-            };
-            const domain = domainMap[operation];
             const agentOperations = Array.from({ length: parallelCount }, (_, i) => {
                 const agentId = `${operation}-agent-${i + 1}`;
                 return {
@@ -262,9 +269,7 @@ export function createFleetCommand(context, cleanupAndExit, ensureInitialized, r
                 progress.updateAgent(op.id, 0, { status: 'running' });
                 try {
                     const taskResult = await context.queen.submitTask({
-                        type: operation === 'test' ? 'generate-tests' :
-                            operation === 'analyze' ? 'analyze-coverage' :
-                                'scan-security',
+                        type: taskType,
                         priority: 'p1',
                         targetDomains: [domain],
                         payload: { target: options.target, workerId: op.id },

package/dist/cli/handlers/task-handler.js

@@ -5,9 +5,10 @@
  */
 import chalk from 'chalk';
 import { getStatusColor, formatDuration, } from './interfaces.js';
-import { ALL_DOMAINS, isDomainName } from '../../shared/types/index.js';
+import { ALL_DOMAINS, invalidPriorityMessage, isDomainName, isPriority } from '../../shared/types/index.js';
 import { createTimedSpinner } from '../utils/progress.js';
 import { parseJsonOption } from '../helpers/safe-json.js';
+import { validateIndexTaskPayload } from '../../domains/code-intelligence/index-path-guard.js';
 import { writeOutput, toJSON } from '../utils/ci-output.js';
 // ============================================================================
 // Task Handler
@@ -75,6 +76,12 @@ export class TaskHandler {
             console.error(chalk.gray(`  Valid domains: ${ALL_DOMAINS.join(', ')}\n`));
             return this.cleanupAndExit(1);
         }
+        // #1108: reject a priority outside the allowed set. Parity with MCP
+        // `task_submit`.
+        if (!isPriority(options.priority)) {
+            console.error(chalk.red(`\n  ${invalidPriorityMessage(options.priority)}\n`));
+            return this.cleanupAndExit(1);
+        }
         // #734 C: a CLI-submitted task runs inside this process and is not
         // persisted, so a detached submit would report an ID for work that is
         // abandoned when the command exits. Refuse it rather than claim success.
@@ -93,6 +100,19 @@ export class TaskHandler {
             const taskType = type;
             const payload = parseJsonOption(options.payload, 'payload');
             const targetDomains = options.domain ? [options.domain] : [];
+            // #1075: reject a type that no domain plugin executes instead of waiting
+            // out the timeout on a task that can never finish.
+            const executable = context.queen.validateTaskExecutable(taskType, targetDomains);
+            if (!executable.success) {
+                console.error(chalk.red(`\n  ${executable.error.message}\n`));
+                return this.cleanupAndExit(1);
+            }
+            // #1096: same boundary check as MCP task_submit.
+            const payloadError = validateIndexTaskPayload(taskType, payload);
+            if (payloadError) {
+                console.error(chalk.red(`\n  ${payloadError.message}\n`));
+                return this.cleanupAndExit(1);
+            }
             console.log(chalk.blue(`\n  Submitting task: ${taskType}\n`));
             // Use spinner for submit operation
             const spinner = options.progress !== false

package/dist/coordination/handlers/code-intelligence-handlers.js

@@ -10,6 +10,7 @@ import { ok, err } from '../../shared/types/index.js';
 import { toError } from '../../shared/error-utils.js';
 import { discoverSourceFiles } from './handler-utils.js';
 import { resolveProjectRootFromPaths } from '../../domains/code-intelligence/project-root-resolver.js';
+import { nothingIndexedError } from '../../domains/code-intelligence/index-path-guard.js';
 import { createLogger } from '../../logging/logger-factory.js';
 const logger = createLogger('CodeIntelligenceHandlers');
 async function collectProjectMetricsForTarget(ctx, targetPath, indexedFiles) {
@@ -78,11 +79,21 @@ export function registerCodeIntelligenceHandlers(ctx) {
                 return result;
             }
             const indexResult = result.value;
+            // #1096: files were found but none was indexed (e.g. the target is a
+            // symlink out of the project) - fail like the coordinator does.
+            if (indexResult.filesIndexed === 0) {
+                return err(nothingIndexedError(filesToIndex.length, indexResult.skipped ?? [], indexResult.errors));
+            }
+            const notIndexed = new Set([
+                ...(indexResult.skipped ?? []).map((s) => s.path),
+                ...indexResult.errors.map((e) => e.file),
+            ]);
+            const indexedFiles = filesToIndex.filter((file) => !notIndexed.has(file));
             // #999 MCP-CLI parity: `aqe code index` runs the coordinator's project
             // metric step (LOC, tests, tools); run the same step here, rooted at the
             // caller's target the way #997 resolves it. Best-effort: indexing has
             // already succeeded, so a metric failure only omits projectMetrics.
-            const projectMetrics = await collectProjectMetricsForTarget(ctx, targetPath, filesToIndex);
+            const projectMetrics = await collectProjectMetricsForTarget(ctx, targetPath, indexedFiles);
             // Detect languages from files
             const detectedLanguages = new Set();
             const extToLang = {
@@ -95,7 +106,7 @@ export function registerCodeIntelligenceHandlers(ctx) {
                 c: 'c', h: 'c', cpp: 'cpp', hpp: 'cpp', cc: 'cpp',
                 scala: 'scala',
             };
-            for (const file of filesToIndex) {
+            for (const file of indexedFiles) {
                 const ext = path.extname(file).slice(1);
                 const lang = extToLang[ext];
                 if (lang)
@@ -116,6 +127,7 @@ export function registerCodeIntelligenceHandlers(ctx) {
                 duration: indexResult.duration,
                 errors: indexResult.errors,
                 warnings: indexResult.warnings,
+                skipped: indexResult.skipped ?? [],
                 ...(projectMetrics ? { projectMetrics } : {}),
             });
         }

package/dist/coordination/handlers/coverage-collection.js

@@ -22,6 +22,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { parseLcovInfo } from './handler-utils.js';
+import { runTestRunnerProcess } from '../../shared/test-runner-process.js';
 /**
  * Is the "never execute build tooling" kill-switch set?
  *
@@ -402,26 +403,24 @@ export async function collectRustCoverage(targetPath, options = {}) {
     // Honor the opt-out before doing any of that.
     if (isCoverageExecDisabled())
         return null;
-    const { execSync } = await import('child_process');
     const timeout = options.timeoutMs ?? 300000;
     // cargo must run from the crate root, not from whatever subdirectory the
     // caller happened to point at.
     const crateRoot = findCargoRoot(targetPath);
     if (!crateRoot)
         return null;
-    try {
-        execSync('cargo llvm-cov --version', {
-            cwd: crateRoot, timeout: 30000, stdio: ['pipe', 'pipe', 'pipe'],
-        });
-    }
-    catch {
+    // #1074: run cargo asynchronously. The coverage run executes the crate's
+    // whole test suite, and a synchronous call would stop the MCP server
+    // answering any other request for up to `timeout`.
+    const version = await runTestRunnerProcess('cargo', ['llvm-cov', '--version'], { cwd: crateRoot, timeout: 30000 });
+    if (version.error || version.status !== 0) {
         return null; // cargo-llvm-cov not installed — not an error, just unavailable.
     }
     const outPath = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'aqe-rust-cov-')), 'lcov.info');
     try {
-        execSync(`cargo llvm-cov --lcov --output-path ${JSON.stringify(outPath)}`, {
-            cwd: crateRoot, timeout, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
-        });
+        const run = await runTestRunnerProcess('cargo', ['llvm-cov', '--lcov', '--output-path', outPath], { cwd: crateRoot, timeout });
+        if (run.error || run.status !== 0)
+            return null;
         if (!fs.existsSync(outPath))
             return null;
         const parsed = parseLcovInfo(fs.readFileSync(outPath, 'utf-8'));

package/dist/coordination/handlers/coverage-handlers.js

@@ -7,8 +7,9 @@
 import { ok, err } from '../../shared/types/index.js';
 import { toError } from '../../shared/error-utils.js';
 import { buildEstimatedCoverage, collectRustCoverage, findCargoRoot, isCoverageExecDisabled, isRustProject, } from './coverage-collection.js';
-import { describeNoData, evaluateCoverageForTarget, isUnmeasured, resolveExistingCoverage, scopeCoverageToTarget, reconcileRecommendations, thresholdVerdict, } from './coverage-target.js';
+import { describeNoData, evaluateCoverageForTarget, isUnmeasured, packageFilterForTarget, resolveExistingCoverage, scopeCoverageToTarget, reconcileRecommendations, thresholdVerdict, } from './coverage-target.js';
 import { randomUUID } from 'crypto';
+import * as path from 'path';
 import { describeRunFailure, runJsCoverage, testRunStatus } from './coverage-runner.js';
 import { collectedMetrics } from '../../domains/coverage-analysis/collected-metrics.js';
 /**
@@ -80,7 +81,8 @@ async function collectCoverage(targetPath) {
     if (existing.status === 'evaluated') {
         return fromEvaluation(existing.evaluation, false, existing.projectRoot);
     }
-    const { target, projectRoot } = existing;
+    const { target } = existing;
+    let projectRoot = existing.projectRoot;
     // #569 work item 1: delegate to real instrumentation where available.
     if (isRustProject(target)) {
         const rust = await collectRustCoverage(target);
@@ -109,7 +111,23 @@ async function collectCoverage(targetPath) {
     if (isCoverageExecDisabled()) {
         return { collected: buildEstimatedCoverage(target), ranTests: false, projectRoot };
     }
-    const run = await runJsCoverage(projectRoot, { timeoutMs: coverageTimeoutMs() });
+    const pathFilter = packageFilterForTarget(target, projectRoot);
+    let run = await runJsCoverage(projectRoot, {
+        timeoutMs: coverageTimeoutMs(),
+        pathFilter,
+    });
+    // A workspace config may deliberately include only root-level tests. If it
+    // found no tests for this package, restore the nearest-package behavior. The
+    // same fallback permits isolated package installs with no runner at the root.
+    // Do not retry timeouts, crashes or nonempty failing suites: their failures
+    // must remain visible. Only the fallback run's actual report can be measured.
+    const rootRunnerMissing = run.missing && run.numTotalTests === null;
+    const rootHadNoTests = !run.missing && run.numTotalTests === 0
+        && testRunStatus(run) === 'passed' && (run.exitCode === 0 || run.exitCode === 1);
+    if (pathFilter && !run.timedOut && (rootRunnerMissing || rootHadNoTests)) {
+        projectRoot = path.resolve(projectRoot, pathFilter);
+        run = await runJsCoverage(projectRoot, { timeoutMs: coverageTimeoutMs() });
+    }
     // An EMPTY report (`{}`) from a run that reported its tests means "the run
     // instrumented nothing under the target" → unmeasured, never an estimate
     // (#995 review BL2). An empty report from a run that crashed before

package/dist/coordination/handlers/coverage-runner.d.ts

@@ -96,7 +96,7 @@ export declare function runnerBinDirs(projectRoot: string): string[];
  * Pick the runner and its argv. No shell is involved: `command` is the Node
  * binary and `args[0]` the runner's JS entry, so paths are passed verbatim.
  */
-export declare function buildJsCoverageInvocation(projectRoot: string, reportDir: string): JsCoverageInvocation;
+export declare function buildJsCoverageInvocation(projectRoot: string, reportDir: string, pathFilter?: string | null): JsCoverageInvocation;
 /**
  * Synchronously kill every live coverage run and remove its temp dir. Runs from
  * `process.on('exit')`, where only synchronous work is possible.
@@ -134,6 +134,7 @@ export declare function runProcessTree(command: string, args: string[], options:
  */
 export declare function runJsCoverage(projectRoot: string, options?: {
     timeoutMs?: number;
+    pathFilter?: string | null;
 }): Promise<JsCoverageRun>;
 /**
  * One-line, caller-facing explanation of why a run produced no usable report.

package/dist/coordination/handlers/coverage-runner.js

@@ -174,7 +174,7 @@ function usesPlugNPlay(projectRoot) {
  * Pick the runner and its argv. No shell is involved: `command` is the Node
  * binary and `args[0]` the runner's JS entry, so paths are passed verbatim.
  */
-export function buildJsCoverageInvocation(projectRoot, reportDir) {
+export function buildJsCoverageInvocation(projectRoot, reportDir, pathFilter) {
     const resultsFile = path.join(reportDir, RESULTS_FILE);
     const deps = readRunnerDeps(projectRoot);
     let runner = 'vitest';
@@ -200,6 +200,13 @@ export function buildJsCoverageInvocation(projectRoot, reportDir) {
         runnerArgs = ['run', '--coverage', `--coverage.reportsDirectory=${reportDir}`,
             '--coverage.reporter=json', '--coverage.reportOnFailure=true', '--reporter=json', `--outputFile=${resultsFile}`];
     }
+    // A package target run from the workspace root: restrict the run to that
+    // package's tests (vitest/jest positional filter) so a slow sibling cannot
+    // time the run out. nyc/mocha take no such filter.
+    // jest reads the positional as a regex, so escape the directory's metacharacters.
+    if (pathFilter && runner !== 'nyc') {
+        runnerArgs.push(runner === 'jest' ? pathFilter.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') : pathFilter);
+    }
     const bin = findPackageBin(projectRoot, runner === 'jest' ? 'jest' : runner);
     return {
         runner,
@@ -392,7 +399,7 @@ export async function runJsCoverage(projectRoot, options = {}) {
     const timeoutMs = options.timeoutMs ?? 120000;
     const reportDir = fs.mkdtempSync(path.join(os.tmpdir(), 'aqe-js-cov-'));
     try {
-        const inv = buildJsCoverageInvocation(projectRoot, reportDir);
+        const inv = buildJsCoverageInvocation(projectRoot, reportDir, options.pathFilter);
         if (!inv.command) {
             return {
                 runner: inv.runner, missing: true, exitCode: null, exitedCleanly: false, timedOut: false,

package/dist/coordination/handlers/coverage-target.d.ts

@@ -22,9 +22,11 @@ import type { CoverageData, FileCoverage } from '../../domains/coverage-analysis
 /**
  * Walk up from a target to the nearest directory that holds a project marker.
  *
- * NEAREST rather than topmost: in a monorepo, `packages/core/src` belongs to
- * `packages/core` (its own package.json and test config), not the workspace
- * root. This intentionally differs from `kernel/findProjectRoot`, which locates
+ * Normally NEAREST rather than topmost: in a monorepo, `packages/core/src`
+ * belongs to `packages/core` when it has its own runner config. When only the
+ * enclosing workspace has a runner config, use that workspace so test execution
+ * and existing coverage reports use the same configured root (#1005). This
+ * intentionally differs from `kernel/findProjectRoot`, which locates
  * the AQE data root (honouring AQE_PROJECT_ROOT and `.agentic-qe`).
  *
  * Returns `null` when the target does not exist (a typo must not silently
@@ -32,6 +34,14 @@ import type { CoverageData, FileCoverage } from '../../domains/coverage-analysis
  * found below the home directory / filesystem root within `maxDepth` levels.
  */
 export declare function findCoverageProjectRoot(target: string, maxDepth?: number): string | null;
+/**
+ * When `projectRoot` was adopted as a workspace root for a target inside a
+ * nested package, the directory (relative to the root, with a trailing `/`) of
+ * that package, for use as a test-runner path filter so sibling packages' tests
+ * are not run too. `null` when the target is the root itself or no nested
+ * package manifest sits between the target and the root.
+ */
+export declare function packageFilterForTarget(target: string, projectRoot: string): string | null;
 /** Is this path (by name) a coverage report rather than source code? */
 export declare function isCoverageReportFile(filePath: string): boolean;
 /**

package/dist/coordination/handlers/coverage-target.js

@@ -23,6 +23,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { loadCoverageData, parseCoberturaXml, parseCoverageJson, parseCoverageSummaryJson, parseLcovInfo, } from './handler-utils.js';
 import { isTestPath } from './coverage-collection.js';
+import { findProjectRoot } from '../../kernel/project-root.js';
 // ============================================================================
 // Project root
 // ============================================================================
@@ -38,12 +39,180 @@ const PROJECT_ROOT_MARKERS = [
     'pom.xml', 'build.gradle', 'build.gradle.kts',
     '.git',
 ];
+const JS_RUNNER_CONFIGS = [
+    'vitest.config.ts', 'vitest.config.js', 'vitest.config.mts', 'vitest.config.mjs',
+    'vitest.config.cts', 'vitest.config.cjs',
+    'vitest.workspace.ts', 'vitest.workspace.js', 'vitest.workspace.mts',
+    'vitest.workspace.mjs', 'vitest.workspace.json',
+    'vite.config.ts', 'vite.config.js', 'vite.config.mts', 'vite.config.mjs',
+    'jest.config.ts', 'jest.config.js', 'jest.config.mts', 'jest.config.mjs',
+    'jest.config.cts', 'jest.config.cjs', 'jest.config.json',
+];
+function hasJsRunnerConfig(dir) {
+    if (JS_RUNNER_CONFIGS.some(name => fs.existsSync(path.join(dir, name))))
+        return true;
+    // Jest also accepts inline configuration: `"jest": { ... }` in package.json.
+    return readPackageJson(dir)?.jest !== undefined;
+}
+/**
+ * The runner a package.json declares through its dependencies, mirroring the
+ * precedence of the coverage runner (jest, then mocha/nyc, then vitest).
+ * `null` when it declares none. Jest and vitest run with no config file at all,
+ * so a dependency is as good a declaration as a config.
+ */
+function declaredRunner(dir) {
+    const pkg = readPackageJson(dir);
+    if (!pkg)
+        return null;
+    const deps = {
+        ...pkg.devDependencies,
+        ...pkg.dependencies,
+    };
+    if (deps['jest'] || deps['@jest/core'])
+        return 'jest';
+    if (deps['mocha'] || deps['nyc'])
+        return 'nyc';
+    if (deps['vitest'])
+        return 'vitest';
+    return null;
+}
+/** mocha/nyc are configured by dotfiles rather than a runner config module. */
+function hasMochaOrNycConfig(dir) {
+    try {
+        return fs.readdirSync(dir).some(name => /^\.(mocharc|nycrc)(\.|$)/.test(name));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * May a package inherit the runner config of workspace `rootDir`? Only when it
+ * does not bring its own runner: a package that declares a different runner
+ * (e.g. jest under a vitest root) must keep running that one, from its own
+ * directory. With no runner declared at the root the runner defaults to vitest.
+ */
+function packageCanUseRootRunner(pkgDir, rootDir) {
+    if (hasMochaOrNycConfig(pkgDir))
+        return (declaredRunner(rootDir) ?? 'vitest') === 'nyc';
+    const own = declaredRunner(pkgDir);
+    return own === null || own === (declaredRunner(rootDir) ?? 'vitest');
+}
+function readPackageJson(dir) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+        return typeof parsed === 'object' && parsed !== null ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The workspace patterns a root declares: npm/yarn `workspaces` (array or
+ * `{ packages: [...] }`) or pnpm's `packages:` list. `null` = not a workspace
+ * root. Patterns are returned as written (negations keep their `!`).
+ */
+function readWorkspacePatterns(dir) {
+    const patterns = [];
+    let isRoot = false;
+    const pkg = readPackageJson(dir);
+    const ws = pkg?.workspaces;
+    const fromPkg = Array.isArray(ws)
+        ? ws
+        : (typeof ws === 'object' && ws !== null && Array.isArray(ws.packages)
+            ? ws.packages
+            : null);
+    if (ws !== undefined && ws !== null && typeof ws === 'object')
+        isRoot = true;
+    if (fromPkg)
+        patterns.push(...fromPkg.filter((p) => typeof p === 'string'));
+    // Only the block-list `packages:` form is read; the flow form gives no
+    // patterns, so the root is not adopted (fails safe).
+    try {
+        const yaml = fs.readFileSync(path.join(dir, 'pnpm-workspace.yaml'), 'utf-8');
+        isRoot = true;
+        let inPackages = false;
+        for (const raw of yaml.split(/\r?\n/)) {
+            const line = raw.replace(/\s+#.*$/, '').trimEnd();
+            if (/^packages\s*:/.test(line)) {
+                inPackages = true;
+                continue;
+            }
+            if (inPackages) {
+                const m = /^\s+-\s+(.+)$/.exec(line);
+                if (m)
+                    patterns.push(m[1].trim().replace(/^['"]|['"]$/g, ''));
+                else if (/^\S/.test(line))
+                    inPackages = false;
+            }
+        }
+    }
+    catch { /* no pnpm-workspace.yaml */ }
+    return isRoot ? patterns : null;
+}
+function workspaceGlobToRegExp(pattern) {
+    const DEEP_DIR = '\u0000';
+    const DEEP_ANY = '\u0001';
+    const body = pattern.replace(/^\.\//, '').replace(/\/+$/, '')
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*\//g, DEEP_DIR)
+        .replace(/\*\*/g, DEEP_ANY)
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .split(DEEP_DIR).join('(?:.*/)?')
+        .split(DEEP_ANY).join('.*');
+    return new RegExp(`^${body}$`);
+}
+/**
+ * Is `pkgDir` a member of the workspace declared at `rootDir`? Patterns are
+ * resolved relative to the root; a pattern containing a `..` segment or an
+ * absolute path is ignored (it could point outside the root), and `!`
+ * patterns exclude.
+ */
+function isWorkspaceMember(rootDir, pkgDir) {
+    const patterns = readWorkspacePatterns(rootDir);
+    if (!patterns)
+        return false;
+    const rel = path.relative(rootDir, pkgDir).split(path.sep).join('/');
+    if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel))
+        return false;
+    let member = false;
+    for (const raw of patterns) {
+        const negated = raw.startsWith('!');
+        const pattern = negated ? raw.slice(1) : raw;
+        if (path.isAbsolute(pattern) || /^[A-Za-z]:/.test(pattern) || pattern.split(/[\\/]/).includes('..'))
+            continue;
+        if (workspaceGlobToRegExp(pattern).test(rel))
+            member = !negated;
+    }
+    return member;
+}
+/** True when `child` is `parent` or inside it (path-segment aware). */
+function within(child, parent) {
+    const rel = path.relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+/**
+ * The AQE project root, as the ceiling for workspace-root adoption. Runner
+ * configuration is code that gets executed, so it must never be picked up from
+ * above the project (`AQE_PROJECT_ROOT` or the discovered root). `null` when it
+ * cannot be resolved, which disables adoption.
+ */
+function aqeProjectCeiling(start) {
+    try {
+        return fs.realpathSync(path.resolve(findProjectRoot(start)));
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Walk up from a target to the nearest directory that holds a project marker.
  *
- * NEAREST rather than topmost: in a monorepo, `packages/core/src` belongs to
- * `packages/core` (its own package.json and test config), not the workspace
- * root. This intentionally differs from `kernel/findProjectRoot`, which locates
+ * Normally NEAREST rather than topmost: in a monorepo, `packages/core/src`
+ * belongs to `packages/core` when it has its own runner config. When only the
+ * enclosing workspace has a runner config, use that workspace so test execution
+ * and existing coverage reports use the same configured root (#1005). This
+ * intentionally differs from `kernel/findProjectRoot`, which locates
  * the AQE data root (honouring AQE_PROJECT_ROOT and `.agentic-qe`).
  *
  * Returns `null` when the target does not exist (a typo must not silently
@@ -70,18 +239,66 @@ export function findCoverageProjectRoot(target, maxDepth = 12) {
         home = null;
     }
     const start = dir;
+    let nearestRoot = null;
+    let ceiling = null;
     for (let depth = 0; depth <= maxDepth; depth++) {
         // A stray manifest in $HOME must not claim every directory beneath it.
         // $HOME is still a valid root when it is the target itself.
         if (home !== null && dir === home && dir !== start)
-            return null;
-        if (PROJECT_ROOT_MARKERS.some(m => fs.existsSync(path.join(dir, m))))
-            return dir;
+            return nearestRoot;
+        if (!nearestRoot && PROJECT_ROOT_MARKERS.some(m => fs.existsSync(path.join(dir, m)))) {
+            nearestRoot = dir;
+            if (hasJsRunnerConfig(dir))
+                return dir;
+            // Only a nested JS package can inherit the workspace's runner config.
+            // Other project types keep the nearest-marker semantics.
+            if (!fs.existsSync(path.join(dir, 'package.json')))
+                return dir;
+        }
+        else if (nearestRoot && readWorkspacePatterns(dir) !== null) {
+            // Adopt this workspace root (and run its config) only when it is inside
+            // the AQE project and actually lists the nearest package as a member.
+            ceiling ??= aqeProjectCeiling(start) ?? '';
+            if (ceiling && within(dir, ceiling) && within(nearestRoot, ceiling)
+                && isWorkspaceMember(dir, nearestRoot) && hasJsRunnerConfig(dir)
+                && packageCanUseRootRunner(nearestRoot, dir)) {
+                return dir;
+            }
+            return nearestRoot;
+        }
+        // Do not adopt configuration from a different repository.
+        if (nearestRoot && fs.existsSync(path.join(dir, '.git')))
+            return nearestRoot;
         const parent = path.dirname(dir);
         if (parent === dir)
-            return null;
+            return nearestRoot;
         dir = parent;
     }
+    return nearestRoot;
+}
+/**
+ * When `projectRoot` was adopted as a workspace root for a target inside a
+ * nested package, the directory (relative to the root, with a trailing `/`) of
+ * that package, for use as a test-runner path filter so sibling packages' tests
+ * are not run too. `null` when the target is the root itself or no nested
+ * package manifest sits between the target and the root.
+ */
+export function packageFilterForTarget(target, projectRoot) {
+    try {
+        const root = fs.realpathSync(projectRoot);
+        const real = fs.realpathSync(path.resolve(target));
+        let dir = fs.statSync(real).isDirectory() ? real : path.dirname(real);
+        while (dir !== root && within(dir, root)) {
+            if (fs.existsSync(path.join(dir, 'package.json'))) {
+                return `${path.relative(root, dir).split(path.sep).join('/')}/`;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch { /* fall through */ }
     return null;
 }
 // ============================================================================

package/dist/coordination/handlers/handler-types.d.ts

@@ -43,6 +43,8 @@ export interface TaskHandlerContext {
      */
     getCodeIntelligenceCoordinator?(): Promise<ProjectMetricsCollector | undefined>;
     getQualityAnalyzer(): QualityAnalyzerService;
+    /** The domain execution owner also records run evidence and lifecycle events. */
+    getTestExecutionAPI?(): Promise<import('../../domains/test-execution/interfaces').ITestExecutionAPI | undefined>;
     /** Executor configuration */
     readonly config: {
         defaultLanguage: string;

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

@@ -11,6 +11,8 @@ import { toError } from '../../shared/error-utils.js';
 import { 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 { runTestRunnerProcess } from '../../shared/test-runner-process.js';
 function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
@@ -182,8 +184,28 @@ export function registerTestExecutionHandlers(ctx) {
             if (testFiles.some(file => !safePathPattern.test(file))) {
                 return err(new TestRunnerExecutionError('Some test file paths contain invalid characters and were rejected. Provide concrete paths; expand glob patterns before calling.'));
             }
-            const { spawnSync } = await import('child_process');
-            const options = { cwd: process.cwd(), timeout: 120000, encoding: 'utf-8' };
+            // A caller-owned MCP task skips the Queen's plugin dispatch. Run through
+            // that same domain API here: it owns persistence, measured quality evidence
+            // and TestRunStarted/Completed events as well as the runner itself.
+            if (task.executionOwner === 'caller') {
+                const api = await ctx.getTestExecutionAPI?.();
+                if (!api)
+                    return err(new TestRunnerExecutionError('Test-execution domain is unavailable.'));
+                const result = await api.runTests({
+                    testFiles,
+                    parallel: payload.parallel,
+                    timeout: payload.timeout,
+                    workers: payload.parallelism,
+                    // The domain owns requested retries; Queen dispatch must not replay it.
+                    retryCount: payload.retryCount ?? 0,
+                });
+                if (!result.success)
+                    return result;
+                return ok({ ...result.value, coverage: result.value.coverage?.line ?? null });
+            }
+            // #1074: run the runner asynchronously so the MCP server keeps serving
+            // other requests (task_status, task_cancel, ...) during the test run.
+            const options = { cwd: process.cwd(), timeout: 120000 };
             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.
@@ -192,7 +214,7 @@ export function registerTestExecutionHandlers(ctx) {
             let output;
             try {
                 // #909: absolute paths cannot be read as flags (e.g. a "--watch" entry).
-                execution = spawnSync('npx', ['vitest', 'run', ...testFiles.map(file => runnerFilePath(file, options.cwd)), '--reporter=json', ...report.args], options);
+                execution = await runTestRunnerProcess('npx', ['vitest', 'run', ...testFiles.map(file => runnerFilePath(file, options.cwd)), '--reporter=json', ...report.args], options);
                 output = execution.error || execution.signal
                     ? ''
                     : report.read(execution.stdout || '') ?? '';
@@ -203,7 +225,7 @@ export function registerTestExecutionHandlers(ctx) {
             // Preserve the existing Jest fallback when Vitest cannot produce a report.
             if (!output.includes('{') && execution.status !== 0 && !execution.error && !execution.signal) {
                 runner = 'jest';
-                execution = spawnSync('npx', ['jest', ...testFiles.map(file => jestExactPathPattern(file, options.cwd)), '--json'], options);
+                execution = await runTestRunnerProcess('npx', ['jest', ...testFiles.map(file => jestExactPathPattern(file, options.cwd)), '--json'], options);
                 output = execution.stdout || '';
             }
             const diagnostics = [execution.error?.message, execution.signal && `Terminated by ${execution.signal}`, execution.stderr, output].filter(Boolean).join('\n');
@@ -225,7 +247,12 @@ export function registerTestExecutionHandlers(ctx) {
                         // #1027 N5/NB5: this handler runs the tests without --coverage, so it has no
                         // coverage figure to return (null, never 0%). For test_execute_parallel the
                         // measured coverage + testsPassing are recorded by TestExecutorService.
-                        return ok({ total, passed, failed, skipped, duration: 0, coverage: null, failedTests: [] });
+                        // #1110: per-test entries come from the runner report itself, or are left out.
+                        const testCases = testCasesFromRunnerReport(json, testFiles.join(', '));
+                        return ok({
+                            total, passed, failed, skipped, duration: 0, coverage: null, failedTests: [],
+                            ...(testCases && testCases.length === total ? { testCases } : {}),
+                        });
                     }
                 }
             }