agentic-qe 3.15.14 → 3.15.16

package/dist/coordination/mincut/mincut-persistence.js

@@ -49,12 +49,14 @@ export class MinCutPersistence {
         this.ensureInitialized();
         const id = uuidv4();
         const db = this.memory.getDatabase();
-        db.prepare(`
+        // #1274: the queen's snapshot timer and agent events write here, so the
+        // writes queue instead of freezing the MCP server on a locked memory.db.
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_snapshots (
         id, timestamp, vertex_count, edge_count, total_weight,
         is_connected, component_count, vertices_json, edges_json
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, snapshot.timestamp.toISOString(), snapshot.stats.vertexCount, snapshot.stats.edgeCount, snapshot.stats.totalWeight, snapshot.stats.isConnected ? 1 : 0, snapshot.stats.componentCount, JSON.stringify(snapshot.vertices), JSON.stringify(snapshot.edges));
+    `).run(id, snapshot.timestamp.toISOString(), snapshot.stats.vertexCount, snapshot.stats.edgeCount, snapshot.stats.totalWeight, snapshot.stats.isConnected ? 1 : 0, snapshot.stats.componentCount, JSON.stringify(snapshot.vertices), JSON.stringify(snapshot.edges)));
         // Enforce retention to prevent unbounded snapshot growth (Issue #258)
         await this.enforceRetention();
         return id;
@@ -70,20 +72,20 @@ export class MinCutPersistence {
         if (!countRow || countRow.count <= maxSnapshots)
             return 0;
         const deleteCount = countRow.count - maxSnapshots;
-        db.prepare(`
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       DELETE FROM mincut_snapshots WHERE id IN (
         SELECT id FROM mincut_snapshots ORDER BY created_at ASC LIMIT ?
       )
-    `).run(deleteCount);
+    `).run(deleteCount));
         // Also trim history
         const historyCount = db.prepare('SELECT COUNT(*) as count FROM mincut_history').get();
         if (historyCount.count > 500) {
             const historyDelete = historyCount.count - 500;
-            db.prepare(`
+            await this.memory.writeWhenUnlocked(() => db.prepare(`
         DELETE FROM mincut_history WHERE id IN (
           SELECT id FROM mincut_history ORDER BY created_at ASC LIMIT ?
         )
-      `).run(historyDelete);
+      `).run(historyDelete));
         }
         return deleteCount;
     }
@@ -121,11 +123,11 @@ export class MinCutPersistence {
     async recordHistory(entry) {
         this.ensureInitialized();
         const db = this.memory.getDatabase();
-        const result = db.prepare(`
+        const result = await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_history (
         mincut_value, vertex_count, edge_count, algorithm, duration_ms, snapshot_id
       ) VALUES (?, ?, ?, ?, ?, ?)
-    `).run(entry.minCutValue, entry.vertexCount, entry.edgeCount, entry.algorithm ?? 'weighted-degree', entry.durationMs ?? null, entry.snapshotId ?? null);
+    `).run(entry.minCutValue, entry.vertexCount, entry.edgeCount, entry.algorithm ?? 'weighted-degree', entry.durationMs ?? null, entry.snapshotId ?? null));
         return Number(result.lastInsertRowid);
     }
     /**
@@ -225,13 +227,15 @@ export class MinCutPersistence {
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         const insertMany = db.transaction((vertices) => {
+            ids.length = 0; // a retried attempt starts over (#1283)
             for (const weak of vertices) {
                 const id = uuidv4();
                 insert.run(id, weak.vertexId, weak.weightedDegree, weak.riskScore, weak.reason, weak.vertex.domain ?? null, weak.vertex.type, JSON.stringify(weak.suggestions), snapshotId ?? null);
                 ids.push(id);
             }
         });
-        insertMany(weakVertices);
+        // #1283: queued, so a locked memory.db does not freeze the MCP server.
+        await this.memory.writeWhenUnlocked(() => insertMany(weakVertices));
         return ids;
     }
     /**
@@ -260,11 +264,11 @@ export class MinCutPersistence {
     async resolveWeakVertex(id) {
         this.ensureInitialized();
         const db = this.memory.getDatabase();
-        const result = db.prepare(`
+        const result = await this.memory.writeWhenUnlocked(() => db.prepare(`
       UPDATE mincut_weak_vertices
       SET resolved_at = datetime('now')
       WHERE id = ? AND resolved_at IS NULL
-    `).run(id);
+    `).run(id));
         return result.changes > 0;
     }
     // ==========================================================================
@@ -276,12 +280,12 @@ export class MinCutPersistence {
     async saveAlert(alert) {
         this.ensureInitialized();
         const db = this.memory.getDatabase();
-        db.prepare(`
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_alerts (
         id, severity, message, mincut_value, threshold,
         affected_vertices_json, remediations_json, acknowledged, timestamp
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(alert.id, alert.severity, alert.message, alert.minCutValue, alert.threshold, JSON.stringify(alert.affectedVertices), JSON.stringify(alert.remediations), alert.acknowledged ? 1 : 0, alert.timestamp.toISOString());
+    `).run(alert.id, alert.severity, alert.message, alert.minCutValue, alert.threshold, JSON.stringify(alert.affectedVertices), JSON.stringify(alert.remediations), alert.acknowledged ? 1 : 0, alert.timestamp.toISOString()));
         return alert.id;
     }
     /**
@@ -303,13 +307,13 @@ export class MinCutPersistence {
     async acknowledgeAlert(id, acknowledgedBy) {
         this.ensureInitialized();
         const db = this.memory.getDatabase();
-        const result = db.prepare(`
+        const result = await this.memory.writeWhenUnlocked(() => db.prepare(`
       UPDATE mincut_alerts
       SET acknowledged = 1,
           acknowledged_at = datetime('now'),
           acknowledged_by = ?
       WHERE id = ? AND acknowledged = 0
-    `).run(acknowledgedBy ?? null, id);
+    `).run(acknowledgedBy ?? null, id));
         return result.changes > 0;
     }
     /**
@@ -335,14 +339,14 @@ export class MinCutPersistence {
         this.ensureInitialized();
         const id = uuidv4();
         const db = this.memory.getDatabase();
-        db.prepare(`
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_healing_actions (
         id, action_type, action_params_json, success,
         mincut_before, mincut_after, improvement,
         error_message, duration_ms, triggered_by,
         snapshot_before_id, snapshot_after_id
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, result.action.type, JSON.stringify(result.action), result.success ? 1 : 0, result.minCutBefore, result.minCutAfter, result.improvement, result.error ?? null, result.durationMs, result.triggeredBy ?? null, result.snapshotBeforeId ?? null, result.snapshotAfterId ?? null);
+    `).run(id, result.action.type, JSON.stringify(result.action), result.success ? 1 : 0, result.minCutBefore, result.minCutAfter, result.improvement, result.error ?? null, result.durationMs, result.triggeredBy ?? null, result.snapshotBeforeId ?? null, result.snapshotAfterId ?? null));
         return id;
     }
     /**
@@ -408,13 +412,13 @@ export class MinCutPersistence {
         if (observation.prediction) {
             actualVsPredictedDiff = observation.minCutValue - observation.prediction.predictedMinCut;
         }
-        db.prepare(`
+        await this.memory.writeWhenUnlocked(() => db.prepare(`
       INSERT INTO mincut_observations (
         id, iteration, mincut_value, weak_vertex_count,
         weak_vertices_json, snapshot_id, prediction_json,
         actual_vs_predicted_diff
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(id, observation.iteration, observation.minCutValue, observation.weakVertices.length, JSON.stringify(observation.weakVertices.map(v => v.vertexId)), observation.snapshotId ?? null, observation.prediction ? JSON.stringify(observation.prediction) : null, actualVsPredictedDiff);
+    `).run(id, observation.iteration, observation.minCutValue, observation.weakVertices.length, JSON.stringify(observation.weakVertices.map(v => v.vertexId)), observation.snapshotId ?? null, observation.prediction ? JSON.stringify(observation.prediction) : null, actualVsPredictedDiff));
         return id;
     }
     /**
@@ -474,18 +478,18 @@ export class MinCutPersistence {
         const historyMaxAge = options.historyMaxAge ?? 7 * 24 * 60 * 60 * 1000; // 7 days
         const snapshotMaxAge = options.snapshotMaxAge ?? 24 * 60 * 60 * 1000; // 1 day
         const alertMaxAge = options.alertMaxAge ?? 30 * 24 * 60 * 60 * 1000; // 30 days
-        const historyResult = db.prepare(`
+        const historyResult = await this.memory.writeWhenUnlocked(() => db.prepare(`
       DELETE FROM mincut_history
       WHERE timestamp < ?
-    `).run(new Date(now - historyMaxAge).toISOString());
-        const snapshotResult = db.prepare(`
+    `).run(new Date(now - historyMaxAge).toISOString()));
+        const snapshotResult = await this.memory.writeWhenUnlocked(() => db.prepare(`
       DELETE FROM mincut_snapshots
       WHERE timestamp < ?
-    `).run(new Date(now - snapshotMaxAge).toISOString());
-        const alertResult = db.prepare(`
+    `).run(new Date(now - snapshotMaxAge).toISOString()));
+        const alertResult = await this.memory.writeWhenUnlocked(() => db.prepare(`
       DELETE FROM mincut_alerts
       WHERE timestamp < ? AND acknowledged = 1
-    `).run(new Date(now - alertMaxAge).toISOString());
+    `).run(new Date(now - alertMaxAge).toISOString()));
         return {
             historyDeleted: historyResult.changes,
             snapshotsDeleted: snapshotResult.changes,

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

@@ -217,6 +217,10 @@ export declare class CodeIntelligenceCoordinator extends BaseDomainCoordinator<C
     protected subscribeToEvents(): void;
     private handleTestRunCompleted;
     private handleFilesChanged;
+    /**
+     * #1230: makes every given file searchable, one file at a time (only one
+     * file's content is held at once), with no per-run file cap.
+     */
     indexForSearch(paths: string[]): Promise<SearchIndexSummary>;
     private loadWorkflowState;
     private saveWorkflowState;

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

@@ -59,8 +59,13 @@ const DEFAULT_CONFIG = {
  * CQ-002: Extends BaseDomainCoordinator
  */
 const logger = LoggerFactory.create('code-intelligence');
-/** Files made searchable per index run (content, plus vectors with an embedding model). */
-const SEARCH_INDEX_FILE_LIMIT = 100;
+/**
+ * #1230: after this many files in a row fail to embed, an index run stops
+ * asking the embedding model and stores the remaining files as text only.
+ * Each failed embed costs the client's retries and backoff (about 3s), which
+ * would otherwise dominate a large run while the model is down.
+ */
+const MAX_CONSECUTIVE_EMBED_FAILURES = 3;
 export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
@@ -761,19 +766,39 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
     // ============================================================================
     // Helper Methods
     // ============================================================================
+    /**
+     * #1230: makes every given file searchable, one file at a time (only one
+     * file's content is held at once), with no per-run file cap.
+     */
     async indexForSearch(paths) {
-        // Index a subset of files for search
-        // Limit to 100 files for performance in a single batch
-        const filesToIndex = paths.slice(0, SEARCH_INDEX_FILE_LIMIT);
         let searchable = 0;
-        for (const path of filesToIndex) {
+        let withVector = 0;
+        let embedFailures = 0;
+        let consecutiveEmbedFailures = 0;
+        let lastEmbedFailure;
+        let notEmbedded = 0;
+        for (const path of paths) {
             try {
                 // Read actual file content
                 const result = await this.fileReader.readFile(path);
-                if (result.success && result.value) {
-                    const indexed = await this.semanticAnalyzer.indexCode(path, result.value);
-                    if (indexed.success)
-                        searchable++;
+                if (!result.success || !result.value)
+                    continue;
+                const embed = consecutiveEmbedFailures < MAX_CONSECUTIVE_EMBED_FAILURES;
+                const indexed = await this.semanticAnalyzer.indexCode(path, result.value, { embed });
+                if (!indexed.success)
+                    continue;
+                searchable++;
+                if (indexed.value.vector) {
+                    withVector++;
+                    consecutiveEmbedFailures = 0;
+                }
+                else if (indexed.value.vectorFailure !== undefined) {
+                    embedFailures++;
+                    consecutiveEmbedFailures++;
+                    lastEmbedFailure = indexed.value.vectorFailure;
+                }
+                else if (!embed) {
+                    notEmbedded++;
                 }
             }
             catch {
@@ -783,9 +808,17 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
         // #1224: say when search will not see every indexed file.
         const warnings = [];
         if (searchable < paths.length) {
-            warnings.push(`Search covers ${searchable} of ${paths.length} indexed files` +
-                (paths.length > SEARCH_INDEX_FILE_LIMIT ? ` (at most ${SEARCH_INDEX_FILE_LIMIT} per index run)` : '') +
-                '; code in the other files is not found by search.');
+            warnings.push(`Search covers ${searchable} of ${paths.length} indexed files; ` +
+                'the other files could not be added to the search index, so code in them is not found by search.');
+        }
+        // #1231: say which files a semantic search can only match by text.
+        if (embedFailures > 0) {
+            warnings.push(`The embedding model failed for ${embedFailures} file(s) (${lastEmbedFailure})` +
+                (notEmbedded > 0
+                    ? `, so it was not asked for the remaining ${notEmbedded} file(s) of this run`
+                    : '') +
+                `. ${searchable - withVector} of ${searchable} searchable files have no vector; ` +
+                'semantic search matches them by text only. Re-index when the model is available.');
         }
         return { searchable, warnings };
     }

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

@@ -75,9 +75,18 @@ export interface SearchResults {
      * #1224, semantic searches only: 'vector' when an embedding model ranked the
      * results, 'lexical-only' when none was available and query words were
      * matched against the indexed text instead (`reason` says why).
+     * #1231: 'partial-vector' when only some indexed files have a vector; the
+     * others were matched by text (hits with `matchType: 'lexical'`) and
+     * `coverage` gives the counts.
      */
-    mode?: 'vector' | 'lexical-only';
+    mode?: 'vector' | 'partial-vector' | 'lexical-only';
     reason?: string;
+    /** #1231, semantic searches that ranked by vector: how many indexed files have a vector. */
+    coverage?: SearchVectorCoverage;
+}
+export interface SearchVectorCoverage {
+    indexedFiles: number;
+    filesWithVector: number;
 }
 export interface SearchResult {
     file: string;

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

@@ -11,6 +11,17 @@ import { SearchRequest, SearchResults, SearchResult } from '../interfaces';
  * reported after searching an index that holds code.
  */
 export declare const NOTHING_INDEXED_FOR_SEARCH: string;
+export interface IndexCodeOptions {
+    /** false: store the text only, without asking the embedding model (#1230: it kept failing this run). */
+    embed?: boolean;
+}
+/** What indexCode stored for a file. */
+export interface IndexedCode {
+    /** A vector from the current embedding model was stored. */
+    vector: boolean;
+    /** Set when an embedding model is configured but failed for this file. */
+    vectorFailure?: string;
+}
 /**
  * Interface for the semantic analyzer service
  */
@@ -18,7 +29,7 @@ export interface ISemanticAnalyzerService {
     /** Perform semantic search across codebase */
     search(request: SearchRequest): Promise<Result<SearchResults, Error>>;
     /** Index code for semantic search */
-    indexCode(file: string, content: string): Promise<Result<void, Error>>;
+    indexCode(file: string, content: string, options?: IndexCodeOptions): Promise<Result<IndexedCode, Error>>;
     /** Find semantically similar code */
     findSimilar(code: string, limit?: number): Promise<Result<SearchResult[], Error>>;
     /** Analyze code semantics */
@@ -113,7 +124,7 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     /**
      * Index code content for semantic search
      */
-    indexCode(file: string, content: string): Promise<Result<void, Error>>;
+    indexCode(file: string, content: string, options?: IndexCodeOptions): Promise<Result<IndexedCode, Error>>;
     /**
      * Find semantically similar code
      */
@@ -139,17 +150,30 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     private isCurrentModelVector;
     private vectorKeyPrefix;
     private contentKeyPattern;
+    /** Visits every indexed file's stored content, one at a time. */
+    private forEachIndexed;
     /**
      * #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.
+     * against the indexed text and reports `mode: 'lexical-only'` with the
+     * reason; no similarity is invented for those hits.
      */
     private semanticSearch;
+    /**
+     * #1231: files indexed while the embedding model was unavailable have no
+     * vector, so vector search cannot rank them. Match those by text, label the
+     * hits 'lexical', and report the result as 'partial-vector' with the counts.
+     * Cosine and text-match scores are not comparable, so vector hits come
+     * first (by cosine), then lexical hits (by share of query words found); the
+     * reason says how many text matches the limit left out.
+     */
+    private withVectorlessFiles;
     /** Word-overlap matching for a semantic query when no vectors can be used. */
     private lexicalSearch;
     private exactSearch;
     private fuzzySearch;
+    /** Token-overlap match of one indexed file, or null when it is filtered out or scores too low. */
+    private fuzzyMatch;
     private extractConcepts;
     private detectPatterns;
     private calculateComplexity;
@@ -160,9 +184,10 @@ export declare class SemanticAnalyzerService implements ISemanticAnalyzerService
     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".
+     * A query word is found when a content word contains it (or equals it):
+     * "login" is found in `loginWithPassword`. #1279: not the reverse; a query
+     * word such as `stepHandler450` is not found just because the file has the
+     * shorter word `step`, which made almost every file a full match.
      */
     private tokensMatch;
     private matchesFilters;

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

@@ -94,12 +94,12 @@ export class SemanticAnalyzerService {
                 return err(new Error(NOTHING_INDEXED_FOR_SEARCH));
             }
             let results;
-            let lexicalOnlyReason;
+            let semanticOutcome = {};
             switch (type) {
                 case 'semantic': {
-                    const semantic = await this.semanticSearch(query, limit, scope, filters);
-                    results = semantic.results;
-                    lexicalOnlyReason = semantic.lexicalOnlyReason;
+                    const { results: hits, ...outcome } = await this.semanticSearch(query, limit, scope, filters);
+                    results = hits;
+                    semanticOutcome = outcome;
                     break;
                 }
                 case 'exact':
@@ -116,11 +116,7 @@ export class SemanticAnalyzerService {
                 results,
                 total: results.length,
                 searchTime,
-                ...(type === 'semantic'
-                    ? lexicalOnlyReason === undefined
-                        ? { mode: 'vector' }
-                        : { mode: 'lexical-only', reason: lexicalOnlyReason }
-                    : {}),
+                ...semanticOutcome,
             });
         }
         catch (error) {
@@ -130,13 +126,13 @@ export class SemanticAnalyzerService {
     /**
      * Index code content for semantic search
      */
-    async indexCode(file, content) {
+    async indexCode(file, content, options = {}) {
         try {
             // Extract code metadata
             const metadata = this.extractCodeMetadata(file, content);
             // #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);
+            const embedded = options.embed === false ? {} : await this.tryEmbed(content);
             if (embedded.vector) {
                 const key = `${this.vectorKeyPrefix()}${this.fileToKey(file)}`;
                 await this.memory.storeVector(key, embedded.vector, {
@@ -153,8 +149,15 @@ export class SemanticAnalyzerService {
             // namespace, and a write with {namespace} could not be read back without
             // the same option (issue #491 Bug 2) — which silently dropped every
             // search result (#511 follow-up).
-            await this.memory.set(`${this.config.namespace}:content:${this.fileToKey(file)}`, { file, content, metadata });
-            return ok(undefined);
+            const stored = embedded.vector
+                ? { file, content, metadata, embeddingModel: this.embeddingModelId() }
+                : { file, content, metadata };
+            await this.memory.set(`${this.config.namespace}:content:${this.fileToKey(file)}`, stored);
+            return ok(embedded.vector
+                ? { vector: true }
+                : this.embedder && embedded.reason
+                    ? { vector: false, vectorFailure: embedded.reason }
+                    : { vector: false });
         }
         catch (error) {
             return err(toError(error));
@@ -284,21 +287,31 @@ export class SemanticAnalyzerService {
     contentKeyPattern() {
         return `${this.config.namespace}:content:*`;
     }
+    /** Visits every indexed file's stored content, one at a time. */
+    async forEachIndexed(visit) {
+        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)
+                visit(stored);
+        }
+    }
     // ============================================================================
     // 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.
+     * against the indexed text and reports `mode: 'lexical-only'` with the
+     * reason; no similarity is invented for those hits.
      */
     async semanticSearch(query, limit, scope, filters) {
         const embedded = await this.tryEmbed(query);
         if (!embedded.vector) {
             return {
                 results: await this.lexicalSearch(query, limit, scope, filters),
-                lexicalOnlyReason: embedded.reason,
+                mode: 'lexical-only',
+                reason: embedded.reason,
             };
         }
         // Only this namespace's vectors, from the model that embedded the query.
@@ -310,7 +323,8 @@ export class SemanticAnalyzerService {
         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`,
+                mode: 'lexical-only',
+                reason: `no indexed file has an embedding from ${this.embeddingModelId()}; re-index to enable vector search`,
             };
         }
         // Convert to search results with filtering
@@ -345,7 +359,53 @@ export class SemanticAnalyzerService {
                     break;
             }
         }
-        return { results };
+        return this.withVectorlessFiles(query, results, limit, scope, filters);
+    }
+    /**
+     * #1231: files indexed while the embedding model was unavailable have no
+     * vector, so vector search cannot rank them. Match those by text, label the
+     * hits 'lexical', and report the result as 'partial-vector' with the counts.
+     * Cosine and text-match scores are not comparable, so vector hits come
+     * first (by cosine), then lexical hits (by share of query words found); the
+     * reason says how many text matches the limit left out.
+     */
+    async withVectorlessFiles(query, vectorHits, limit, scope, filters) {
+        const model = this.embeddingModelId();
+        const vectorFiles = new Set(vectorHits.map((hit) => hit.file));
+        const queryTokens = this.tokenize(query.toLowerCase());
+        const lexicalHits = [];
+        let indexedFiles = 0;
+        let withoutVector = 0;
+        await this.forEachIndexed((stored) => {
+            indexedFiles++;
+            if (stored.embeddingModel === model)
+                return;
+            withoutVector++;
+            if (vectorFiles.has(stored.file))
+                return;
+            const hit = this.fuzzyMatch(queryTokens, stored, scope, filters);
+            if (hit)
+                lexicalHits.push({ ...hit, matchType: 'lexical' });
+        });
+        const coverage = { indexedFiles, filesWithVector: indexedFiles - withoutVector };
+        if (withoutVector === 0) {
+            return { results: vectorHits, mode: 'vector', coverage };
+        }
+        const byScore = (a, b) => b.score - a.score;
+        const results = [...[...vectorHits].sort(byScore), ...lexicalHits.sort(byScore)].slice(0, limit);
+        const droppedLexical = vectorHits.length + lexicalHits.length - results.length;
+        return {
+            results,
+            mode: 'partial-vector',
+            reason: `${withoutVector} of ${indexedFiles} indexed files have no embedding from ${model} ` +
+                '(it was unavailable when they were indexed, or an older aqe version indexed them), ' +
+                'so they were matched by text only (matchType "lexical", listed after the vector hits); ' +
+                (droppedLexical > 0
+                    ? `${droppedLexical} more text match(es) were left out by the limit of ${limit}; `
+                    : '') +
+                're-index to rank them by vector',
+            coverage,
+        };
     }
     /** Word-overlap matching for a semantic query when no vectors can be used. */
     async lexicalSearch(query, limit, scope, filters) {
@@ -390,39 +450,38 @@ export class SemanticAnalyzerService {
     }
     async fuzzySearch(query, limit, scope, filters) {
         const results = [];
-        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);
-            if (!stored)
-                continue;
-            // Apply scope filter
-            if (scope && scope.length > 0) {
-                const matchesScope = scope.some((s) => stored.file.includes(s));
-                if (!matchesScope)
-                    continue;
-            }
-            // Apply filters
-            if (filters && !this.matchesFilters(stored.metadata, filters)) {
-                continue;
-            }
-            // Fuzzy match using token overlap
-            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) => this.tokensMatch(t, ct)));
-                results.push({
-                    file: stored.file,
-                    snippet: this.extractSnippet(stored.content, 200),
-                    score,
-                    highlights: matchedTokens,
-                    metadata: stored.metadata,
-                });
-            }
-        }
+        await this.forEachIndexed((stored) => {
+            const hit = this.fuzzyMatch(queryTokens, stored, scope, filters);
+            if (hit)
+                results.push(hit);
+        });
         // Sort by score and limit
         return results.sort((a, b) => b.score - a.score).slice(0, limit);
     }
+    /** Token-overlap match of one indexed file, or null when it is filtered out or scores too low. */
+    fuzzyMatch(queryTokens, stored, scope, filters) {
+        // Apply scope filter
+        if (scope && scope.length > 0 && !scope.some((s) => stored.file.includes(s))) {
+            return null;
+        }
+        // Apply filters
+        if (filters && !this.matchesFilters(stored.metadata, filters)) {
+            return null;
+        }
+        // Fuzzy match using token overlap
+        const contentTokens = this.tokenize(stored.content.toLowerCase());
+        const score = this.calculateFuzzyScore(queryTokens, contentTokens);
+        if (score < this.config.minScore)
+            return null;
+        return {
+            file: stored.file,
+            snippet: this.extractSnippet(stored.content, 200),
+            score,
+            highlights: queryTokens.filter((t) => contentTokens.some((ct) => this.tokensMatch(t, ct))),
+            metadata: stored.metadata,
+        };
+    }
     // ============================================================================
     // Private Analysis Methods
     // ============================================================================
@@ -625,13 +684,13 @@ export class SemanticAnalyzerService {
         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".
+     * A query word is found when a content word contains it (or equals it):
+     * "login" is found in `loginWithPassword`. #1279: not the reverse; a query
+     * word such as `stepHandler450` is not found just because the file has the
+     * shorter word `step`, which made almost every file a full match.
      */
     tokensMatch(queryToken, contentToken) {
-        return contentToken.includes(queryToken) ||
-            (contentToken.length >= 3 && queryToken.includes(contentToken));
+        return contentToken.includes(queryToken);
     }
     matchesFilters(metadata, filters) {
         for (const filter of filters) {
@@ -683,7 +742,7 @@ export class SemanticAnalyzerService {
         const queryTokens = this.tokenize(query.toLowerCase());
         const contentTokens = this.tokenize(content.toLowerCase());
         for (const qt of queryTokens) {
-            const match = contentTokens.find((ct) => ct.includes(qt) || qt.includes(ct));
+            const match = contentTokens.find((ct) => this.tokensMatch(qt, ct));
             if (match && !highlights.includes(match)) {
                 highlights.push(match);
             }

package/dist/domains/learning-optimization/services/learning-coordinator.js

@@ -512,7 +512,7 @@ Provide:
         const contextFingerprint = `${experience.domain}:${experience.action}`;
         for (const patternId of experience.appliedPatternIds ?? []) {
             try {
-                nullStore.recordNull({
+                await nullStore.recordNullWhenUnlocked({
                     patternId,
                     contextFingerprint,
                     failureMode: String(experience.result.outcome?.error ?? experience.action),

package/dist/domains/quality-assessment/coordinator.js

@@ -284,7 +284,8 @@ export class QualityAssessmentCoordinator extends BaseDomainCoordinator {
             // ADR-070: Record quality gate decision in witness chain
             try {
                 const wc = await getWitnessChain();
-                wc.append(finalResult.passed ? 'QUALITY_GATE_PASS' : 'QUALITY_GATE_FAIL', { gateName: request.gateName, passed: finalResult.passed, score: finalResult.overallScore, failedChecks: finalResult.failedChecks }, 'quality-gate');
+                // #1283: queued, so a locked memory.db does not freeze the MCP server.
+                await wc.appendWhenUnlocked(finalResult.passed ? 'QUALITY_GATE_PASS' : 'QUALITY_GATE_FAIL', { gateName: request.gateName, passed: finalResult.passed, score: finalResult.overallScore, failedChecks: finalResult.failedChecks }, 'quality-gate');
             }
             catch (_wcErr) { /* non-critical */ }
             // ADR-062: Monotonic gate threshold ratcheting