agentic-qe 3.15.11 → 3.15.13

package/dist/domains/code-intelligence/services/semantic-analyzer.d.ts

@@ -6,6 +6,11 @@ import { Result } from '../../../shared/types';
 import { MemoryBackend } from '../../../kernel/interfaces';
 import { NomicEmbedderConfig, IEmbeddingProvider } from '../../../shared/embeddings';
 import { SearchRequest, SearchResults, SearchResult } from '../interfaces';
+/**
+ * #1224: the message for a search over an empty index. "No results" is only
+ * reported after searching an index that holds code.
+ */
+export declare const NOTHING_INDEXED_FOR_SEARCH: string;
 /**
  * Interface for the semantic analyzer service
  */
@@ -18,7 +23,10 @@ export interface ISemanticAnalyzerService {
     findSimilar(code: string, limit?: number): Promise<Result<SearchResult[], Error>>;
     /** Analyze code semantics */
     analyze(code: string): Promise<Result<SemanticAnalysis, Error>>;
-    /** Get code embeddings */
+    /**
+     * Get code embeddings. Throws when no embedding model is available: no
+     * pseudo-embedding is substituted (ADR-097).
+     */
     getEmbedding(code: string): Promise<number[]>;
 }
 /**
@@ -56,8 +64,15 @@ export interface HalsteadMetrics {
 export interface SemanticAnalyzerConfig {
     /** Embedding vector dimension (384 for all-MiniLM-L6-v2) */
     embeddingDimension: number;
-    /** Minimum similarity score threshold */
+    /** Minimum word-overlap score for fuzzy and text-only matches */
     minScore: number;
+    /**
+     * #1224: minimum cosine similarity for vector hits. Sentence-embedding
+     * models score a relevant file well below 0.5 (all-MiniLM-L6-v2 gave 0.37
+     * for "login" against a login function), so the text threshold would hide
+     * every vector hit.
+     */
+    minVectorScore: number;
     /** Maximum search results */
     maxResults: number;
     /** Storage namespace */
@@ -84,6 +99,8 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     private readonly analysisCache;
     private embedder;
     private embedderInitialized;
+    /** #1224: why no embedder is in use, once initialization has run. */
+    private embedderUnavailableReason;
     constructor(memory: MemoryBackend, config?: Partial<SemanticAnalyzerConfig>);
     /**
      * Initialize the Nomic embedder lazily
@@ -106,15 +123,31 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
      */
     analyze(code: string): Promise<Result<SemanticAnalysis, Error>>;
     /**
-     * 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).
      */
     getEmbedding(code: string): Promise<number[]>;
     /**
      * Check if using real Nomic embeddings
      */
     isUsingNomicEmbeddings(): boolean;
+    /** #1224: embed `text`, or say why no real embedding is available. */
+    private tryEmbed;
+    /** Identifies the model behind stored vectors, so vectors from another model are not compared. */
+    private embeddingModelId;
+    private isCurrentModelVector;
+    private vectorKeyPrefix;
+    private contentKeyPattern;
+    /**
+     * #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.
+     */
     private semanticSearch;
+    /** Word-overlap matching for a semantic query when no vectors can be used. */
+    private lexicalSearch;
     private exactSearch;
     private fuzzySearch;
     private extractConcepts;
@@ -122,11 +155,16 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     private calculateComplexity;
     private extractDependencies;
     private generateSuggestions;
-    private generateCodeEmbedding;
     private extractCodeMetadata;
     private detectLanguage;
     private tokenize;
     private calculateFuzzyScore;
+    /**
+     * 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".
+     */
+    private tokensMatch;
     private matchesFilters;
     private extractSnippet;
     private extractSnippetAround;
@@ -134,6 +172,14 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     private findHighlights;
     private findSemanticHighlights;
     private fileToKey;
+    /**
+     * Content identity for the analysis and embedding caches.
+     *
+     * This keys cache entries, so it has to separate any two distinct inputs.
+     * A 31-multiplier 32-bit hash does not: for any shared prefix and suffix,
+     * "Aa" and "BB" collide, so two different functions would share one entry
+     * and the second caller would receive the first one's result.
+     */
     private hashCode;
     private cacheEmbedding;
     private cacheAnalysis;

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

@@ -2,12 +2,22 @@
  * Agentic QE v3 - Semantic Analyzer Service
  * Semantic code analysis using vector embeddings and HNSW search
  */
+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,
@@ -25,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 };
@@ -42,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();
@@ -54,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;
     }
@@ -64,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;
@@ -83,6 +116,11 @@ export class SemanticAnalyzerService {
                 results,
                 total: results.length,
                 searchTime,
+                ...(type === 'semantic'
+                    ? lexicalOnlyReason === undefined
+                        ? { mode: 'vector' }
+                        : { mode: 'lexical-only', reason: lexicalOnlyReason }
+                    : {}),
             });
         }
         catch (error) {
@@ -94,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/
@@ -125,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);
@@ -189,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
@@ -200,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);
@@ -221,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));
@@ -257,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)
@@ -302,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);
@@ -323,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),
@@ -499,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),
@@ -563,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];
@@ -635,14 +699,16 @@ export class SemanticAnalyzerService {
     fileToKey(file) {
         return file.replace(/[/\\]/g, ':').replace(/\./g, '_');
     }
+    /**
+     * Content identity for the analysis and embedding caches.
+     *
+     * This keys cache entries, so it has to separate any two distinct inputs.
+     * A 31-multiplier 32-bit hash does not: for any shared prefix and suffix,
+     * "Aa" and "BB" collide, so two different functions would share one entry
+     * and the second caller would receive the first one's result.
+     */
     hashCode(str) {
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
-            hash = (hash << 5) - hash + char;
-            hash = hash & hash;
-        }
-        return hash.toString(16);
+        return createHash('sha256').update(str, 'utf8').digest('hex');
     }
     cacheEmbedding(key, embedding) {
         if (this.embeddingCache.size >= this.config.cacheSize) {

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

@@ -14,6 +14,16 @@ 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;
+/**
+ * #1030: the per-file record key of each path in ONE report, keyed by the
+ * path as the report wrote it. A path is left out when its record would not
+ * be a measurement of a project file: it resolves outside the project root
+ * (lcov `SF:../../outside.ts`), it is a Windows absolute path read on POSIX
+ * (it would resolve to a junk key), or the report lists the same file under
+ * two spellings (`./src/a.ts` and `src/a.ts`), so which entry is right is
+ * unknown.
+ */
+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

@@ -17,6 +17,35 @@ import { findProjectRoot } from '../../kernel/project-root.js';
 export function fileCoverageKey(filePath, projectRoot) {
     return path.isAbsolute(filePath) ? path.normalize(filePath) : path.resolve(projectRoot ?? findProjectRoot(), filePath);
 }
+/**
+ * #1030: the per-file record key of each path in ONE report, keyed by the
+ * path as the report wrote it. A path is left out when its record would not
+ * be a measurement of a project file: it resolves outside the project root
+ * (lcov `SF:../../outside.ts`), it is a Windows absolute path read on POSIX
+ * (it would resolve to a junk key), or the report lists the same file under
+ * two spellings (`./src/a.ts` and `src/a.ts`), so which entry is right is
+ * unknown.
+ */
+export function projectFileCoverageKeys(paths, projectRoot) {
+    const root = path.resolve(projectRoot ?? findProjectRoot());
+    const keys = new Map();
+    const spellings = new Map();
+    for (const filePath of paths) {
+        if (!path.isAbsolute(filePath) && path.win32.isAbsolute(filePath))
+            continue;
+        const key = fileCoverageKey(filePath, root);
+        const relative = path.relative(root, key);
+        if (relative === '' || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))
+            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);
+    }
+    return 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,7 +522,7 @@ 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),
@@ -533,11 +537,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 } : {}),
     };
 }
 // ============================================================================