agentic-qe 3.15.12 → 3.15.14

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

@@ -52,6 +52,25 @@ async function confineTarget(taskType, target) {
         return ok(undefined);
     return requirePayloadPath(taskType, 'target', target, { allowDirectory: true, allowMissing: true });
 }
+/**
+ * #1224: index the files for the code-intelligence search (the index the
+ * Queen's `search` task reads), not only the knowledge graph. Returns warnings
+ * for the index result.
+ */
+async function indexFilesForSearch(ctx, indexedFiles) {
+    const unavailable = 'Search index not updated: the code-intelligence domain is unavailable, so a code search will not find these files.';
+    if (!ctx.getCodeIntelligenceCoordinator)
+        return [unavailable];
+    try {
+        const coordinator = await ctx.getCodeIntelligenceCoordinator();
+        if (!coordinator)
+            return [unavailable];
+        return (await coordinator.indexForSearch(indexedFiles)).warnings;
+    }
+    catch (error) {
+        return [`Search index not updated: ${toError(error).message}`];
+    }
+}
 export function registerCodeIntelligenceHandlers(ctx) {
     // Register code indexing handler - REAL IMPLEMENTATION
     ctx.registerHandler('index-code', async (task) => {
@@ -108,6 +127,7 @@ export function registerCodeIntelligenceHandlers(ctx) {
             // 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, indexedFiles);
+            const searchWarnings = await indexFilesForSearch(ctx, indexedFiles);
             // Detect languages from files
             const detectedLanguages = new Set();
             const extToLang = {
@@ -140,7 +160,7 @@ export function registerCodeIntelligenceHandlers(ctx) {
                 languages: Array.from(detectedLanguages),
                 duration: indexResult.duration,
                 errors: indexResult.errors,
-                warnings: indexResult.warnings,
+                warnings: [...(indexResult.warnings ?? []), ...searchWarnings],
                 skipped: indexResult.skipped ?? [],
                 ...(projectMetrics ? { projectMetrics } : {}),
             });

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

@@ -16,6 +16,7 @@
  * Either one makes the evidence insufficient: no verdict may pass on it.
  */
 import type { FileCoverage } from '../../domains/coverage-analysis/interfaces';
+import type { ExcludedCoverageEntry } from '../../domains/coverage-analysis/collected-metrics.js';
 /** The report is older than these source files. */
 export interface StaleReport {
     reportPath: string;
@@ -35,6 +36,17 @@ export interface CoverageEvidence {
         source: string;
         readable: boolean;
     };
+    /**
+     * #1219: report entries left out of the figures because they are not a
+     * measurement of a project file (outside the root, a Windows path on POSIX,
+     * or one file under two spellings).
+     */
+    excludedEntries?: ExcludedCoverageEntry[];
+    /**
+     * #1219: project files the report lists under two spellings. Which entry is
+     * right is unknown, so they are UNMEASURED and the evidence is insufficient.
+     */
+    conflictingFiles?: string[];
 }
 /**
  * Production source files under a directory `target` that the report has no
@@ -66,10 +78,17 @@ export declare function assessCoverageEvidence(report: {
 }, measuredFiles: FileCoverage[], projectRoot: string, target: string, options?: {
     reportPath?: string;
     checkCompleteness?: boolean;
+    excluded?: ExcludedCoverageEntry[];
 }): CoverageEvidence;
 /**
  * Why the evidence is insufficient, one sentence per problem; empty when it is
  * complete. Shared by MCP and CLI so the wording cannot drift.
  */
 export declare function describeEvidence(evidence: CoverageEvidence | undefined, projectRoot: string): string[];
+/**
+ * #1219: one line naming the report entries left out of the figures as not
+ * project files (empty when none were). A note, not an evidence gap: those
+ * entries never were the project's coverage. Shared by MCP and CLI.
+ */
+export declare function describeExcludedEntries(evidence: CoverageEvidence | undefined): string[];
 //# sourceMappingURL=coverage-evidence.d.ts.map

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

@@ -115,12 +115,16 @@ export function assessCoverageEvidence(report, measuredFiles, projectRoot, targe
     const stale = options.reportPath
         ? findStaleness(options.reportPath, [...sources].filter(file => fs.existsSync(file)))
         : undefined;
+    const excluded = options.excluded ?? [];
+    const conflicting = [...new Set(excluded.flatMap(e => (e.file ? [e.file] : [])))].sort();
     return {
-        status: unmeasured.length > 0 || stale ? 'insufficient-evidence' : 'complete',
+        status: unmeasured.length > 0 || stale || conflicting.length > 0 ? 'insufficient-evidence' : 'complete',
         unmeasuredFiles: unmeasured,
-        targetFiles: sources.size,
+        targetFiles: sources.size + conflicting.filter(file => !sources.has(file)).length,
         ...(stale ? { stale } : {}),
         ...(coverageScope ? { coverageScope } : {}),
+        ...(excluded.length > 0 ? { excludedEntries: excluded } : {}),
+        ...(conflicting.length > 0 ? { conflictingFiles: conflicting } : {}),
     };
 }
 const MAX_LISTED = 5;
@@ -148,6 +152,12 @@ export function describeEvidence(evidence, projectRoot) {
             'the report with coverage for the whole target, or exclude files that are not meant to be measured in the ' +
             `coverage tool's include/exclude config.${scopeNote}`);
     }
+    const conflicting = evidence.conflictingFiles ?? [];
+    if (conflicting.length > 0) {
+        reasons.push(`${conflicting.length} source file${conflicting.length === 1 ? ' is' : 's are'} listed in the coverage ` +
+            'report under two spellings (e.g. `./src/a.ts` and `src/a.ts`), so which entry is right is unknown; ' +
+            `they are UNMEASURED and left out of the figures: ${listFiles(conflicting, projectRoot)}`);
+    }
     if (evidence.stale) {
         const m = evidence.stale.newerFiles.length;
         reasons.push(`the coverage report ${path.relative(projectRoot, evidence.stale.reportPath) || evidence.stale.reportPath} ` +
@@ -156,4 +166,23 @@ export function describeEvidence(evidence, projectRoot) {
     }
     return reasons;
 }
+const EXCLUDED_WHY = {
+    'outside-project': 'outside the project root',
+    'windows-path': 'a Windows path, which cannot name a file here',
+    'duplicate-spelling': 'a second spelling of a file the report already lists',
+};
+/**
+ * #1219: one line naming the report entries left out of the figures as not
+ * project files (empty when none were). A note, not an evidence gap: those
+ * entries never were the project's coverage. Shared by MCP and CLI.
+ */
+export function describeExcludedEntries(evidence) {
+    const outside = (evidence?.excludedEntries ?? []).filter(e => e.reason !== 'duplicate-spelling');
+    if (outside.length === 0)
+        return [];
+    const shown = outside.slice(0, MAX_LISTED).map(e => `${e.path} (${EXCLUDED_WHY[e.reason]})`);
+    const more = outside.length > MAX_LISTED ? `, … ${outside.length - MAX_LISTED} more` : '';
+    return [`${outside.length} coverage report entr${outside.length === 1 ? 'y is' : 'ies are'} not a project file and ` +
+            `${outside.length === 1 ? 'is' : 'are'} left out of the figures: ${shown.join(', ')}${more}.`];
+}
 //# sourceMappingURL=coverage-evidence.js.map

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

@@ -9,7 +9,7 @@ import { toError } from '../../shared/error-utils.js';
 import { requirePayloadPath } from '../../shared/io/payload-path-guard.js';
 import { buildEstimatedCoverage, collectRustCoverage, findCargoRoot, isCoverageExecDisabled, isRustProject, } from './coverage-collection.js';
 import { describeNoData, evaluateCoverageForTarget, isUnmeasured, packageFilterForTarget, resolveExistingCoverage, scopeCoverageToTarget, reconcileRecommendations, thresholdVerdict, } from './coverage-target.js';
-import { describeEvidence } from './coverage-evidence.js';
+import { describeEvidence, describeExcludedEntries } from './coverage-evidence.js';
 import { randomUUID } from 'crypto';
 import * as path from 'path';
 import { describeRunFailure, runJsCoverage, testRunStatus } from './coverage-runner.js';
@@ -289,6 +289,8 @@ export function registerCoverageHandlers(ctx) {
             if (evidenceReasons.length > 0) {
                 warnings.push(`INSUFFICIENT EVIDENCE — the threshold is not met on this report: ${evidenceReasons.join('; ').replace(/\.?$/, '.')}`);
             }
+            // #1219: entries that are not project files are named, not silently dropped.
+            warnings.push(...describeExcludedEntries(evidence));
             // #569: the analyzer generates recommendations from the summary numbers.
             // When branch or function data was never collected, those numbers are 0
             // by construction, and the resulting advice ("Branch coverage is
@@ -325,6 +327,8 @@ export function registerCoverageHandlers(ctx) {
                     evidenceStatus: evidence.status,
                     unmeasuredFiles: evidence.unmeasuredFiles,
                     ...(evidence.stale ? { staleReport: evidence.stale } : {}),
+                    ...(evidence.conflictingFiles ? { conflictingFiles: evidence.conflictingFiles } : {}),
+                    ...(evidence.excludedEntries ? { excludedReportEntries: evidence.excludedEntries } : {}),
                 } : {}),
                 delta: report.delta,
                 recommendations,

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

@@ -26,6 +26,7 @@ import { loadCoverageReport, parseCoberturaXml, parseCoverageJson, parseCoverage
 import { isTestPath } from './coverage-collection.js';
 import { assessCoverageEvidence } from './coverage-evidence.js';
 import { findProjectRoot } from '../../kernel/project-root.js';
+import { classifyProjectCoveragePaths } from '../../domains/coverage-analysis/collected-metrics.js';
 // ============================================================================
 // Project root
 // ============================================================================
@@ -428,7 +429,12 @@ export function scopeCoverageToTarget(data, root, target) {
 export function evaluateCoverageForTarget(report, projectRoot, target, options = {}) {
     if (options.numTotalTests === 0)
         return { status: 'no-data', reason: 'no-tests-ran' };
-    const scoped = scopeCoverageToTarget(report, projectRoot, target);
+    // #1219: an entry that is not a measurement of a project file (outside the
+    // root, a Windows path on POSIX, one file under two spellings) is not part
+    // of the figures — the same rule as the per-file records (#1030).
+    const inTarget = scopeCoverageToTarget(report, projectRoot, target);
+    const { keys, excluded } = classifyProjectCoveragePaths(inTarget.map(f => f.path), projectRoot);
+    const scoped = inTarget.filter(f => keys.has(f.path));
     if (scoped.length === 0)
         return { status: 'no-data', reason: 'target-not-covered' };
     // Coverage OF a test file is not production coverage (#569). A report with
@@ -438,6 +444,7 @@ export function evaluateCoverageForTarget(report, projectRoot, target, options =
         return { status: 'no-data', reason: 'test-only-report' };
     const evidence = assessCoverageEvidence(report, production, projectRoot, target, {
         reportPath: options.reportPath, checkCompleteness: options.checkCompleteness,
+        excluded: excluded.filter(e => !e.file || !isTestPath(e.file, projectRoot)),
     });
     return { status: 'measured', files: production, evidence };
 }

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

@@ -13,8 +13,8 @@ import type { TestGeneratorService } from '../../domains/test-generation';
 import type { KnowledgeGraphService } from '../../domains/code-intelligence';
 import type { ICodeIntelligenceCoordinator } from '../../domains/code-intelligence/coordinator';
 import type { QualityAnalyzerService } from '../../domains/quality-assessment';
-/** The coordinator surface the MCP index-code handler needs (#999). */
-export type ProjectMetricsCollector = Pick<ICodeIntelligenceCoordinator, 'collectProjectMetrics'>;
+/** The coordinator surface the MCP index-code handler needs (#999, #1224). */
+export type ProjectMetricsCollector = Pick<ICodeIntelligenceCoordinator, 'collectProjectMetrics' | 'indexForSearch'>;
 /** Signature of a single task handler */
 export type InstanceTaskHandler = (task: QueenTask) => Promise<Result<unknown, Error>>;
 /**

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

@@ -123,6 +123,12 @@ export declare function discoverSourceFiles(targetPath: string, options?: {
     includeTests?: boolean;
     languages?: string[];
     maxFiles?: number;
+    /**
+     * #1020: also include component files (.vue, .svelte) and symlinked files.
+     * For callers that judge the whole source scope (quality assessment) and
+     * read through a reader that contains symlinks to the project root.
+     */
+    completeScope?: boolean;
 }): Promise<string[]>;
 /**
  * Generate security recommendations based on findings

package/dist/coordination/handlers/handler-utils.js

@@ -417,11 +417,11 @@ export function parseCoberturaXml(content) {
  */
 export async function discoverSourceFiles(targetPath, options = {}) {
     const files = [];
-    const { includeTests = true, languages, maxFiles = 5000 } = options;
+    const { includeTests = true, languages, maxFiles = 5000, completeScope = false } = options;
     // Determine file extensions to include
     // Default: scan ALL common source languages unless explicitly filtered
     let extensions = [
-        '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', // JavaScript/TypeScript
+        '.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', // JavaScript/TypeScript
         '.py', '.pyw', // Python
         '.go', // Go
         '.rs', // Rust
@@ -437,7 +437,7 @@ export async function discoverSourceFiles(targetPath, options = {}) {
         extensions = [];
         for (const lang of languages) {
             if (lang === 'typescript')
-                extensions.push('.ts', '.tsx');
+                extensions.push('.ts', '.tsx', '.mts', '.cts');
             if (lang === 'javascript')
                 extensions.push('.js', '.jsx', '.mjs', '.cjs');
             if (lang === 'python')
@@ -464,6 +464,8 @@ export async function discoverSourceFiles(targetPath, options = {}) {
                 extensions.push('.scala');
         }
     }
+    if (completeScope && (!languages || languages.length === 0))
+        extensions.push('.vue', '.svelte');
     async function walkDir(dir) {
         try {
             const entries = await fs.readdir(dir, { withFileTypes: true });
@@ -488,7 +490,7 @@ export async function discoverSourceFiles(targetPath, options = {}) {
                         return; // Cap reached
                     await walkDir(fullPath);
                 }
-                else if (entry.isFile()) {
+                else if (entry.isFile() || (completeScope && entry.isSymbolicLink() && await isFileTarget(fullPath))) {
                     const ext = path.extname(entry.name);
                     // Check extension
                     if (!extensions.includes(ext))
@@ -515,6 +517,14 @@ export async function discoverSourceFiles(targetPath, options = {}) {
             // Directory not accessible
         }
     }
+    async function isFileTarget(linkPath) {
+        try {
+            return (await fs.stat(linkPath)).isFile();
+        }
+        catch {
+            return false; // dangling link
+        }
+    }
     // Check if targetPath is a file or directory
     try {
         const stat = await fs.stat(targetPath);

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

@@ -16,8 +16,11 @@ export function registerMiscHandlers(ctx) {
             passed: false,
             violations: [],
             warnings: [],
-            score: 0,
-            note: 'Accessibility testing requires a browser environment (Puppeteer/Playwright). ' +
+            // #1145: nothing was audited, so `passed: false` is not a verdict and the score is -1
+            score: -1,
+            measured: false,
+            note: 'Accessibility NOT MEASURED: this is not a failing result. ' +
+                'Accessibility testing requires a browser environment (Puppeteer/Playwright). ' +
                 'Use tools like axe-core, pa11y, or Lighthouse CLI for WCAG compliance testing. ' +
                 'Example: npx pa11y ' + (payload.url || '<url>'),
         });

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

@@ -89,13 +89,13 @@ async function resolveAnalysisScope(payload) {
             throw new CallerInputError(`target ${JSON.stringify(payload.target)} does not exist.`);
         if (stat.isFile())
             return { sourceFiles: [target], explicitFiles: [target], scope: target };
-        return { sourceFiles: await discoverSourceFiles(target, { includeTests: false }), explicitFiles: [], scope: target };
+        return { sourceFiles: await discoverSourceFiles(target, { includeTests: false, completeScope: true }), explicitFiles: [], scope: target };
     }
     // Default to src/ — scanning the entire project root is too slow
     // (node_modules, dist, .git, etc. make it hang on large projects)
     const srcDir = nodePath.join(root, 'src');
     const targetDir = existsSync(srcDir) ? srcDir : root;
-    return { sourceFiles: await discoverSourceFiles(targetDir, { includeTests: false }), explicitFiles: [], scope: targetDir };
+    return { sourceFiles: await discoverSourceFiles(targetDir, { includeTests: false, completeScope: true }), explicitFiles: [], scope: targetDir };
 }
 /** #1021: one line per partially measured metric, naming the gap. */
 function describePartialMetrics(partial) {
@@ -222,8 +222,16 @@ export function registerQualityHandlers(ctx) {
             const insufficient = sufficiency.evidenceStatus !== 'measured';
             const passed = !insufficient && measuredFailures.length === 0 && report.score.overall >= threshold;
             const recommendations = report.recommendations.map(r => `[${r.type}] ${r.title}: ${r.description}`);
+            // A score that leaves out unmeasured metrics is not the overall score:
+            // -1 with the reason, as the gate's overallScore since #1223. The score
+            // over the measured metrics stays available, labelled as a subset.
+            const subsetScore = report.subsetScore ?? report.score.overall;
             return ok({
-                qualityScore: report.score.overall,
+                qualityScore: insufficient ? UNMEASURED : report.score.overall,
+                ...(insufficient ? {
+                    qualityScoreReason: `not computed: ${sufficiency.unmeasured.join(', ')} unmeasured`,
+                    ...(subsetScore >= 0 ? { subsetScore } : {}),
+                } : {}),
                 passed,
                 threshold,
                 metrics: {

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

@@ -263,8 +263,12 @@ export function registerSecurityHandlers(ctx) {
                     });
                     if (result.success) {
                         dastResult = result.value;
-                        // Legacy DAST results contain findings, but no execution coverage receipt.
-                        engines.push({ ...unverifiedEngine('dast', 'url'), target: payload.targetUrl });
+                        // #1135: probes the target did not answer make DAST partial; the
+                        // findings it did collect are kept. A complete run still has no
+                        // execution coverage receipt, so it stays unverified.
+                        engines.push(dastResult.status === 'incomplete'
+                            ? { ...partialDastEngine(dastResult.failedRequests), target: payload.targetUrl }
+                            : { ...unverifiedEngine('dast', 'url'), target: payload.targetUrl });
                     }
                     else {
                         engines.push({ ...failedEngine('dast', 'url', result.error), target: payload.targetUrl });
@@ -399,6 +403,12 @@ function safeErrorCode(error) {
     const code = error?.code;
     return typeof code === 'string' && /^[A-Z0-9_]{1,32}$/.test(code) ? code : 'UNKNOWN';
 }
+function partialDastEngine(failedRequests) {
+    const codes = [...new Set(failedRequests.map(failure => failure.code))].join(', ');
+    return { id: 'dast', requested: true, required: true, status: 'partial', scope: 'url',
+        ruleCoverage: 'unknown', errors: [`dast incomplete: ${failedRequests.length} request(s) not answered (${codes}).`],
+        limitations: failedRequests.slice(0, 20).map(failure => `dast not answered: ${failure.url} (${failure.code}: ${failure.reason})`) };
+}
 function unverifiedEngine(id, scope) {
     return { id, requested: true, required: true, status: 'unverified', scope,
         ruleCoverage: 'unknown', errors: [], limitations: [`${id} returned no execution receipt; coverage is unverified.`] };

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

@@ -164,11 +164,16 @@ export class SecurityAuditProtocol {
                 const dastResult = await this.runDASTScan(this.config.targetUrl);
                 if (dastResult.success) {
                     this.currentAudit = { ...this.currentAudit, dastResult: dastResult.value };
+                    if (dastResult.value.status !== 'complete') {
+                        this.recordIncompleteCheck(`DAST scan is incomplete: ${dastResult.value.error ?? 'some requests were not answered'}`);
+                    }
                     this.recordIncompleteCheck('DAST coverage is unverified: the scanner returned no execution receipt');
                     await this.publishVulnerabilities(dastResult.value.vulnerabilities);
                 }
                 else {
-                    this.recordIncompleteCheck('DAST scan did not complete');
+                    // #1135: keep the scanner's reason (DAST_AUTHENTICATION_FAILED, DAST_TARGET_UNAVAILABLE, ...).
+                    const code = dastResult.error.code;
+                    this.recordIncompleteCheck(`DAST scan did not complete${typeof code === 'string' ? ` (${code})` : ''}: ${dastResult.error.message}`);
                 }
             }
             else if (auditOptions.includeDAST) {
@@ -284,7 +289,10 @@ export class SecurityAuditProtocol {
                         // Convert scanner result to protocol result format
                         return ok({
                             vulnerabilities: scanResult.value.vulnerabilities,
+                            // #1221: this scanner does not look up latest versions; empty is not "up to date".
                             outdatedPackages: [],
+                            outdatedStatus: 'not-run',
+                            outdatedUnchecked: [],
                             summary: scanResult.value.summary,
                             status: scanResult.value.status,
                             measured: scanResult.value.measured,
@@ -360,6 +368,8 @@ export class SecurityAuditProtocol {
                 if (scanResult.success) {
                     return ok(scanResult.value);
                 }
+                // #1135: the scanner's own failure, with its code, not a generic "unavailable".
+                return err(scanResult.error);
             }
             catch (scannerError) {
                 // Scanner unavailable - log error

package/dist/coordination/result-saver-adapters.js

@@ -37,6 +37,7 @@ function qualityReport(result) {
         : [];
     return {
         ...(typeof score.overall === 'number' ? { qualityScore: score.overall } : {}),
+        ...(typeof data.subsetScore === 'number' ? { subsetScore: data.subsetScore } : {}),
         passed: false,
         gateEvaluated: false,
         metrics: Object.fromEntries(metrics.filter(m => m.name && typeof m.value === 'number').map(m => [m.name, m.value])),

package/dist/coordination/result-saver.js

@@ -501,11 +501,15 @@ ${data.recommendations.map((r, i) => `${i + 1}. ${r}`).join('\n')}
 ## Quality Score
 
 ${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`}
+            : data.qualityScore < 0 && typeof data.subsetScore === 'number'
+                ? `Not computed — unmeasured: ${data.unmeasured?.join(', ') || 'unknown'}.\n`
+                    + `Subset score over measured metrics: ${data.subsetScore.toFixed(1)} (not a verdict)`
+                    + (data.scoreBasis?.length ? `\nBased on: ${data.scoreBasis.join(', ')}` : '')
+                : 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
 

package/dist/coordination/task-executor.js

@@ -15,6 +15,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 { isLearnableResult } from '../learning/learnable-result.js';
 import { createResultSaver } from './result-saver.js';
 import { getProjectStorePath } from '../kernel/project-root.js';
 import { createLogger } from '../logging/logger-factory.js';
@@ -487,8 +488,12 @@ export class DomainTaskExecutor {
                 };
             }
             await this.publishTaskCompleted(task.id, result.value, domain);
-            // ADR-051: Record successful outcome
-            this.recordOutcome(task, routingTier, true, Date.now() - startTime).catch((e) => { logger.warn('recordOutcome failed', { error: e instanceof Error ? e.message : String(e), taskId: task.id }); });
+            // ADR-051: Record successful outcome. #1020: a run without evidence (a
+            // coverage estimate, an insufficient-evidence quality run) completed as a
+            // task but is not a success to learn routing from.
+            if (isLearnableResult(domain, result.value)) {
+                this.recordOutcome(task, routingTier, true, Date.now() - startTime).catch((e) => { logger.warn('recordOutcome failed', { error: e instanceof Error ? e.message : String(e), taskId: task.id }); });
+            }
             // Save results to files if enabled. A task can opt out per call with
             // payload.saveResults === false (#925); the executor-wide config still
             // acts as the global switch.

package/dist/domains/chaos-resilience/services/chaos-engineer.d.ts

@@ -89,6 +89,7 @@ export declare class ChaosEngineerService implements IChaosEngineeringService {
     private executeCommandProbe;
     private executeMetricProbe;
     private performFaultInjection;
+    private notInjected;
     private injectLatency;
     private injectError;
     private injectTimeout;

package/dist/domains/chaos-resilience/services/chaos-engineer.js

@@ -609,32 +609,25 @@ Provide:
         }
         return err(new Error(`Unknown fault type: ${fault.type}`));
     }
+    // #1258: these fault types need infrastructure this process does not control
+    // (a network proxy, service mesh, firewall or DNS server). They used to log a
+    // note and return ok(1), so an experiment reported a fault that never ran.
+    // They now fail with the reason, and injectFault() records injected: false.
+    notInjected(fault, requirement) {
+        return err(new Error(`${fault.type} fault not injected into ${fault.target.selector}: requires ${requirement}, ` +
+            'which this process does not control. Nothing was changed on the target.'));
+    }
     async injectLatency(fault) {
-        // Latency injection is typically done at proxy/network level
-        // For simulation, we store the config and check during probe execution
-        const latencyMs = fault.parameters.latencyMs ?? 100;
-        logger.info(`Latency injection configured: ${latencyMs}ms for ${fault.target.selector}`);
-        logger.info(`Note: Actual latency injection requires network proxy (e.g., Toxiproxy, tc)`);
-        return ok(1);
+        return this.notInjected(fault, 'a network proxy (e.g., Toxiproxy, tc)');
     }
     async injectError(fault) {
-        // Error injection typically requires proxy/service mesh
-        const errorCode = fault.parameters.errorCode ?? 500;
-        logger.info(`Error injection configured: ${errorCode} for ${fault.target.selector}`);
-        logger.info(`Note: Actual error injection requires service mesh (e.g., Istio, Linkerd)`);
-        return ok(1);
+        return this.notInjected(fault, 'a service mesh or proxy (e.g., Istio, Linkerd, Toxiproxy)');
     }
     async injectTimeout(fault) {
-        // Timeout injection via proxy configuration
-        logger.info(`Timeout injection configured for ${fault.target.selector}`);
-        logger.info(`Note: Actual timeout injection requires network proxy configuration`);
-        return ok(1);
+        return this.notInjected(fault, 'a network proxy (e.g., Toxiproxy)');
     }
     async injectPacketLoss(fault) {
-        const lossPercent = fault.parameters.packetLossPercent ?? 10;
-        logger.info(`Packet loss configured: ${lossPercent}% for ${fault.target.selector}`);
-        logger.info(`Note: Actual packet loss requires tc/iptables (Linux) or similar`);
-        return ok(1);
+        return this.notInjected(fault, 'tc/iptables (Linux) or a network proxy');
     }
     async injectCpuStress(fault) {
         // Real CPU stress implementation using busy loops
@@ -689,34 +682,18 @@ Provide:
         }
     }
     async injectDiskStress(fault) {
-        // Disk stress would require file system operations
-        logger.info(`Disk stress configured for ${fault.target.selector}`);
-        logger.info(`Note: Actual disk stress requires file system write permissions`);
-        return ok(1);
+        return this.notInjected(fault, 'file system stress tooling (e.g., stress-ng)');
     }
     async injectNetworkPartition(fault) {
-        // Network partition typically requires iptables or similar
-        logger.info(`Network partition configured for ${fault.target.selector}`);
-        logger.info(`Note: Actual network partition requires iptables/firewall rules`);
-        return ok(1);
+        return this.notInjected(fault, 'iptables/firewall rules');
     }
     async injectDnsFailure(fault) {
-        // DNS failure injection via /etc/hosts or DNS server configuration
-        logger.info(`DNS failure configured for ${fault.target.selector}`);
-        logger.info(`Note: Actual DNS failure requires DNS server or /etc/hosts modification`);
-        return ok(1);
+        return this.notInjected(fault, 'a DNS server or /etc/hosts modification');
     }
     async injectProcessKill(fault) {
-        // Process kill via system commands
-        const processPattern = fault.target.selector;
-        logger.info(`Process kill configured for pattern: ${processPattern}`);
-        logger.info(`Note: Actual process kill requires appropriate permissions`);
-        // In dry-run mode or without permissions, just log
-        if (this.config.enableDryRun) {
-            logger.info(`Would kill processes matching: ${processPattern}`);
-            return ok(0);
-        }
-        return ok(1);
+        // No process is signalled here, so a dry run and a real run both report
+        // the fault as not injected rather than counting a target as affected.
+        return this.notInjected(fault, 'process signalling with appropriate permissions (e.g., Chaos Monkey, Litmus)');
     }
     async performFaultRemoval(fault) {
         logger.info(`Removing fault: ${fault.id} (${fault.type})`);
@@ -817,14 +794,15 @@ Provide:
         if (!finalSteadyState) {
             return 'failed';
         }
-        if (execution.result.hypothesisValidated) {
-            return 'completed';
-        }
-        // Check if any faults failed to inject
+        // #1258: a fault that was not injected means the experiment did not run as
+        // designed, so a hypothesis "validated" without it is not a completed run.
         const failedFaults = execution.result.faultResults.filter((f) => !f.injected);
         if (failedFaults.length > 0) {
             return 'failed';
         }
+        if (execution.result.hypothesisValidated) {
+            return 'completed';
+        }
         return 'completed';
     }
     async rollbackExperiment(experiment) {

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

@@ -2,10 +2,10 @@
  * Code Intelligence - GNN Integration
  * Extracted from coordinator.ts for CQ-004 (file size reduction)
  *
- * Contains: GNN embedding indexing, code embedding generation, GNN search
+ * Contains: GNN embedding indexing, code embedding generation
  */
 import { QEGNNEmbeddingIndex } from '../../integrations/ruvector/wrappers';
-import type { ImpactRequest, SearchResult } from './interfaces';
+import type { ImpactRequest } from './interfaces';
 import { FileReader } from '../../shared/io';
 export declare function initializeGNNIndex(domainKey: string): QEGNNEmbeddingIndex;
 /**
@@ -23,24 +23,10 @@ export declare function generateGraphMAEEmbeddings(fileReader: FileReader, paths
  * Generate code embedding using semantic features
  */
 export declare function generateCodeEmbedding(path: string, content: string): Promise<number[]>;
-/**
- * Search code with GNN for enhanced similarity
- */
-export declare function searchCodeWithGNN(gnnIndex: QEGNNEmbeddingIndex, query: string): Promise<Array<{
-    file: string;
-    similarity: number;
-}>>;
 /**
  * Enhance impact analysis with GNN semantic similarity
  */
 export declare function enhanceImpactAnalysisWithGNN(gnnIndex: QEGNNEmbeddingIndex, fileReader: FileReader, request: ImpactRequest): Promise<void>;
-/**
- * Merge search results from semantic search and GNN
- */
-export declare function mergeSearchResults(semanticResults: SearchResult[], gnnResults: Array<{
-    file: string;
-    similarity: number;
-}>): SearchResult[];
 /**
  * R6: Train GNN embeddings with memory-bounded cold-tier training.
  * Uses LRU hotset caching when the graph exceeds hotsetSize, falling