mcvay-mind 1.0.7 → 1.0.8

package/lib/metrics.js

@@ -37,6 +37,7 @@ const DEFAULT_STATE = {
     unified_graph_traversal: { count: 0, total: 0, min: null, max: null, avg: 0 },
     keyword: { count: 0, total: 0, min: null, max: null, avg: 0 },
     semantic: { count: 0, total: 0, min: null, max: null, avg: 0 },
+    fast_semantic: { count: 0, total: 0, min: null, max: null, avg: 0 },
     graph: { count: 0, total: 0, min: null, max: null, avg: 0 },
     format: { count: 0, total: 0, min: null, max: null, avg: 0 },
   },
@@ -101,6 +102,7 @@ function mergeState(rawState) {
       unified_graph_traversal: mergeLatency(latency.unified_graph_traversal),
       keyword: mergeLatency(latency.keyword),
       semantic: mergeLatency(latency.semantic),
+      fast_semantic: mergeLatency(latency.fast_semantic),
       graph: mergeLatency(latency.graph),
       format: mergeLatency(latency.format),
     },
@@ -162,7 +164,16 @@ function recordSearch({
     } else {
       state.search.card_mode += 1;
     }
-    const modeKey = `${mode || 'hybrid'}`.trim().toLowerCase() || 'hybrid';
+    let modeKey = `${mode || 'hybrid'}`.trim().toLowerCase() || 'hybrid';
+    if (
+      modeKey === 'fast:keyword'
+      && latencyBreakdown
+      && latencyBreakdown.fastSemanticMs !== null
+      && latencyBreakdown.fastSemanticMs !== undefined
+      && Number.isFinite(latencyBreakdown.fastSemanticMs)
+    ) {
+      modeKey = 'fast:hybrid';
+    }
     state.search.by_engine_mode[modeKey] = toNumber(state.search.by_engine_mode[modeKey], 0) + 1;
     updateLatency(state.latency_ms.search, durationMs);
     if (latencyBreakdown && typeof latencyBreakdown === 'object') {
@@ -172,6 +183,9 @@ function recordSearch({
       if (Number.isFinite(latencyBreakdown.semanticMs)) {
         updateLatency(state.latency_ms.semantic, latencyBreakdown.semanticMs);
       }
+      if (Number.isFinite(latencyBreakdown.fastSemanticMs)) {
+        updateLatency(state.latency_ms.fast_semantic, latencyBreakdown.fastSemanticMs);
+      }
       if (Number.isFinite(latencyBreakdown.graphMs)) {
         updateLatency(state.latency_ms.graph, latencyBreakdown.graphMs);
       }

package/lib/search.js

@@ -39,6 +39,9 @@ const TYPE_PRIORITY = {
 const SEARCH_CACHE_MAX_ENTRIES = 200;
 const SEARCH_CACHE_TTL_MS = 60 * 1000;
 const EXPAND_INTENT_TERMS = new Set(['why', 'how', 'details', 'detail', 'context', 'full', 'explain', 'history']);
+const FAST_SEMANTIC_MAX_TOP_N = 10;
+const FAST_LATENCY_BUDGET_MS = 500;
+const FAST_SEMANTIC_LATENCY_GUARD_MS = 400;
 const queryCache = new Map();
 
 function normalizeQuery(query = '') {
@@ -141,6 +144,14 @@ function shouldRunSemanticForBalanced(keywordResults = [], options = {}) {
   return topNorm < 0.62 || sparse;
 }
 
+function shouldRunSemanticForFast(keywordResults = []) {
+  if (!keywordResults.length) return true;
+  const top = keywordResults[0];
+  const topNorm = normalizeKeywordScore(top && top.score);
+  const sparse = keywordResults.length < 3;
+  return topNorm < 0.5 || sparse;
+}
+
 // ============================================================================
 // Keyword Extraction
 // ============================================================================
@@ -203,6 +214,14 @@ function computeHybridScore(memory, options, keywords, query, cwd, linkCounts =
   return (keywordNorm * keywordWeight) + (semanticNorm * semanticWeight) + (metadataNorm * 0.1);
 }
 
+function computeSimpleFusionScore(memory, options = {}) {
+  const keywordWeight = Number.isFinite(options.keywordWeight) ? options.keywordWeight : 0.5;
+  const semanticWeight = Number.isFinite(options.semanticWeight) ? options.semanticWeight : 0.5;
+  const keywordNorm = normalizeKeywordScore(memory.keywordScore || memory.score || 0);
+  const semanticNorm = normalizeSemanticScore(memory.semanticScore || 0);
+  return (keywordWeight * keywordNorm) + (semanticWeight * semanticNorm);
+}
+
 function normalizeBm25ForDisplay(score) {
   if (!Number.isFinite(score)) return 0;
   return 1 / (1 + Math.max(0, score));
@@ -417,6 +436,7 @@ function fuseResults(keywordResults, semanticResults, options, cwd = process.cwd
   const keywords = extractKeywords(query);
   const mode = options.mode || 'hybrid';
   const limit = options.limit || 10;
+  const simpleFusion = !!options.simpleFusion;
 
   if (mode === 'keyword') {
     return keywordResults.slice(0, limit);
@@ -460,7 +480,9 @@ function fuseResults(keywordResults, semanticResults, options, cwd = process.cwd
   }
 
   const fused = Array.from(bySlug.values()).map(m => {
-    const hybrid = computeHybridScore(m, options, keywords, query, cwd, linkCounts);
+    const hybrid = simpleFusion
+      ? computeSimpleFusionScore(m, options)
+      : computeHybridScore(m, options, keywords, query, cwd, linkCounts);
     return {
       ...m,
       score: Math.round(hybrid * 150),
@@ -578,12 +600,14 @@ async function searchMemories(options, cwd = process.cwd()) {
   const phaseMs = {
     keywordMs: 0,
     semanticMs: 0,
+    fastSemanticMs: null,
     graphMs: 0,
     formatMs: 0,
   };
   let cacheHit = false;
   let cacheMiss = false;
   let errored = false;
+  let fastSemanticTriggered = false;
   const cacheKey = buildSearchCacheKey({
     ...options,
     query,
@@ -615,7 +639,37 @@ async function searchMemories(options, cwd = process.cwd()) {
     phaseMs.keywordMs = Date.now() - keywordStart;
 
     if (preset === 'fast' || !query || mode === 'keyword') {
-      ranked = keywordResults;
+      const fastGateOpen = preset === 'fast'
+        && query
+        && shouldRunSemanticForFast(keywordResults)
+        && phaseMs.keywordMs < FAST_SEMANTIC_LATENCY_GUARD_MS
+        && (Date.now() - startMs) < FAST_LATENCY_BUDGET_MS;
+      if (fastGateOpen) {
+        fastSemanticTriggered = true;
+        const semanticStart = Date.now();
+        const fastRun = await runSemanticSearch({
+          ...options,
+          limit: Math.min(
+            FAST_SEMANTIC_MAX_TOP_N,
+            Number.isFinite(options.annTopN) ? options.annTopN : FAST_SEMANTIC_MAX_TOP_N,
+          ),
+          semanticBackend: 'ann',
+        }, cwd);
+        phaseMs.fastSemanticMs = Date.now() - semanticStart;
+        phaseMs.semanticMs += phaseMs.fastSemanticMs;
+        const canFuse = fastRun.available && fastRun.results.length > 0;
+        ranked = canFuse
+          ? fuseResults(
+            keywordResults,
+            fastRun.results,
+            { ...options, simpleFusion: true, mode: 'hybrid' },
+            cwd,
+            linkCounts,
+          )
+          : keywordResults;
+      } else {
+        ranked = keywordResults;
+      }
     } else if (preset === 'balanced') {
       const shouldSemantic = shouldRunSemanticForBalanced(keywordResults, options);
       if (shouldSemantic) {
@@ -686,7 +740,7 @@ async function searchMemories(options, cwd = process.cwd()) {
 
     metrics.recordSearch({
       resultMode: resultModeForMetrics,
-      mode: `${preset}:${mode}`,
+      mode: (preset === 'fast' && fastSemanticTriggered) ? 'fast:hybrid' : `${preset}:${mode}`,
       durationMs: Date.now() - startMs,
       errored,
       latencyBreakdown: phaseMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcvay-mind",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Typed memory system with search, recall, and response guidance for agent workflows.",
   "main": "index.js",
   "bin": {