agentic-qe 3.15.5 → 3.15.7

package/dist/coordination/protocols/defect-investigation.d.ts

@@ -64,7 +64,8 @@ export interface RelatedFailure {
 export interface CoverageContext {
     file: string;
     lineCoverage: number;
-    branchCoverage: number;
+    /** `null` = no branch data was collected (#1027 NB4) — never a borrowed figure. */
+    branchCoverage: number | null;
     uncoveredLines: number[];
     riskScore: number;
 }

package/dist/coordination/protocols/defect-investigation.js

@@ -12,6 +12,8 @@ import { createEvent } from '../../shared/events/domain-events.js';
 import { toError } from '../../shared/error-utils.js';
 import { LoggerFactory } from '../../logging/index.js';
 import { addToCount } from '../../shared/utils/safe-record.js';
+import { measuredFileCoverage } from '../../domains/quality-assessment/coverage-report-event.js';
+import { fileCoverageLookupKeys } from '../../domains/coverage-analysis/collected-metrics.js';
 const logger = LoggerFactory.create('defect-investigation');
 export const DefectInvestigationEvents = {
     DefectInvestigationStarted: 'coordination.DefectInvestigationStarted',
@@ -605,12 +607,19 @@ export class DefectInvestigationProtocol {
     async getCoverageContext(file) {
         try {
             // Try per-file coverage (written by coverage-analyzer and test-executor)
-            const coverage = await this.memory.get(`coverage:file:${file}`);
+            // #1014: only measured records; legacy unstamped estimates are ignored.
+            let coverage = null;
+            for (const key of fileCoverageLookupKeys(file)) {
+                coverage = measuredFileCoverage(await this.memory.get(key));
+                if (coverage)
+                    break;
+            }
             if (!coverage) {
                 return null;
             }
-            // Calculate risk based on coverage
-            const avgCoverage = (coverage.line + coverage.branch) / 2;
+            // Calculate risk based on coverage (an uncollected branch metric is
+            // left out, not counted as 0%).
+            const avgCoverage = coverage.branch === null ? coverage.line : (coverage.line + coverage.branch) / 2;
             const riskScore = 1 - avgCoverage / 100;
             return {
                 file,

package/dist/coordination/protocols/quality-gate.js

@@ -10,6 +10,7 @@ import { v4 as uuidv4 } from 'uuid';
 import { ok, err, } from '../../shared/types/index.js';
 import { createEvent } from '../../shared/events/domain-events.js';
 import { toErrorMessage, toError } from '../../shared/error-utils.js';
+import { measuredCoverageSummary } from '../../domains/quality-assessment/coverage-report-event.js';
 // ============================================================================
 // Protocol Events
 // ============================================================================
@@ -402,12 +403,14 @@ export class QualityGateProtocol {
     async getCoverageMetrics(_releaseCandidate) {
         try {
             // Try to get latest coverage data from memory
-            const latestCoverage = await this.memory.get('coverage:latest');
+            // #1014: only a measured record is coverage evidence; a legacy
+            // unstamped or estimated record is "no data" (the gate fails closed).
+            const latestCoverage = measuredCoverageSummary(await this.memory.get('coverage:latest'));
             if (!latestCoverage) {
                 return null;
             }
-            // Get previous coverage for trend
-            const previousCoverage = await this.memory.get('coverage:previous');
+            // Get previous coverage for trend (measured baselines only, #1015)
+            const previousCoverage = measuredCoverageSummary(await this.memory.get('coverage:previous'));
             let trend = 'stable';
             if (previousCoverage) {
                 const delta = latestCoverage.line - previousCoverage.line;
@@ -418,9 +421,10 @@ export class QualityGateProtocol {
             }
             return {
                 line: latestCoverage.line,
-                branch: latestCoverage.branch,
-                function: latestCoverage.function,
-                statement: latestCoverage.statement,
+                // An uncollected metric has no evidence: 0 fails its check closed.
+                branch: latestCoverage.branch ?? 0,
+                function: latestCoverage.function ?? 0,
+                statement: latestCoverage.statement ?? 0,
                 trend,
             };
         }

package/dist/coordination/protocols/security-audit.js

@@ -137,6 +137,12 @@ export class SecurityAuditProtocol {
             if (depResult.success) {
                 this.currentAudit = { ...this.currentAudit, dependencyResult: depResult.value };
                 await this.publishDependencyVulnerabilities(depResult.value.vulnerabilities);
+                // #1049: a failed or partial advisory lookup (or a result without a
+                // status, which cannot show it was complete) is not a clean dependency scan.
+                if (depResult.value.status !== 'complete') {
+                    this.recordIncompleteCheck(depResult.value.error
+                        ?? `Dependency advisories could not be checked for ${depResult.value.uncheckedPackages?.length ?? 'unknown number of'} package(s)`);
+                }
             }
             else {
                 this.recordIncompleteCheck('Dependency scan did not complete');
@@ -280,6 +286,11 @@ export class SecurityAuditProtocol {
                             vulnerabilities: scanResult.value.vulnerabilities,
                             outdatedPackages: [],
                             summary: scanResult.value.summary,
+                            status: scanResult.value.status,
+                            measured: scanResult.value.measured,
+                            packagesChecked: scanResult.value.packagesChecked,
+                            uncheckedPackages: scanResult.value.uncheckedPackages,
+                            ...(scanResult.value.error ? { error: scanResult.value.error } : {}),
                         });
                     }
                 }

package/dist/coordination/result-saver.d.ts

@@ -49,6 +49,11 @@ export interface TrendData {
 export declare class ResultSaver {
     private readonly baseDir;
     private readonly resultsDir;
+    /**
+     * @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?: string);
     /**
      * Save task result in appropriate format(s)
@@ -71,12 +76,38 @@ export declare class ResultSaver {
     private generateSecurityReport;
     private generateQualityReport;
     private ensureDirectories;
+    /** `YYYY-MM-DDTHH-MM-SS-mmm` (#1007: milliseconds, not seconds). */
     private formatTimestamp;
+    /** Short task-id fragment plus random hex, unique per save. */
+    private uniqueSuffix;
+    /** Write `filePath` via a temp file and rename, replacing any previous version. */
+    private replaceFile;
+    /**
+     * 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).
+     */
+    private writeNewFile;
+    /**
+     * File name for a generated test source: the sanitized name capped at
+     * MAX_GENERATED_STEM_LENGTH characters (a long source file name would
+     * otherwise exceed the filesystem's 255-byte limit once the temp-file suffix
+     * is added) plus a short hash of the source path and full name. The hash keeps
+     * `src/one/math.ts` and `src/two/math.ts` (or a truncated long name) from
+     * overwriting each other, while the same test still maps to the same file.
+     */
+    private generatedTestFilename;
     private sanitizeFilename;
     private getTestExtension;
     private createFileEntry;
     private extractSummary;
+    /**
+     * 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).
+     */
     private updateIndex;
+    private writeIndexEntry;
 }
 export declare function createResultSaver(baseDir?: string): ResultSaver;
 //# sourceMappingURL=result-saver.d.ts.map

package/dist/coordination/result-saver.js

@@ -4,8 +4,11 @@
  */
 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';
+/** Cap on the sanitized stem of a generated test file name (see generatedTestFilename). */
+const MAX_GENERATED_STEM_LENGTH = 100;
 function securityReportExecution(data) {
     return data.evidence?.completeness === 'complete' ? 'completed'
         : data.evidence?.completeness === 'partial' ? 'partial'
@@ -77,7 +80,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 +102,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,25 +172,37 @@ 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) {
-                if (test.code) {
+                // The test-generation domain returns `testCode`; retain `code` for
+                // older callers of ResultSaver that already use that field.
+                const code = test.testCode ?? test.code;
+                if (code) {
                     const ext = this.getTestExtension(options.language || 'typescript', options.framework || 'vitest');
-                    const testFilename = this.sanitizeFilename(test.name) + ext;
+                    const testFilename = this.generatedTestFilename(test, 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.
+                    //
+                    // One unwritable source file (e.g. a name the filesystem rejects)
+                    // must not discard the manifest and report, so a per-file failure is
+                    // skipped; `files` then lists only what is actually on disk.
+                    try {
+                        files.push(await this.replaceFile(testPath, code, 'source'));
+                    }
+                    catch (error) {
+                        console.warn(`ResultSaver: could not write generated test ${testFilename}: ${error.message}`);
+                    }
                 }
             }
         }
         // 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 +214,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 +226,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 +240,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 +259,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 +273,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 +282,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 +291,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 +300,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 +309,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 +317,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;
     }
     // ==========================================================================
@@ -486,7 +497,12 @@ ${data.recommendations.map((r, i) => `${i + 1}. ${r}`).join('\n')}
 
 ## 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
 
@@ -502,7 +518,7 @@ ${data.recommendations.length === 0 ? noRecommendations : data.recommendations.m
     // ==========================================================================
     // Utilities
     // ==========================================================================
-    async ensureDirectories(taskType) {
+    async ensureDirectories(_taskType) {
         const dirs = [
             this.resultsDir,
             path.join(this.resultsDir, 'security'),
@@ -515,8 +531,67 @@ ${data.recommendations.length === 0 ? noRecommendations : data.recommendations.m
             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}`);
+    }
+    /**
+     * File name for a generated test source: the sanitized name capped at
+     * MAX_GENERATED_STEM_LENGTH characters (a long source file name would
+     * otherwise exceed the filesystem's 255-byte limit once the temp-file suffix
+     * is added) plus a short hash of the source path and full name. The hash keeps
+     * `src/one/math.ts` and `src/two/math.ts` (or a truncated long name) from
+     * overwriting each other, while the same test still maps to the same file.
+     */
+    generatedTestFilename(test, ext) {
+        const stem = this.sanitizeFilename(test.name).slice(0, MAX_GENERATED_STEM_LENGTH) || 'test';
+        const hash = createHash('sha256')
+            .update(`${test.file ?? ''}\0${test.name}`)
+            .digest('hex')
+            .slice(0, 8);
+        return `${stem}-${hash}${ext}`;
     }
     sanitizeFilename(name) {
         return name.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
@@ -555,7 +630,10 @@ ${data.recommendations.length === 0 ? noRecommendations : data.recommendations.m
                 };
             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 } : {}),
                 };
@@ -568,8 +646,26 @@ ${data.recommendations.length === 0 ? noRecommendations : data.recommendations.m
                 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');
@@ -598,9 +694,13 @@ ${data.recommendations.length === 0 ? noRecommendations : data.recommendations.m
         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;
@@ -106,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

@@ -16,6 +16,7 @@ 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
@@ -54,9 +55,15 @@ function resolveQualityAnalyzerService(memory) {
     const factory = DomainServiceRegistry.resolve(ServiceKeys.QualityAnalyzerService);
     return factory(memory);
 }
-/** #996: structured details, only from the one error type that is known to carry them. */
+/**
+ * #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) {
-    return error instanceof InsufficientQualityEvidenceError ? { ...error.toDetails() } : undefined;
+    if (error instanceof InsufficientQualityEvidenceError)
+        return { ...error.toDetails() };
+    return isCallerInputError(error) ? { callerError: true } : undefined;
 }
 // ============================================================================
 // ADR-051: Model Routing Support
@@ -141,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',
         };
@@ -240,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);
@@ -498,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/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
@@ -301,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