agentic-qe 3.15.12 → 3.15.14

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

@@ -6,9 +6,18 @@ import { createHash } from 'node:crypto';
 import { ok, err } from '../../../shared/types/index.js';
 import { NomicEmbedder, EMBEDDING_CONFIG, } from '../../../shared/embeddings/index.js';
 import { toError } from '../../../shared/error-utils.js';
+/**
+ * #1224: the message for a search over an empty index. "No results" is only
+ * reported after searching an index that holds code.
+ */
+export const NOTHING_INDEXED_FOR_SEARCH = 'No code is indexed for search yet, so the search was not run. ' +
+    'Index the project first (MCP code_index, or `aqe code index <path>`), then search again.';
+/** Upper bound on indexed files one exact/fuzzy search reads. */
+const MAX_INDEXED_FILES_SCANNED = 100_000;
 const DEFAULT_CONFIG = {
     embeddingDimension: EMBEDDING_CONFIG.DIMENSIONS, // 384 for all-MiniLM-L6-v2
     minScore: 0.5,
+    minVectorScore: 0.3,
     maxResults: 100,
     namespace: 'code-intelligence:semantic',
     enableCaching: true,
@@ -26,6 +35,8 @@ export class SemanticAnalyzerService {
     analysisCache = new Map();
     embedder = null;
     embedderInitialized = false;
+    /** #1224: why no embedder is in use, once initialization has run. */
+    embedderUnavailableReason = null;
     constructor(memory, config = {}) {
         this.memory = memory;
         this.config = { ...DEFAULT_CONFIG, ...config };
@@ -43,9 +54,11 @@ export class SemanticAnalyzerService {
             return;
         }
         if (this.config.useNomicEmbeddings) {
+            // #1224: no pseudo-embedding fallback. A failed embed throws, and the
+            // search reports itself as lexical-only instead.
             const nomicEmbedder = new NomicEmbedder({
-                enableFallback: true,
                 ...this.config.nomicConfig,
+                enableFallback: false,
             });
             // Check if Ollama is available
             const isAvailable = await nomicEmbedder.healthCheck();
@@ -55,6 +68,13 @@ export class SemanticAnalyzerService {
                 this.config.embeddingDimension =
                     EMBEDDING_CONFIG.DIMENSIONS;
             }
+            else {
+                this.embedderUnavailableReason =
+                    `no embedding model available (Ollama model '${EMBEDDING_CONFIG.MODEL}' is not reachable)`;
+            }
+        }
+        else {
+            this.embedderUnavailableReason = 'embeddings are disabled for code search';
         }
         this.embedderInitialized = true;
     }
@@ -65,11 +85,23 @@ export class SemanticAnalyzerService {
         const startTime = Date.now();
         try {
             const { query, type, scope, limit = this.config.maxResults, filters } = request;
+            if (type !== 'semantic' && type !== 'exact' && type !== 'fuzzy') {
+                return err(new Error(`Unknown search type: ${type}`));
+            }
+            // #1224: an empty answer from an empty index is not "no results".
+            const indexed = await this.memory.search(this.contentKeyPattern(), 1);
+            if (indexed.length === 0) {
+                return err(new Error(NOTHING_INDEXED_FOR_SEARCH));
+            }
             let results;
+            let lexicalOnlyReason;
             switch (type) {
-                case 'semantic':
-                    results = await this.semanticSearch(query, limit, scope, filters);
+                case 'semantic': {
+                    const semantic = await this.semanticSearch(query, limit, scope, filters);
+                    results = semantic.results;
+                    lexicalOnlyReason = semantic.lexicalOnlyReason;
                     break;
+                }
                 case 'exact':
                     results = await this.exactSearch(query, limit, scope, filters);
                     break;
@@ -84,6 +116,11 @@ export class SemanticAnalyzerService {
                 results,
                 total: results.length,
                 searchTime,
+                ...(type === 'semantic'
+                    ? lexicalOnlyReason === undefined
+                        ? { mode: 'vector' }
+                        : { mode: 'lexical-only', reason: lexicalOnlyReason }
+                    : {}),
             });
         }
         catch (error) {
@@ -95,17 +132,20 @@ export class SemanticAnalyzerService {
      */
     async indexCode(file, content) {
         try {
-            // Generate embedding for the code
-            const embedding = await this.getEmbedding(content);
             // Extract code metadata
             const metadata = this.extractCodeMetadata(file, content);
-            // Store in vector index
-            const key = `${this.config.namespace}:code:${this.fileToKey(file)}`;
-            await this.memory.storeVector(key, embedding, {
-                file,
-                ...metadata,
-                indexedAt: new Date().toISOString(),
-            });
+            // #1224: store a vector only when a real embedding model produced one;
+            // without it the file is still searchable by text.
+            const embedded = await this.tryEmbed(content);
+            if (embedded.vector) {
+                const key = `${this.vectorKeyPrefix()}${this.fileToKey(file)}`;
+                await this.memory.storeVector(key, embedded.vector, {
+                    file,
+                    ...metadata,
+                    embeddingModel: this.embeddingModelId(),
+                    indexedAt: new Date().toISOString(),
+                });
+            }
             // Store content for retrieval.
             // The key is already fully namespace-qualified, so do NOT also pass a
             // {namespace} store option: every read path (semanticSearch/findSimilar/
@@ -126,13 +166,13 @@ export class SemanticAnalyzerService {
     async findSimilar(code, limit = 10) {
         try {
             const embedding = await this.getEmbedding(code);
-            const vectorResults = await this.memory.vectorSearch(embedding, limit);
+            const vectorResults = await this.memory.vectorSearch(embedding, limit, this.vectorKeyPrefix());
             const results = [];
             for (const vr of vectorResults) {
-                if (vr.score < this.config.minScore)
+                if (vr.score < this.config.minVectorScore)
                     continue;
                 const metadata = vr.metadata;
-                if (!metadata?.file)
+                if (!metadata?.file || !this.isCurrentModelVector(metadata))
                     continue;
                 const contentKey = `${this.config.namespace}:content:${this.fileToKey(metadata.file)}`;
                 const stored = await this.memory.get(contentKey);
@@ -190,8 +230,9 @@ export class SemanticAnalyzerService {
         }
     }
     /**
-     * Get embedding vector for code
-     * Uses Nomic embeddings via Ollama when available, falls back to pseudo-embeddings
+     * Get embedding vector for code.
+     * Uses Nomic embeddings via Ollama (or the injected provider). Throws when
+     * neither is available: no pseudo-embedding is substituted (#1224, ADR-097).
      */
     async getEmbedding(code) {
         // Check cache
@@ -201,15 +242,10 @@ export class SemanticAnalyzerService {
         }
         // Initialize embedder lazily
         await this.initializeEmbedder();
-        // Generate embedding using Nomic or fallback
-        let embedding;
-        if (this.embedder) {
-            embedding = await this.embedder.embed(code);
-        }
-        else {
-            // Fallback to pseudo-embedding when Ollama is not available
-            embedding = this.generateCodeEmbedding(code);
+        if (!this.embedder) {
+            throw new Error(`Code embeddings unavailable: ${this.embedderUnavailableReason ?? 'no embedding model'}`);
         }
+        const embedding = await this.embedder.embed(code);
         // Cache result
         if (this.config.enableCaching) {
             this.cacheEmbedding(cacheKey, embedding);
@@ -222,22 +258,67 @@ export class SemanticAnalyzerService {
     isUsingNomicEmbeddings() {
         return this.embedder !== null && this.embedder instanceof NomicEmbedder;
     }
+    /** #1224: embed `text`, or say why no real embedding is available. */
+    async tryEmbed(text) {
+        await this.initializeEmbedder();
+        if (!this.embedder) {
+            return { reason: this.embedderUnavailableReason ?? 'no embedding model available' };
+        }
+        try {
+            return { vector: await this.getEmbedding(text) };
+        }
+        catch (error) {
+            return { reason: `the embedding model failed: ${toError(error).message}` };
+        }
+    }
+    /** Identifies the model behind stored vectors, so vectors from another model are not compared. */
+    embeddingModelId() {
+        return this.embedder instanceof NomicEmbedder ? EMBEDDING_CONFIG.MODEL : 'injected-provider';
+    }
+    isCurrentModelVector(metadata) {
+        return metadata.embeddingModel === this.embeddingModelId();
+    }
+    vectorKeyPrefix() {
+        return `${this.config.namespace}:code:`;
+    }
+    contentKeyPattern() {
+        return `${this.config.namespace}:content:*`;
+    }
     // ============================================================================
     // Private Search Methods
     // ============================================================================
+    /**
+     * #1224: vector search when an embedding model is available. Otherwise (or
+     * when no indexed file has a vector from that model) it matches query words
+     * against the indexed text and says so through `lexicalOnlyReason`; no
+     * similarity is invented for those hits.
+     */
     async semanticSearch(query, limit, scope, filters) {
-        // Generate query embedding
-        const queryEmbedding = await this.getEmbedding(query);
-        // Perform vector search
-        const vectorResults = await this.memory.vectorSearch(queryEmbedding, limit * 2);
+        const embedded = await this.tryEmbed(query);
+        if (!embedded.vector) {
+            return {
+                results: await this.lexicalSearch(query, limit, scope, filters),
+                lexicalOnlyReason: embedded.reason,
+            };
+        }
+        // Only this namespace's vectors, from the model that embedded the query.
+        const vectorResults = (await this.memory.vectorSearch(embedded.vector, limit * 2, this.vectorKeyPrefix()))
+            .filter((vr) => {
+            const metadata = vr.metadata;
+            return !!metadata?.file && this.isCurrentModelVector(metadata);
+        });
+        if (vectorResults.length === 0) {
+            return {
+                results: await this.lexicalSearch(query, limit, scope, filters),
+                lexicalOnlyReason: `no indexed file has an embedding from ${this.embeddingModelId()}; re-index to enable vector search`,
+            };
+        }
         // Convert to search results with filtering
         const results = [];
         for (const vr of vectorResults) {
-            if (vr.score < this.config.minScore)
+            if (vr.score < this.config.minVectorScore)
                 continue;
             const metadata = vr.metadata;
-            if (!metadata?.file)
-                continue;
             // Apply scope filter
             if (scope && scope.length > 0) {
                 const matchesScope = scope.some((s) => metadata.file.includes(s));
@@ -258,17 +339,23 @@ export class SemanticAnalyzerService {
                     score: vr.score,
                     highlights: this.findSemanticHighlights(stored.content, query),
                     metadata: stored.metadata,
+                    matchType: 'vector',
                 });
                 if (results.length >= limit)
                     break;
             }
         }
-        return results;
+        return { results };
+    }
+    /** Word-overlap matching for a semantic query when no vectors can be used. */
+    async lexicalSearch(query, limit, scope, filters) {
+        const hits = await this.fuzzySearch(query, limit, scope, filters);
+        return hits.map((hit) => ({ ...hit, matchType: 'lexical' }));
     }
     async exactSearch(query, limit, scope, filters) {
         const results = [];
-        const pattern = `${this.config.namespace}:content:*`;
-        const keys = await this.memory.search(pattern, limit * 3);
+        // #1224: scan every indexed file; a cap here hid matches in later files.
+        const keys = await this.memory.search(this.contentKeyPattern(), MAX_INDEXED_FILES_SCANNED);
         for (const key of keys) {
             const stored = await this.memory.get(key);
             if (!stored)
@@ -303,8 +390,7 @@ export class SemanticAnalyzerService {
     }
     async fuzzySearch(query, limit, scope, filters) {
         const results = [];
-        const pattern = `${this.config.namespace}:content:*`;
-        const keys = await this.memory.search(pattern, limit * 5);
+        const keys = await this.memory.search(this.contentKeyPattern(), MAX_INDEXED_FILES_SCANNED);
         const queryTokens = this.tokenize(query.toLowerCase());
         for (const key of keys) {
             const stored = await this.memory.get(key);
@@ -324,7 +410,7 @@ export class SemanticAnalyzerService {
             const contentTokens = this.tokenize(stored.content.toLowerCase());
             const score = this.calculateFuzzyScore(queryTokens, contentTokens);
             if (score >= this.config.minScore) {
-                const matchedTokens = queryTokens.filter((t) => contentTokens.some((ct) => ct.includes(t) || t.includes(ct)));
+                const matchedTokens = queryTokens.filter((t) => contentTokens.some((ct) => this.tokensMatch(t, ct)));
                 results.push({
                     file: stored.file,
                     snippet: this.extractSnippet(stored.content, 200),
@@ -500,38 +586,6 @@ export class SemanticAnalyzerService {
     // ============================================================================
     // Private Helper Methods
     // ============================================================================
-    generateCodeEmbedding(code) {
-        // Fallback: Generate a pseudo-embedding based on code features
-        // Used when Ollama/Nomic is not available
-        const embedding = new Array(this.config.embeddingDimension).fill(0);
-        // Extract tokens and features
-        const tokens = this.tokenize(code);
-        const concepts = this.extractConcepts(code);
-        // Combine token-based and concept-based features
-        for (let i = 0; i < tokens.length; i++) {
-            const token = tokens[i];
-            for (let j = 0; j < token.length && j < embedding.length; j++) {
-                embedding[(i + j) % embedding.length] += token.charCodeAt(j) / 1000;
-            }
-        }
-        // Add concept signals
-        const conceptIndex = new Map([
-            ['object-oriented', 0],
-            ['asynchronous', 1],
-            ['functional', 2],
-            ['type-safe', 3],
-            ['modular', 4],
-        ]);
-        for (const concept of concepts) {
-            const idx = conceptIndex.get(concept);
-            if (idx !== undefined) {
-                embedding[idx] += 0.5;
-            }
-        }
-        // Normalize
-        const magnitude = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0)) || 1;
-        return embedding.map((v) => v / magnitude);
-    }
     extractCodeMetadata(file, content) {
         return {
             language: this.detectLanguage(file),
@@ -564,12 +618,21 @@ export class SemanticAnalyzerService {
             return 0;
         let matches = 0;
         for (const qt of queryTokens) {
-            if (contentTokens.some((ct) => ct.includes(qt) || qt.includes(ct))) {
+            if (contentTokens.some((ct) => this.tokensMatch(qt, ct))) {
                 matches++;
             }
         }
         return matches / queryTokens.length;
     }
+    /**
+     * A content token matches a query token it contains, or that contains it.
+     * #1224: the second direction needs a content token of 3+ characters, so a
+     * one-letter variable such as `i` does not match the query "login".
+     */
+    tokensMatch(queryToken, contentToken) {
+        return contentToken.includes(queryToken) ||
+            (contentToken.length >= 3 && queryToken.includes(contentToken));
+    }
     matchesFilters(metadata, filters) {
         for (const filter of filters) {
             const value = metadata[filter.field];

package/dist/domains/coverage-analysis/collected-metrics.d.ts

@@ -14,6 +14,32 @@ import type { CoverageSummary, FileCoverage } from './interfaces';
  * (or the cwd when none is known), so one file never has two records.
  */
 export declare function fileCoverageKey(filePath: string, projectRoot?: string): string;
+/** Why a report entry is not a measurement of a project file (#1030, #1219). */
+export type ExcludedCoverageReason = 'outside-project' | 'windows-path' | 'duplicate-spelling';
+/** A report entry left out of per-file records and of the report's summary. */
+export interface ExcludedCoverageEntry {
+    /** The path as the report wrote it. */
+    path: string;
+    reason: ExcludedCoverageReason;
+    /** For `duplicate-spelling`: the project file both spellings name. */
+    file?: string;
+}
+/**
+ * #1030, #1219: sort the paths of ONE report into project files (with their
+ * per-file record key, keyed by the path as the report wrote it) and entries
+ * that are not a measurement of a project file: a path that resolves outside
+ * the project root (lcov `SF:../../outside.ts`), a Windows absolute path read
+ * on POSIX (it would resolve to a junk key), or a file the report lists under
+ * two spellings (`./src/a.ts` and `src/a.ts`), so which entry is right is
+ * unknown. A path under the root's realpath (macOS `/private/var` for
+ * `/var`) is inside.
+ */
+export declare function classifyProjectCoveragePaths(paths: readonly string[], projectRoot?: string): {
+    keys: Map<string, string>;
+    excluded: ExcludedCoverageEntry[];
+};
+/** #1030: the per-file record key of each project file in ONE report (see `classifyProjectCoveragePaths`). */
+export declare function projectFileCoverageKeys(paths: readonly string[], projectRoot?: string): Map<string, string>;
 /** Read the canonical key first, then a measured legacy relative key if present. */
 export declare function fileCoverageLookupKeys(filePath: string, projectRoot?: string): string[];
 export interface CollectedMetrics {

package/dist/domains/coverage-analysis/collected-metrics.js

@@ -6,6 +6,7 @@
  * summary figure is 0 by construction, and must be reported AND persisted as
  * null — never as 0% (a fake low figure) nor as istanbul's 0/0 = 100%.
  */
+import * as fs from 'fs';
 import * as path from 'path';
 import { findProjectRoot } from '../../kernel/project-root.js';
 /**
@@ -17,6 +18,59 @@ import { findProjectRoot } from '../../kernel/project-root.js';
 export function fileCoverageKey(filePath, projectRoot) {
     return path.isAbsolute(filePath) ? path.normalize(filePath) : path.resolve(projectRoot ?? findProjectRoot(), filePath);
 }
+function isInside(root, key) {
+    const relative = path.relative(root, key);
+    return relative !== '' && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function realRoot(root) {
+    try {
+        return fs.realpathSync(root);
+    }
+    catch {
+        return root;
+    }
+}
+/**
+ * #1030, #1219: sort the paths of ONE report into project files (with their
+ * per-file record key, keyed by the path as the report wrote it) and entries
+ * that are not a measurement of a project file: a path that resolves outside
+ * the project root (lcov `SF:../../outside.ts`), a Windows absolute path read
+ * on POSIX (it would resolve to a junk key), or a file the report lists under
+ * two spellings (`./src/a.ts` and `src/a.ts`), so which entry is right is
+ * unknown. A path under the root's realpath (macOS `/private/var` for
+ * `/var`) is inside.
+ */
+export function classifyProjectCoveragePaths(paths, projectRoot) {
+    const root = path.resolve(projectRoot ?? findProjectRoot());
+    const canonicalRoot = realRoot(root);
+    const keys = new Map();
+    const excluded = [];
+    const spellings = new Map();
+    for (const filePath of paths) {
+        if (!path.isAbsolute(filePath) && path.win32.isAbsolute(filePath)) {
+            excluded.push({ path: filePath, reason: 'windows-path' });
+            continue;
+        }
+        const key = fileCoverageKey(filePath, root);
+        if (!isInside(root, key) && !isInside(canonicalRoot, key)) {
+            excluded.push({ path: filePath, reason: 'outside-project' });
+            continue;
+        }
+        keys.set(filePath, key);
+        spellings.set(key, (spellings.get(key) ?? 0) + 1);
+    }
+    for (const [filePath, key] of keys) {
+        if ((spellings.get(key) ?? 0) > 1) {
+            keys.delete(filePath);
+            excluded.push({ path: filePath, reason: 'duplicate-spelling', file: key });
+        }
+    }
+    return { keys, excluded };
+}
+/** #1030: the per-file record key of each project file in ONE report (see `classifyProjectCoveragePaths`). */
+export function projectFileCoverageKeys(paths, projectRoot) {
+    return classifyProjectCoveragePaths(paths, projectRoot).keys;
+}
 /** Read the canonical key first, then a measured legacy relative key if present. */
 export function fileCoverageLookupKeys(filePath, projectRoot) {
     const canonical = `coverage:file:${fileCoverageKey(filePath, projectRoot)}`;

package/dist/domains/coverage-analysis/services/coverage-analyzer.js

@@ -11,7 +11,7 @@ import { safeJsonParse } from '../../../shared/safe-json.js';
 import { writeQualityEvidence, writeTestRunEvidence } from '../../quality-assessment/quality-evidence.js';
 import { measuredCoverageSummary } from '../../quality-assessment/coverage-report-event.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
-import { collectedMetrics, collectedSummary, fileCoverageKey } from '../collected-metrics.js';
+import { collectedMetrics, collectedSummary, projectFileCoverageKeys } from '../collected-metrics.js';
 /**
  * Whether an analyze request carries instrumented (measured) coverage (#1008).
  * Fail-closed: an explicit `request.measured` wins; otherwise only data a
@@ -510,7 +510,11 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
      * (The vector index via storeVector is kept for similarity search.)
      */
     async storeFileCoverageKV(files, projectRoot, runStatus) {
+        const keys = projectFileCoverageKeys(files.map(file => file.path), projectRoot);
         for (const file of files) {
+            const key = keys.get(file.path);
+            if (!key)
+                continue;
             try {
                 // #1014: a metric with no data is null (not collected), never 0%.
                 const pct = (m) => m.total > 0 ? Math.round((m.covered / m.total) * 10000) / 100 : null;
@@ -518,12 +522,14 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
                     continue;
                 // #1014: stamped, so readers can tell it from legacy unstamped
                 // estimate records written by <= 3.15.4.
-                await this.memory.set(`coverage:file:${fileCoverageKey(file.path, projectRoot)}`, {
+                await this.memory.set(`coverage:file:${key}`, {
                     line: pct(file.lines),
                     branch: pct(file.branches),
                     function: pct(file.functions),
                     statement: pct(file.statements),
                     measured: true,
+                    // #1219: the counts behind `line`, so several files can be line-weighted.
+                    lines: { covered: file.lines.covered, total: file.lines.total },
                     ...(runStatus ? { runStatus } : {}),
                 }, { persist: true });
             }
@@ -533,11 +539,15 @@ Provide thoughtful, specific analysis based on the coverage data. Do not include
         }
     }
     async indexFileCoverageVectors(files, projectRoot) {
+        const keys = projectFileCoverageKeys(files.map(file => file.path), projectRoot);
         for (const file of files) {
+            const key = keys.get(file.path);
+            if (!key)
+                continue;
             try {
                 // Create a vector representation of the file coverage
                 const embedding = this.createCoverageEmbedding(file);
-                await this.memory.storeVector(`coverage:file:${fileCoverageKey(file.path, projectRoot)}`, embedding, {
+                await this.memory.storeVector(`coverage:file:${key}`, embedding, {
                     path: file.path,
                     lineCoverage: file.lines.covered / (file.lines.total || 1),
                     branchCoverage: file.branches.covered / (file.branches.total || 1),

package/dist/domains/coverage-analysis/services/coverage-parser.d.ts

@@ -129,6 +129,8 @@ export interface CoverageReport {
     files: Map<string, FileCoverageData>;
     /** Summary statistics */
     summary: CoverageSummary;
+    /** Parts of the report that could not be attributed and are not in `files` (#1232). */
+    warnings?: string[];
 }
 /**
  * Summary statistics for entire coverage report

package/dist/domains/coverage-analysis/services/coverage-parser.js

@@ -461,12 +461,20 @@ export function parseDotcoverContent(content, projectRoot) {
     // Parse <Statement> elements to build per-file coverage
     const stmtPattern = /<Statement\s+FileIndex="(\d+)"\s+Line="(\d+)"\s+Column="\d+"\s+EndLine="\d+"\s+EndColumn="\d+"\s+Covered="(\w+)"\s*\/>/g;
     const fileData = new Map();
+    // #1232: statements whose FileIndex is not in the file table, by index; never named after a made-up file.
+    const unknownIndices = new Map();
+    let statementCount = 0;
     let sm;
     while ((sm = stmtPattern.exec(content)) !== null) {
+        statementCount++;
         const fileIdx = sm[1];
         const lineNum = parseInt(sm[2], 10);
         const isCovered = sm[3] === 'True';
-        const filePath = fileIndex.get(fileIdx) || `file-${fileIdx}`;
+        const filePath = fileIndex.get(fileIdx);
+        if (!filePath) {
+            unknownIndices.set(fileIdx, (unknownIndices.get(fileIdx) ?? 0) + 1);
+            continue;
+        }
         if (!fileData.has(filePath)) {
             fileData.set(filePath, { lineDetails: new Map(), total: 0, covered: 0 });
         }
@@ -476,14 +484,21 @@ export function parseDotcoverContent(content, projectRoot) {
         if (isCovered)
             data.covered++;
     }
+    const warnings = [];
+    if (unknownIndices.size > 0) {
+        const skipped = [...unknownIndices.values()].reduce((sum, n) => sum + n, 0);
+        warnings.push(`dotCover report references FileIndex ${[...unknownIndices.keys()].join(', ')} missing from its file table; ` +
+            `${skipped} statement(s) skipped and their coverage is not reported`);
+    }
     // If no Statement elements found, parse from CoveredStatements/TotalStatements attributes
-    if (fileData.size === 0) {
+    if (statementCount === 0) {
         const rootPattern = /CoveredStatements="(\d+)"\s+TotalStatements="(\d+)"/;
         const rootMatch = rootPattern.exec(content);
         if (rootMatch) {
             const covered = parseInt(rootMatch[1], 10);
             const total = parseInt(rootMatch[2], 10);
             const filePath = path.join(projectRoot, 'aggregate');
+            warnings.push("dotCover report has no per-file statements; report totals are listed under 'aggregate', which is not a project file");
             files.set(filePath, {
                 path: filePath,
                 relativePath: 'aggregate',
@@ -526,6 +541,7 @@ export function parseDotcoverContent(content, projectRoot) {
         language: 'csharp',
         files,
         summary: calculateSummary(files),
+        ...(warnings.length > 0 ? { warnings } : {}),
     };
 }
 // ============================================================================

package/dist/domains/defect-intelligence/services/defect-predictor.js

@@ -16,7 +16,7 @@ import { TypeScriptParser } from '../../../shared/parsers/index.js';
 import { toError } from '../../../shared/error-utils.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { getClaudeModelForTier } from '../../../shared/llm/model-registry.js';
-import { measuredCoverageSummary, measuredFileCoverage } from '../../quality-assessment/coverage-report-event.js';
+import { measuredFileCoverage } from '../../quality-assessment/coverage-report-event.js';
 import { fileCoverageLookupKeys } from '../../coverage-analysis/collected-metrics.js';
 // LLMDefectAnalysis is imported from ../interfaces
 const DEFAULT_CONFIG = {
@@ -616,11 +616,8 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
                     return 1 - fileCoverage.line / 100;
                 }
             }
-            // Fall back to project-wide coverage
-            const summary = measuredCoverageSummary(await this.memory.get('coverage:latest'));
-            if (summary) {
-                return 1 - summary.line / 100;
-            }
+            // #1219: no fallback to the project-wide summary — it is not this
+            // file's coverage. A file with no record of its own gets the prior below.
         }
         catch {
             // Non-critical lookup

package/dist/domains/quality-assessment/coherence/gate-controller.js

@@ -78,6 +78,11 @@ export class CoherenceGateController {
         if (criticalFailure) {
             reasons.push(criticalFailure);
         }
+        // Check 7 (#1020): an unmeasured input is never read as passing, so no
+        // decision can allow. Measured failures above stay the primary reason.
+        if ((lambda.unmeasured?.length ?? 0) > 0) {
+            reasons.push('insufficientEvidence');
+        }
         // Determine tier based on reasons
         return this.determineDecision(lambda, reasons);
     }
@@ -92,6 +97,9 @@ export class CoherenceGateController {
      */
     canDeploy(lambda) {
         const decision = this.evaluate(lambda);
+        // #1020: allowDeployWhenUnstable never covers missing evidence.
+        if ((lambda.unmeasured?.length ?? 0) > 0)
+            return false;
         return decision.decision === 'allow' ||
             (decision.decision === 'reduceScope' && this.config.policy.allowDeployWhenUnstable);
     }
@@ -144,16 +152,16 @@ export class CoherenceGateController {
      * Check critical dimensions for failures
      */
     checkCriticalDimensions(dimensions) {
-        // Security is critical
-        if (dimensions.security < 0.5) {
+        // Security is critical (an absent dimension is unmeasured, see #1020)
+        if (dimensions.security !== undefined && dimensions.security < 0.5) {
             return 'securityCritical';
         }
         // Test pass rate is critical
-        if (dimensions.passRate < 0.8) {
+        if (dimensions.passRate !== undefined && dimensions.passRate < 0.8) {
             return 'testFailureSpike';
         }
         // Coverage drop is concerning (if previously high)
-        if (dimensions.coverage < 0.5) {
+        if (dimensions.coverage !== undefined && dimensions.coverage < 0.5) {
             return 'coverageDrop';
         }
         return null;
@@ -328,6 +336,9 @@ export class CoherenceGateController {
             const additionalStr = additionalReasons.map(r => this.reasonToString(r)).join(', ');
             parts.push(`Additional concerns: ${additionalStr}.`);
         }
+        if (lambda.unmeasured && lambda.unmeasured.length > 0) {
+            parts.push(`Not measured: ${lambda.unmeasured.join(', ')}.`);
+        }
         // Dimension summary
         const summary = this.getDimensionSummary(lambda.dimensions);
         parts.push(`Quality dimensions: ${summary.healthy} healthy, ${summary.warning} warning, ${summary.critical} critical.`);
@@ -363,6 +374,7 @@ export class CoherenceGateController {
             'securityCritical': 'critical security vulnerability detected',
             'coverageDrop': 'significant test coverage decrease',
             'testFailureSpike': 'sudden increase in test failures',
+            'insufficientEvidence': 'one or more quality inputs were not measured',
         };
         return reasonStrings[reason] || reason;
     }