agentic-qe 3.15.4 → 3.15.6

package/dist/coordination/result-saver.js

@@ -4,8 +4,9 @@
  */
 import * as fs from 'fs/promises';
 import * as path from 'path';
-import { createHash } from 'crypto';
+import { createHash, randomBytes } from 'crypto';
 import { safeJsonParse } from '../shared/safe-json.js';
+import { getProjectStorePath } from '../kernel/project-root.js';
 function securityReportExecution(data) {
     return data.evidence?.completeness === 'complete' ? 'completed'
         : data.evidence?.completeness === 'partial' ? 'partial'
@@ -77,7 +78,12 @@ const TEST_FILE_PATTERNS = {
 export class ResultSaver {
     baseDir;
     resultsDir;
-    constructor(baseDir = '.agentic-qe') {
+    /**
+     * @param baseDir Store directory. Defaults to the resolved project's
+     * `.agentic-qe` (review of #1026 N2: a cwd-relative default wrote
+     * `<tmp>/.agentic-qe/results` when run from a shared dir).
+     */
+    constructor(baseDir = getProjectStorePath()) {
         this.baseDir = baseDir;
         this.resultsDir = path.join(baseDir, 'results');
     }
@@ -94,8 +100,13 @@ export class ResultSaver {
         // Ensure directories exist
         await this.ensureDirectories(taskType);
         // Get timestamp string for filenames
+        // #1007: millisecond timestamp plus a per-save suffix. Names to the second
+        // let two saves in the same second overwrite each other. Report, manifest
+        // and data files are created exclusively (see writeNewFile), so even a
+        // reused custom prefix never replaces an earlier result. Generated test
+        // files are the exception: one file per test name (see replaceFile).
         const tsStr = this.formatTimestamp(timestamp);
-        const prefix = options.filenamePrefix || tsStr;
+        const prefix = options.filenamePrefix || `${tsStr}_${this.uniqueSuffix(taskId)}`;
         // Save based on task type
         switch (taskType) {
             case 'generate-tests':
@@ -159,8 +170,7 @@ export class ResultSaver {
             framework: options.framework || 'vitest',
             tests: data.tests,
         }, null, 2);
-        await fs.writeFile(manifestPath, manifestContent);
-        files.push(await this.createFileEntry(manifestPath, 'json'));
+        files.push(await this.writeNewFile(manifestPath, manifestContent, 'json'));
         // Save individual test files if code is provided
         if (data.tests) {
             for (const test of data.tests) {
@@ -168,16 +178,17 @@ export class ResultSaver {
                     const ext = this.getTestExtension(options.language || 'typescript', options.framework || 'vitest');
                     const testFilename = this.sanitizeFilename(test.name) + ext;
                     const testPath = path.join(testDir, testFilename);
-                    await fs.writeFile(testPath, test.code);
-                    files.push(await this.createFileEntry(testPath, 'source'));
+                    // Review of #1026 N7: a generated test keeps one file per test name
+                    // (replaced atomically), unlike reports, so numbered copies never
+                    // pile up for a test runner to collect.
+                    files.push(await this.replaceFile(testPath, test.code, 'source'));
                 }
             }
         }
         // Save markdown report
         const reportPath = path.join(this.resultsDir, 'tests', `${prefix}_report.md`);
         const reportContent = this.generateTestReport(data, options);
-        await fs.writeFile(reportPath, reportContent);
-        files.push(await this.createFileEntry(reportPath, 'markdown'));
+        files.push(await this.writeNewFile(reportPath, reportContent, 'markdown'));
         return files;
     }
     async saveCoverage(result, prefix, options) {
@@ -189,8 +200,7 @@ export class ResultSaver {
         const coverageDir = path.join(this.resultsDir, 'coverage');
         // Save JSON
         const jsonPath = path.join(coverageDir, `${prefix}_coverage.json`);
-        await fs.writeFile(jsonPath, JSON.stringify(data, null, 2));
-        files.push(await this.createFileEntry(jsonPath, 'json'));
+        files.push(await this.writeNewFile(jsonPath, JSON.stringify(data, null, 2), 'json'));
         // Save LCOV format — ONLY for genuinely measured coverage.
         //
         // #569/ADR-126: LCOV has nowhere to record provenance. Emitting it for an
@@ -202,14 +212,12 @@ export class ResultSaver {
         if (options.includeSecondary !== false && data.measured === true) {
             const lcovPath = path.join(coverageDir, `${prefix}_coverage.lcov`);
             const lcovContent = this.generateLcov(data);
-            await fs.writeFile(lcovPath, lcovContent);
-            files.push(await this.createFileEntry(lcovPath, 'lcov'));
+            files.push(await this.writeNewFile(lcovPath, lcovContent, 'lcov'));
         }
         // Save markdown report
         const reportPath = path.join(coverageDir, `${prefix}_report.md`);
         const reportContent = this.generateCoverageReport(data);
-        await fs.writeFile(reportPath, reportContent);
-        files.push(await this.createFileEntry(reportPath, 'markdown'));
+        files.push(await this.writeNewFile(reportPath, reportContent, 'markdown'));
         return files;
     }
     async saveSecurityScan(result, prefix, options) {
@@ -218,20 +226,17 @@ export class ResultSaver {
         const securityDir = path.join(this.resultsDir, 'security');
         // Save JSON
         const jsonPath = path.join(securityDir, `${prefix}_scan.json`);
-        await fs.writeFile(jsonPath, JSON.stringify(data, null, 2));
-        files.push(await this.createFileEntry(jsonPath, 'json'));
+        files.push(await this.writeNewFile(jsonPath, JSON.stringify(data, null, 2), 'json'));
         // Save SARIF format
         if (options.includeSecondary !== false) {
             const sarifPath = path.join(securityDir, `${prefix}_scan.sarif`);
             const sarifContent = this.generateSarif(data);
-            await fs.writeFile(sarifPath, sarifContent);
-            files.push(await this.createFileEntry(sarifPath, 'sarif'));
+            files.push(await this.writeNewFile(sarifPath, sarifContent, 'sarif'));
         }
         // Save markdown report
         const reportPath = path.join(securityDir, `${prefix}_report.md`);
         const reportContent = this.generateSecurityReport(data);
-        await fs.writeFile(reportPath, reportContent);
-        files.push(await this.createFileEntry(reportPath, 'markdown'));
+        files.push(await this.writeNewFile(reportPath, reportContent, 'markdown'));
         return files;
     }
     async saveQualityAssessment(result, prefix, _options) {
@@ -240,13 +245,11 @@ export class ResultSaver {
         const qualityDir = path.join(this.resultsDir, 'quality');
         // Save JSON
         const jsonPath = path.join(qualityDir, `${prefix}_assessment.json`);
-        await fs.writeFile(jsonPath, JSON.stringify(data, null, 2));
-        files.push(await this.createFileEntry(jsonPath, 'json'));
+        files.push(await this.writeNewFile(jsonPath, JSON.stringify(data, null, 2), 'json'));
         // Save markdown report
         const reportPath = path.join(qualityDir, `${prefix}_report.md`);
         const reportContent = this.generateQualityReport(data);
-        await fs.writeFile(reportPath, reportContent);
-        files.push(await this.createFileEntry(reportPath, 'markdown'));
+        files.push(await this.writeNewFile(reportPath, reportContent, 'markdown'));
         return files;
     }
     async saveCodeIndex(result, prefix, _options) {
@@ -256,8 +259,7 @@ export class ResultSaver {
         await fs.mkdir(indexDir, { recursive: true });
         // Save JSON
         const jsonPath = path.join(indexDir, `${prefix}_index.json`);
-        await fs.writeFile(jsonPath, JSON.stringify(data, null, 2));
-        files.push(await this.createFileEntry(jsonPath, 'json'));
+        files.push(await this.writeNewFile(jsonPath, JSON.stringify(data, null, 2), 'json'));
         return files;
     }
     async saveDefectPrediction(result, prefix, _options) {
@@ -266,8 +268,7 @@ export class ResultSaver {
         await fs.mkdir(defectDir, { recursive: true });
         // Save JSON
         const jsonPath = path.join(defectDir, `${prefix}_prediction.json`);
-        await fs.writeFile(jsonPath, JSON.stringify(result, null, 2));
-        files.push(await this.createFileEntry(jsonPath, 'json'));
+        files.push(await this.writeNewFile(jsonPath, JSON.stringify(result, null, 2), 'json'));
         return files;
     }
     async saveContractValidation(result, prefix, _options) {
@@ -276,8 +277,7 @@ export class ResultSaver {
         await fs.mkdir(contractDir, { recursive: true });
         // Save JSON
         const jsonPath = path.join(contractDir, `${prefix}_validation.json`);
-        await fs.writeFile(jsonPath, JSON.stringify(result, null, 2));
-        files.push(await this.createFileEntry(jsonPath, 'json'));
+        files.push(await this.writeNewFile(jsonPath, JSON.stringify(result, null, 2), 'json'));
         return files;
     }
     async saveAccessibilityTest(result, prefix, _options) {
@@ -286,8 +286,7 @@ export class ResultSaver {
         await fs.mkdir(a11yDir, { recursive: true });
         // Save JSON
         const jsonPath = path.join(a11yDir, `${prefix}_test.json`);
-        await fs.writeFile(jsonPath, JSON.stringify(result, null, 2));
-        files.push(await this.createFileEntry(jsonPath, 'json'));
+        files.push(await this.writeNewFile(jsonPath, JSON.stringify(result, null, 2), 'json'));
         return files;
     }
     async saveChaosTest(result, prefix, _options) {
@@ -296,8 +295,7 @@ export class ResultSaver {
         await fs.mkdir(chaosDir, { recursive: true });
         // Save JSON
         const jsonPath = path.join(chaosDir, `${prefix}_chaos.json`);
-        await fs.writeFile(jsonPath, JSON.stringify(result, null, 2));
-        files.push(await this.createFileEntry(jsonPath, 'json'));
+        files.push(await this.writeNewFile(jsonPath, JSON.stringify(result, null, 2), 'json'));
         return files;
     }
     async saveGeneric(taskType, result, prefix) {
@@ -305,8 +303,7 @@ export class ResultSaver {
         const genericDir = path.join(this.resultsDir, 'other');
         await fs.mkdir(genericDir, { recursive: true });
         const jsonPath = path.join(genericDir, `${prefix}_${taskType}.json`);
-        await fs.writeFile(jsonPath, JSON.stringify(result, null, 2));
-        files.push(await this.createFileEntry(jsonPath, 'json'));
+        files.push(await this.writeNewFile(jsonPath, JSON.stringify(result, null, 2), 'json'));
         return files;
     }
     // ==========================================================================
@@ -466,24 +463,42 @@ ${data.recommendations.map((r, i) => `${i + 1}. ${r}`).join('\n')}
 `;
     }
     generateQualityReport(data) {
+        // #996: unmeasured metrics (-1 sentinel) are not scores, and a static
+        // analysis run is not a gate — say both plainly.
+        const insufficient = (data.unmeasured?.length ?? 0) > 0 || data.evidenceStatus === 'insufficient-evidence';
+        const status = insufficient ? 'INSUFFICIENT EVIDENCE (not passed)' : data.passed ? 'PASSED' : 'FAILED';
+        const gateLine = data.gateEvaluated === false
+            ? '\n**Quality gate:** Not evaluated (static analysis only)'
+            : '';
+        const unmeasuredLine = insufficient && data.unmeasured?.length
+            ? `\n**Unmeasured:** ${data.unmeasured.join(', ')}`
+            : '';
+        const noRecommendations = data.gateEvaluated === false
+            ? 'No recommendations.'
+            : 'No recommendations - all quality gates passed.';
         return `# Quality Assessment Report
 
 **Generated:** ${new Date().toISOString()}
-**Status:** ${data.passed ? 'PASSED' : 'FAILED'}
+**Status:** ${status}${gateLine}${unmeasuredLine}
 
 ## Quality Score
 
-${typeof data.qualityScore === 'number' ? `**${data.qualityScore.toFixed(1)}** / 100` : 'N/A — measured gate uses individual checks.'}
+${typeof data.qualityScore !== 'number' ? 'N/A — measured gate uses individual checks.'
+            : data.qualityScore < 0 ? 'Not measured — no requested metric had measured data (#1011).'
+                : data.evidenceStatus === 'insufficient-evidence'
+                    ? `Subset score over measured metrics: ${data.qualityScore.toFixed(1)} (not a verdict)`
+                        + (data.scoreBasis?.length ? `\nBased on: ${data.scoreBasis.join(', ')}` : '')
+                    : `**${data.qualityScore.toFixed(1)}** / 100`}
 
 ## Metrics
 
 | Metric | Score |
 |--------|-------|
-${Object.entries(data.metrics).map(([k, v]) => `| ${k} | ${v.toFixed(1)} |`).join('\n')}
+${Object.entries(data.metrics).map(([k, v]) => `| ${k} | ${Number.isFinite(v) && v >= 0 ? v.toFixed(1) : 'not measured'} |`).join('\n')}
 
 ## Recommendations
 
-${data.recommendations.length === 0 ? 'No recommendations - all quality gates passed.' : data.recommendations.map((r, i) => `${i + 1}. ${r}`).join('\n')}
+${data.recommendations.length === 0 ? noRecommendations : data.recommendations.map((r, i) => `${i + 1}. ${r}`).join('\n')}
 `;
     }
     // ==========================================================================
@@ -502,8 +517,51 @@ ${data.recommendations.length === 0 ? 'No recommendations - all quality gates pa
             await fs.mkdir(dir, { recursive: true });
         }
     }
+    /** `YYYY-MM-DDTHH-MM-SS-mmm` (#1007: milliseconds, not seconds). */
     formatTimestamp(date) {
-        return date.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+        return date.toISOString().replace(/[:.]/g, '-').slice(0, 23);
+    }
+    /** Short task-id fragment plus random hex, unique per save. */
+    uniqueSuffix(taskId) {
+        const idPart = this.sanitizeFilename(taskId).slice(-12) || 'task';
+        return `${idPart}-${randomBytes(3).toString('hex')}`;
+    }
+    /** Write `filePath` via a temp file and rename, replacing any previous version. */
+    async replaceFile(filePath, content, format) {
+        const tmpPath = `${filePath}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+        try {
+            await fs.writeFile(tmpPath, content, { flag: 'wx' });
+            await fs.rename(tmpPath, filePath);
+        }
+        catch (error) {
+            await fs.rm(tmpPath, { force: true });
+            throw error;
+        }
+        return this.createFileEntry(filePath, format);
+    }
+    /**
+     * Create `filePath` exclusively and record it. If the name is taken (a
+     * reused custom prefix), write to
+     * `name-1.ext`, `name-2.ext`, … instead of replacing the earlier file (#1007).
+     */
+    async writeNewFile(filePath, content, format) {
+        const dir = path.dirname(filePath);
+        const base = path.basename(filePath);
+        const dot = base.indexOf('.', 1);
+        const stem = dot > 0 ? base.slice(0, dot) : base;
+        const ext = dot > 0 ? base.slice(dot) : '';
+        for (let attempt = 0; attempt < 1000; attempt++) {
+            const candidate = attempt === 0 ? filePath : path.join(dir, `${stem}-${attempt}${ext}`);
+            try {
+                await fs.writeFile(candidate, content, { flag: 'wx' });
+                return this.createFileEntry(candidate, format);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+            }
+        }
+        throw new Error(`ResultSaver: no free file name for ${filePath}`);
     }
     sanitizeFilename(name) {
         return name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
@@ -542,8 +600,12 @@ ${data.recommendations.length === 0 ? 'No recommendations - all quality gates pa
                 };
             case 'assess-quality':
                 return {
-                    qualityScore: data.qualityScore,
+                    // #1021: -1 means "not measured", and a subset score under insufficient
+                    // evidence is not a verdict; keep both out of the index and trends.
+                    ...(typeof data.qualityScore === 'number' && data.qualityScore >= 0
+                        && data.evidenceStatus !== 'insufficient-evidence' ? { qualityScore: data.qualityScore } : {}),
                     passed: data.passed,
+                    ...(data.evidenceStatus !== undefined ? { evidenceStatus: data.evidenceStatus } : {}),
                 };
             case 'generate-tests':
                 return {
@@ -554,8 +616,26 @@ ${data.recommendations.length === 0 ? 'No recommendations - all quality gates pa
                 return {};
         }
     }
-    async updateIndex(taskId, taskType, timestamp, files, summary) {
-        const indexPath = path.join(this.resultsDir, 'index.json');
+    /**
+     * Append to index.json. Concurrent saves read-modify-write the same file, so
+     * updates are serialized per index path in this process and the file is
+     * replaced atomically, otherwise one save's entry is lost (#1007).
+     */
+    updateIndex(taskId, taskType, timestamp, files, summary) {
+        const indexPath = path.resolve(this.resultsDir, 'index.json');
+        const previous = indexUpdateQueues.get(indexPath) ?? Promise.resolve();
+        const next = previous
+            .catch(() => undefined)
+            .then(() => this.writeIndexEntry(indexPath, taskId, taskType, timestamp, files, summary));
+        indexUpdateQueues.set(indexPath, next);
+        const settle = () => {
+            if (indexUpdateQueues.get(indexPath) === next)
+                indexUpdateQueues.delete(indexPath);
+        };
+        next.then(settle, settle);
+        return next;
+    }
+    async writeIndexEntry(indexPath, taskId, taskType, timestamp, files, summary) {
         let index;
         try {
             const content = await fs.readFile(indexPath, 'utf-8');
@@ -584,9 +664,13 @@ ${data.recommendations.length === 0 ? 'No recommendations - all quality gates pa
         if (index.results.length > 100) {
             index.results = index.results.slice(-100);
         }
-        await fs.writeFile(indexPath, JSON.stringify(index, null, 2));
+        const tmpPath = `${indexPath}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+        await fs.writeFile(tmpPath, JSON.stringify(index, null, 2));
+        await fs.rename(tmpPath, indexPath);
     }
 }
+/** Pending index.json updates, keyed by absolute index path (#1007). */
+const indexUpdateQueues = new Map();
 // Factory function
 export function createResultSaver(baseDir) {
     return new ResultSaver(baseDir);

package/dist/coordination/task-executor.d.ts

@@ -22,6 +22,7 @@ type CoverageAnalyzerService = import('../domains/coverage-analysis').CoverageAn
 type SecurityScannerService = import('../domains/security-compliance').SecurityScannerService;
 type KnowledgeGraphService = import('../domains/code-intelligence').KnowledgeGraphService;
 type QualityAnalyzerService = import('../domains/quality-assessment').QualityAnalyzerService;
+type ProjectMetricsCollector = import('./handlers/handler-types').ProjectMetricsCollector;
 export interface TaskExecutorConfig {
     timeout: number;
     maxRetries: number;
@@ -44,6 +45,11 @@ export interface TaskResult {
     domain: DomainName;
     /** Files saved by result saver */
     savedFiles?: string[];
+    /**
+     * #996: structured context for a failure (which quality metrics were
+     * unmeasured). Only set for InsufficientQualityEvidenceError; absent otherwise.
+     */
+    errorDetails?: Record<string, unknown>;
 }
 export declare class DomainTaskExecutor implements TaskHandlerContext {
     private readonly kernel;
@@ -101,6 +107,12 @@ export declare class DomainTaskExecutor implements TaskHandlerContext {
      */
     private resolveLLMRouter;
     getKnowledgeGraph(): KnowledgeGraphService;
+    /**
+     * #999: the code-intelligence coordinator, so the MCP index-code handler can
+     * run the same project-metric step as `aqe code index`. Loads the domain
+     * lazily; undefined when it is disabled or fails to load.
+     */
+    getCodeIntelligenceCoordinator(): Promise<ProjectMetricsCollector | undefined>;
     getQualityAnalyzer(): QualityAnalyzerService;
     private registerHandlers;
     /**

package/dist/coordination/task-executor.js

@@ -14,7 +14,9 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { isCallerInputError, toErrorMessage } from '../shared/error-utils.js';
+import { InsufficientQualityEvidenceError } from '../domains/quality-assessment/quality-evidence.js';
 import { createResultSaver } from './result-saver.js';
+import { getProjectStorePath } from '../kernel/project-root.js';
 import { createLogger } from '../logging/logger-factory.js';
 import { getClaudeModelForTier } from '../shared/llm/model-registry.js';
 // ADR-051: Agent Booster integration for Tier 0 tasks
@@ -53,6 +55,16 @@ function resolveQualityAnalyzerService(memory) {
     const factory = DomainServiceRegistry.resolve(ServiceKeys.QualityAnalyzerService);
     return factory(memory);
 }
+/**
+ * #996: structured details, only from error types known to carry them.
+ * #1021 round 2b: a caller-input error is marked so learners do not record
+ * the caller's mistake as a component failure.
+ */
+function errorDetailsOf(error) {
+    if (error instanceof InsufficientQualityEvidenceError)
+        return { ...error.toDetails() };
+    return isCallerInputError(error) ? { callerError: true } : undefined;
+}
 // ============================================================================
 // ADR-051: Model Routing Support
 // ============================================================================
@@ -136,7 +148,8 @@ export class DomainTaskExecutor {
             maxRetries: config?.maxRetries ?? 3,
             enableCaching: config?.enableCaching ?? true,
             saveResults: config?.saveResults ?? true,
-            resultsDir: config?.resultsDir ?? '.agentic-qe',
+            // Review of #1026 N2: resolve the project store, not a cwd-relative one.
+            resultsDir: config?.resultsDir ?? getProjectStorePath(),
             defaultLanguage: config?.defaultLanguage ?? 'typescript',
             defaultFramework: config?.defaultFramework ?? 'vitest',
         };
@@ -235,6 +248,25 @@ export class DomainTaskExecutor {
         }
         return this.knowledgeGraph;
     }
+    /**
+     * #999: the code-intelligence coordinator, so the MCP index-code handler can
+     * run the same project-metric step as `aqe code index`. Loads the domain
+     * lazily; undefined when it is disabled or fails to load.
+     */
+    async getCodeIntelligenceCoordinator() {
+        try {
+            const api = this.kernel.getDomainAPIAsync
+                ? await this.kernel.getDomainAPIAsync('code-intelligence')
+                : this.kernel.getDomainAPI('code-intelligence');
+            return typeof api?.getCoordinator === 'function' ? api.getCoordinator() : undefined;
+        }
+        catch (error) {
+            logger.debug('code-intelligence coordinator unavailable for project metrics', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return undefined;
+        }
+    }
     getQualityAnalyzer() {
         if (!this.qualityAnalyzer) {
             this.qualityAnalyzer = resolveQualityAnalyzerService(this.kernel.memory);
@@ -439,12 +471,14 @@ export class DomainTaskExecutor {
                 await this.publishTaskFailed(task.id, errorMsg, domain, 'error' in result && isCallerInputError(result.error));
                 // ADR-051: Record failed outcome
                 this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch((e) => { logger.warn('recordOutcome failed', { error: e instanceof Error ? e.message : String(e), taskId: task.id }); });
+                const errorDetails = 'error' in result ? errorDetailsOf(result.error) : undefined;
                 return {
                     taskId: task.id,
                     success: false,
                     error: errorMsg,
                     duration: Date.now() - startTime,
                     domain,
+                    ...(errorDetails ? { errorDetails } : {}),
                 };
             }
             await this.publishTaskCompleted(task.id, result.value, domain);
@@ -491,12 +525,14 @@ export class DomainTaskExecutor {
             await this.publishTaskFailed(task.id, errorMessage, domain, isCallerInputError(error));
             // ADR-051: Record failed outcome
             this.recordOutcome(task, routingTier, false, Date.now() - startTime).catch((e) => { logger.warn('recordOutcome failed', { error: e instanceof Error ? e.message : String(e), taskId: task.id }); });
+            const errorDetails = errorDetailsOf(error);
             return {
                 taskId: task.id,
                 success: false,
                 error: errorMessage,
                 duration: Date.now() - startTime,
                 domain,
+                ...(errorDetails ? { errorDetails } : {}),
             };
         }
     }

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

@@ -261,7 +261,8 @@ export declare class CodeIntelligenceCoordinator extends BaseDomainCoordinator<C
      */
     getMetricCollector(): IMetricCollectorService | undefined;
     /**
-     * Determine project root from indexed paths
+     * Determine project root from indexed paths (nearest marker, bottom-up; #994).
+     * Relative paths resolve against the process cwd, matching the CLI/MCP callers.
      */
     private getProjectRootFromPaths;
     /**

package/dist/domains/code-intelligence/coordinator.js

@@ -6,7 +6,7 @@
  * - QEGNNEmbeddingIndex: Code graph embeddings with HNSW for fast similarity search
  * - QESONA: Learns and adapts code patterns for improved intelligence
  */
-import { existsSync } from 'node:fs';
+import { resolveProjectRootFromPaths } from './project-root-resolver.js';
 import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import { err } from '../../shared/types/index.js';
@@ -300,11 +300,14 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
                 this.updateWorkflowProgress(workflowId, 60);
                 // V3: Collect real project metrics using actual tooling (Phase 5)
                 if (this.config.enableMetricCollector && this.metricCollector && request.paths.length > 0) {
-                    // Determine project root from first path
-                    const projectPath = this.getProjectRootFromPaths(request.paths);
+                    // Determine project root from the caller's target (or the indexed paths)
+                    const projectPath = this.getProjectRootFromPaths(request.paths, request.target);
                     if (projectPath) {
                         await this.collectProjectMetrics(projectPath);
                     }
+                    else {
+                        logger.debug('Skipping project metrics: no project root resolved (filesystem root or no paths)');
+                    }
                 }
                 this.updateWorkflowProgress(workflowId, 70);
                 // Index content for semantic search
@@ -941,36 +944,11 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
         return this.metricCollector;
     }
     /**
-     * Determine project root from indexed paths
+     * Determine project root from indexed paths (nearest marker, bottom-up; #994).
+     * Relative paths resolve against the process cwd, matching the CLI/MCP callers.
      */
-    getProjectRootFromPaths(paths) {
-        if (paths.length === 0)
-            return null;
-        // Get the first path and find the project root
-        const firstPath = paths[0];
-        // Walk up the path to find package.json, Cargo.toml, go.mod, etc.
-        const parts = firstPath.split('/');
-        let currentPath = '';
-        for (const part of parts) {
-            currentPath = currentPath ? `${currentPath}/${part}` : part;
-            // Check for common project markers
-            const markers = ['package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml', '.git'];
-            for (const marker of markers) {
-                try {
-                    const markerPath = `${currentPath}/${marker}`;
-                    // Synchronous existence check (we're in an async context anyway).
-                    if (existsSync(markerPath)) {
-                        return currentPath;
-                    }
-                }
-                catch {
-                    // Continue checking
-                }
-            }
-        }
-        // If no marker found, return the parent directory of the first path
-        const lastSlash = firstPath.lastIndexOf('/');
-        return lastSlash > 0 ? firstPath.substring(0, lastSlash) : firstPath;
+    getProjectRootFromPaths(paths, target) {
+        return resolveProjectRootFromPaths(paths, { target });
     }
     // ============================================================================
     // V3: Hypergraph Integration for Intelligent Code Analysis (GOAP Action 7)

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

@@ -17,6 +17,11 @@ export interface CodeIntelligenceAPI {
 }
 export interface IndexRequest {
     paths: string[];
+    /**
+     * The directory or file the caller asked to index, before it was expanded
+     * into `paths`. Used to resolve the project root for metrics (#994).
+     */
+    target?: string;
     incremental?: boolean;
     includeTests?: boolean;
     languages?: string[];

package/dist/domains/code-intelligence/plugin.js

@@ -9,6 +9,7 @@ import { KnowledgeGraphService, } from './services/knowledge-graph.js';
 import { SemanticAnalyzerService, } from './services/semantic-analyzer.js';
 import { toError } from '../../shared/error-utils.js';
 import { ImpactAnalyzerService, } from './services/impact-analyzer.js';
+import { isMeasuredGapPayload } from '../../shared/events/domain-events.js';
 /**
  * Code Intelligence Domain Plugin
  * Provides knowledge graph, semantic search, and impact analysis capabilities
@@ -80,6 +81,7 @@ export class CodeIntelligencePlugin extends BaseDomainPlugin {
                     return this.coordinator.index({
                         paths,
                         languages,
+                        target: typeof payload.target === 'string' ? payload.target : undefined,
                     });
                 }],
             ['search', async (payload) => {
@@ -300,6 +302,9 @@ export class CodeIntelligencePlugin extends BaseDomainPlugin {
         );
     }
     async handleCoverageGap(event) {
+        // #1014: only a gap found in MEASURED coverage is acted on / learned from.
+        if (!isMeasuredGapPayload(event.payload))
+            return;
         // Coverage gap detected - update risk scores in knowledge graph
         const payload = event.payload;
         // Store coverage gap info for impact analysis

package/dist/domains/code-intelligence/project-root-resolver.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Project root resolution for code-intelligence metric collection (#994).
+ *
+ * `index()` receives an expanded list of files (the CLI walks the target
+ * directory first). When the caller also passes the original `target`, the
+ * walk starts at the target directory (its parent for a file target), so a `.`
+ * at a monorepo root whose source all lives in one package resolves to the
+ * root. Without a target we start from the deepest directory that contains
+ * every indexed path. Either way we walk UP (bottom-up, using `path.dirname`,
+ * so absolute paths and Windows drive roots are handled by the `path` module)
+ * and return the NEAREST directory that holds a project marker.
+ *
+ * Starting from the common directory rather than the first file keeps a stray
+ * marker inside one subtree (for example `.agentic-qe/workers/package.json`)
+ * from capturing an index that spans the whole project.
+ *
+ * When no marker exists anywhere up to the filesystem root, the start
+ * directory itself is returned (the target, the files' common directory, or a
+ * single file's directory). A filesystem or drive root is never returned:
+ * measuring `/` would walk the whole disk, so the result is null instead.
+ *
+ * @module domains/code-intelligence/project-root-resolver
+ */
+import * as path from 'node:path';
+/** Files or directories whose presence marks a project root. */
+export declare const PROJECT_ROOT_MARKERS: readonly string[];
+export interface ResolveProjectRootOptions {
+    /** Base directory for relative inputs. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /** Existence check, injectable for tests. Defaults to `fs.existsSync`. */
+    exists?: (p: string) => boolean;
+    /** Directory check, injectable for tests. Defaults to `fs.statSync(...).isDirectory()`. */
+    isDirectory?: (p: string) => boolean;
+    /** Path implementation. Defaults to the platform `path`; tests pass `path.win32`. */
+    pathImpl?: path.PlatformPath;
+    /**
+     * The directory (or file) the caller asked to index, before expansion. When
+     * set, the walk starts here instead of at the common directory of `paths`.
+     */
+    target?: string;
+}
+/**
+ * Resolve the project root for a set of indexed paths.
+ *
+ * @param paths - Files and/or directories, absolute or relative to `options.cwd`
+ * @returns Absolute project root, or null when there is nothing to resolve or
+ *   the result would be a filesystem/drive root
+ */
+export declare function resolveProjectRootFromPaths(paths: readonly string[], options?: ResolveProjectRootOptions): string | null;
+//# sourceMappingURL=project-root-resolver.d.ts.map