bluera-knowledge 0.9.38 → 0.9.39

package/dist/mcp/server.js

@@ -1,8 +1,8 @@
 import {
   createMCPServer,
   runMCPServer
-} from "../chunk-36IFANFI.js";
-import "../chunk-XJFV7AJW.js";
+} from "../chunk-TIGPI3BE.js";
+import "../chunk-HUEWT6U5.js";
 import "../chunk-6FHWC36B.js";
 export {
   createMCPServer,

package/dist/workers/background-worker-cli.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   IntelligentCrawler
-} from "../chunk-ZAWIPEYX.js";
+} from "../chunk-IZWOEBFM.js";
 import {
   JobService,
   createDocumentId,
   createServices,
   createStoreId
-} from "../chunk-XJFV7AJW.js";
+} from "../chunk-HUEWT6U5.js";
 import "../chunk-6FHWC36B.js";
 
 // src/workers/background-worker.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bluera-knowledge",
-  "version": "0.9.38",
+  "version": "0.9.39",
   "description": "CLI tool for managing knowledge stores with semantic search",
   "type": "module",
   "bin": {

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "bluera-knowledge",
-  "version": "0.9.38",
+  "version": "0.9.39",
   "description": "Clone repos, crawl docs, search locally. Fast, authoritative answers for AI coding agents.",
   "commands": "./commands",
   "hooks": "./hooks/hooks.json",

package/src/cli/commands/search.ts

@@ -18,6 +18,10 @@ export function createSearchCommand(getOptions: () => GlobalOptions): Command {
     )
     .option('-n, --limit <count>', 'Maximum results to return (default: 10)', '10')
     .option('-t, --threshold <score>', 'Minimum score 0-1; omit low-relevance results')
+    .option(
+      '--min-relevance <score>',
+      'Minimum raw cosine similarity 0-1; returns empty if no results meet threshold'
+    )
     .option('--include-content', 'Show full document content, not just preview snippet')
     .option(
       '--detail <level>',
@@ -32,6 +36,7 @@ export function createSearchCommand(getOptions: () => GlobalOptions): Command {
           mode?: SearchMode;
           limit?: string;
           threshold?: string;
+          minRelevance?: string;
           includeContent?: boolean;
           detail?: DetailLevel;
         }
@@ -82,6 +87,8 @@ export function createSearchCommand(getOptions: () => GlobalOptions): Command {
               limit: parseInt(options.limit ?? '10', 10),
               threshold:
                 options.threshold !== undefined ? parseFloat(options.threshold) : undefined,
+              minRelevance:
+                options.minRelevance !== undefined ? parseFloat(options.minRelevance) : undefined,
               includeContent: options.includeContent,
               detail: options.detail ?? 'minimal',
             });
@@ -96,12 +103,23 @@ export function createSearchCommand(getOptions: () => GlobalOptions): Command {
               }
             } else {
               console.log(`\nSearch: "${query}"`);
-              console.log(
-                `Mode: ${results.mode} | Detail: ${String(options.detail)} | Stores: ${String(results.stores.length)} | Results: ${String(results.totalResults)} | Time: ${String(results.timeMs)}ms\n`
-              );
+
+              // Build status line with optional confidence info
+              let statusLine = `Mode: ${results.mode} | Detail: ${String(options.detail)} | Stores: ${String(results.stores.length)} | Results: ${String(results.totalResults)} | Time: ${String(results.timeMs)}ms`;
+              if (results.confidence !== undefined) {
+                statusLine += ` | Confidence: ${results.confidence}`;
+              }
+              if (results.maxRawScore !== undefined) {
+                statusLine += ` | MaxRaw: ${results.maxRawScore.toFixed(3)}`;
+              }
+              console.log(`${statusLine}\n`);
 
               if (results.results.length === 0) {
-                console.log('No results found.\n');
+                if (results.confidence === 'low') {
+                  console.log('No sufficiently relevant results found.\n');
+                } else {
+                  console.log('No results found.\n');
+                }
               } else {
                 for (let i = 0; i < results.results.length; i++) {
                   const r = results.results[i];

package/src/mcp/handlers/search.handler.ts

@@ -72,6 +72,7 @@ export const handleSearch: ToolHandler<SearchArgs> = async (
     mode: 'hybrid',
     limit: validated.limit,
     detail: validated.detail,
+    minRelevance: validated.minRelevance,
   };
 
   const results = await services.search.search(searchQuery);
@@ -107,6 +108,8 @@ export const handleSearch: ToolHandler<SearchArgs> = async (
       totalResults: results.totalResults,
       mode: results.mode,
       timeMs: results.timeMs,
+      confidence: results.confidence,
+      maxRawScore: results.maxRawScore,
     },
     null,
     2
@@ -115,8 +118,10 @@ export const handleSearch: ToolHandler<SearchArgs> = async (
   // Calculate actual token estimate based on response content
   const responseTokens = estimateTokens(responseJson);
 
-  // Create visible header with token usage
-  const header = `Search: "${validated.query}" | Results: ${String(results.totalResults)} | ${formatTokenCount(responseTokens)} tokens | ${String(results.timeMs)}ms\n\n`;
+  // Create visible header with token usage and confidence
+  const confidenceInfo =
+    results.confidence !== undefined ? ` | Confidence: ${results.confidence}` : '';
+  const header = `Search: "${validated.query}" | Results: ${String(results.totalResults)} | ${formatTokenCount(responseTokens)} tokens | ${String(results.timeMs)}ms${confidenceInfo}\n\n`;
 
   // Log the complete MCP response that will be sent to Claude Code
   logger.info(

package/src/mcp/schemas/index.ts

@@ -28,6 +28,11 @@ export const SearchArgsSchema = z.object({
   detail: z.enum(['minimal', 'contextual', 'full']).default('minimal'),
   limit: z.number().int().positive().default(10),
   stores: z.array(z.string()).optional(),
+  minRelevance: z
+    .number()
+    .min(0, 'minRelevance must be between 0 and 1')
+    .max(1, 'minRelevance must be between 0 and 1')
+    .optional(),
 });
 
 export type SearchArgs = z.infer<typeof SearchArgsSchema>;

package/src/mcp/server.ts

@@ -70,6 +70,11 @@ export function createMCPServer(options: MCPServerOptions): Server {
                 items: { type: 'string' },
                 description: 'Specific store IDs to search (optional)',
               },
+              minRelevance: {
+                type: 'number',
+                description:
+                  'Minimum raw cosine similarity (0-1). Returns empty if no results meet threshold. Use to filter irrelevant results.',
+              },
             },
             required: ['query'],
           },

package/src/services/search.service.test.ts

@@ -1161,6 +1161,7 @@ describe('SearchService - Edge Cases', () => {
   });
 
   it('handles threshold parameter for vector search', async () => {
+    // Setup: multiple results with varying scores
     vi.mocked(mockLanceStore.search).mockResolvedValue([
       {
         id: createDocumentId('doc1'),
@@ -1168,22 +1169,41 @@ describe('SearchService - Edge Cases', () => {
         content: 'high score',
         metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
       },
+      {
+        id: createDocumentId('doc2'),
+        score: 0.5,
+        content: 'medium score',
+        metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
+      },
+      {
+        id: createDocumentId('doc3'),
+        score: 0.3,
+        content: 'low score',
+        metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
+      },
     ]);
 
+    // Search with high threshold
     const results = await searchService.search({
       query: 'test',
       stores: [storeId],
       mode: 'vector',
       limit: 10,
-      threshold: 0.9,
+      threshold: 0.8,
     });
 
+    // Verify lanceStore.search was called (without checking threshold param - it's unused in LanceStore)
     expect(vi.mocked(mockLanceStore.search)).toHaveBeenCalledWith(
       storeId,
       expect.anything(),
-      expect.anything(),
-      0.9
+      expect.anything()
     );
+
+    // Verify threshold filtering works: only high-score result should pass
+    // After normalization, the top result has score 1.0, and threshold 0.8 filters out lower ones
+    // The normalized scores are: doc1=1.0, doc2=0.31, doc3=0.0 (relative to max 0.95)
+    expect(results.results.length).toBe(1);
+    expect(results.results[0]?.id).toBe('doc1');
   });
 });
 
@@ -1992,3 +2012,171 @@ describe('SearchService - Threshold Filtering', () => {
     expect(results.query).toBe('test query');
   });
 });
+
+describe('SearchService - Raw Score and Confidence', () => {
+  let mockLanceStore: LanceStore;
+  let mockEmbeddingEngine: EmbeddingEngine;
+  let searchService: SearchService;
+  const storeId = createStoreId('test-store');
+
+  beforeEach(() => {
+    mockLanceStore = {
+      search: vi.fn(),
+      fullTextSearch: vi.fn(),
+    } as unknown as LanceStore;
+
+    mockEmbeddingEngine = {
+      embed: vi.fn().mockResolvedValue([0.1, 0.2, 0.3]),
+    } as unknown as EmbeddingEngine;
+
+    searchService = new SearchService(mockLanceStore, mockEmbeddingEngine);
+  });
+
+  it('exposes rawVectorScore in rankingMetadata for hybrid search', async () => {
+    // Mock results with known raw vector scores
+    vi.mocked(mockLanceStore.search).mockResolvedValue([
+      {
+        id: createDocumentId('doc1'),
+        score: 0.85, // Raw cosine similarity
+        content: 'vector result',
+        metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
+      },
+      {
+        id: createDocumentId('doc2'),
+        score: 0.65,
+        content: 'another vector result',
+        metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
+      },
+    ]);
+    vi.mocked(mockLanceStore.fullTextSearch).mockResolvedValue([]);
+
+    const results = await searchService.search({
+      query: 'test query',
+      stores: [storeId],
+      mode: 'hybrid',
+      limit: 10,
+    });
+
+    // Verify results have rawVectorScore in rankingMetadata
+    expect(results.results.length).toBeGreaterThan(0);
+    const firstResult = results.results[0];
+    expect(firstResult?.rankingMetadata).toBeDefined();
+    expect(firstResult?.rankingMetadata?.rawVectorScore).toBeDefined();
+    expect(firstResult?.rankingMetadata?.rawVectorScore).toBe(0.85);
+  });
+
+  it('returns confidence level based on maxRawScore', async () => {
+    // Mock results with high raw vector score (>= 0.5)
+    vi.mocked(mockLanceStore.search).mockResolvedValue([
+      {
+        id: createDocumentId('doc1'),
+        score: 0.6, // High confidence threshold
+        content: 'high score result',
+        metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
+      },
+    ]);
+    vi.mocked(mockLanceStore.fullTextSearch).mockResolvedValue([]);
+
+    const results = await searchService.search({
+      query: 'test query',
+      stores: [storeId],
+      mode: 'hybrid',
+      limit: 10,
+    });
+
+    expect(results.confidence).toBe('high');
+    expect(results.maxRawScore).toBe(0.6);
+  });
+
+  it('returns medium confidence for scores between 0.3 and 0.5', async () => {
+    vi.mocked(mockLanceStore.search).mockResolvedValue([
+      {
+        id: createDocumentId('doc1'),
+        score: 0.4, // Medium confidence
+        content: 'medium score result',
+        metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
+      },
+    ]);
+    vi.mocked(mockLanceStore.fullTextSearch).mockResolvedValue([]);
+
+    const results = await searchService.search({
+      query: 'test query',
+      stores: [storeId],
+      mode: 'hybrid',
+      limit: 10,
+    });
+
+    expect(results.confidence).toBe('medium');
+    expect(results.maxRawScore).toBe(0.4);
+  });
+
+  it('returns low confidence for scores below 0.3', async () => {
+    vi.mocked(mockLanceStore.search).mockResolvedValue([
+      {
+        id: createDocumentId('doc1'),
+        score: 0.2, // Low confidence
+        content: 'low score result',
+        metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
+      },
+    ]);
+    vi.mocked(mockLanceStore.fullTextSearch).mockResolvedValue([]);
+
+    const results = await searchService.search({
+      query: 'test query',
+      stores: [storeId],
+      mode: 'hybrid',
+      limit: 10,
+    });
+
+    expect(results.confidence).toBe('low');
+    expect(results.maxRawScore).toBe(0.2);
+  });
+
+  it('filters results with minRelevance based on raw score', async () => {
+    vi.mocked(mockLanceStore.search).mockResolvedValue([
+      {
+        id: createDocumentId('doc1'),
+        score: 0.25, // Below minRelevance threshold
+        content: 'low relevance result',
+        metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
+      },
+    ]);
+    vi.mocked(mockLanceStore.fullTextSearch).mockResolvedValue([]);
+
+    const results = await searchService.search({
+      query: 'irrelevant query',
+      stores: [storeId],
+      mode: 'hybrid',
+      limit: 10,
+      minRelevance: 0.4, // Filter out results below this raw score
+    });
+
+    // Should return empty since max raw score (0.25) < minRelevance (0.4)
+    expect(results.results.length).toBe(0);
+    expect(results.confidence).toBe('low');
+  });
+
+  it('returns results when maxRawScore meets minRelevance', async () => {
+    vi.mocked(mockLanceStore.search).mockResolvedValue([
+      {
+        id: createDocumentId('doc1'),
+        score: 0.5, // Above minRelevance threshold
+        content: 'relevant result',
+        metadata: { type: 'file' as const, storeId, indexedAt: new Date() },
+      },
+    ]);
+    vi.mocked(mockLanceStore.fullTextSearch).mockResolvedValue([]);
+
+    const results = await searchService.search({
+      query: 'relevant query',
+      stores: [storeId],
+      mode: 'hybrid',
+      limit: 10,
+      minRelevance: 0.4,
+    });
+
+    // Should return results since max raw score (0.5) >= minRelevance (0.4)
+    expect(results.results.length).toBe(1);
+    expect(results.confidence).toBe('high');
+  });
+});

package/src/services/search.service.ts

@@ -9,6 +9,7 @@ import type {
   SearchQuery,
   SearchResponse,
   SearchResult,
+  SearchConfidence,
   DetailLevel,
   CodeUnit,
 } from '../types/search.js';
@@ -246,6 +247,19 @@ export class SearchService {
     return result;
   }
 
+  /**
+   * Calculate confidence level based on max raw vector similarity score.
+   * Configurable via environment variables.
+   */
+  private calculateConfidence(maxRawScore: number): SearchConfidence {
+    const highThreshold = parseFloat(process.env['SEARCH_CONFIDENCE_HIGH'] ?? '0.5');
+    const mediumThreshold = parseFloat(process.env['SEARCH_CONFIDENCE_MEDIUM'] ?? '0.3');
+
+    if (maxRawScore >= highThreshold) return 'high';
+    if (maxRawScore >= mediumThreshold) return 'medium';
+    return 'low';
+  }
+
   async search(query: SearchQuery): Promise<SearchResponse> {
     const startTime = Date.now();
     const mode = query.mode ?? 'hybrid';
@@ -264,22 +278,61 @@ export class SearchService {
         detail,
         intent: primaryIntent,
         intents,
+        minRelevance: query.minRelevance,
       },
       'Search query received'
     );
 
     let allResults: SearchResult[] = [];
+    let maxRawScore = 0;
 
     // Fetch more results than needed to allow for deduplication
     const fetchLimit = limit * 3;
 
     if (mode === 'vector') {
+      // For vector mode, get raw scores first for confidence calculation
+      const rawResults = await this.vectorSearchRaw(query.query, stores, fetchLimit);
+      maxRawScore = rawResults.length > 0 ? (rawResults[0]?.score ?? 0) : 0;
       allResults = await this.vectorSearch(query.query, stores, fetchLimit, query.threshold);
     } else if (mode === 'fts') {
+      // FTS mode doesn't have vector similarity, so no confidence calculation
       allResults = await this.ftsSearch(query.query, stores, fetchLimit);
     } else {
-      // Hybrid: combine vector and FTS with RRF
-      allResults = await this.hybridSearch(query.query, stores, fetchLimit, query.threshold);
+      // Hybrid: combine vector and FTS with RRF, get maxRawScore for confidence
+      const hybridResult = await this.hybridSearchWithMetadata(
+        query.query,
+        stores,
+        fetchLimit,
+        query.threshold
+      );
+      allResults = hybridResult.results;
+      maxRawScore = hybridResult.maxRawScore;
+    }
+
+    // Apply minRelevance filter - if max raw score is below threshold, return empty
+    if (query.minRelevance !== undefined && maxRawScore < query.minRelevance) {
+      const timeMs = Date.now() - startTime;
+      logger.info(
+        {
+          query: query.query,
+          mode,
+          maxRawScore,
+          minRelevance: query.minRelevance,
+          timeMs,
+        },
+        'Search filtered by minRelevance - no sufficiently relevant results'
+      );
+
+      return {
+        query: query.query,
+        mode,
+        stores,
+        results: [],
+        totalResults: 0,
+        timeMs,
+        confidence: this.calculateConfidence(maxRawScore),
+        maxRawScore,
+      };
     }
 
     // Deduplicate by source file - keep best chunk per source (considers query relevance)
@@ -302,6 +355,7 @@ export class SearchService {
     });
 
     const timeMs = Date.now() - startTime;
+    const confidence = mode !== 'fts' ? this.calculateConfidence(maxRawScore) : undefined;
 
     logger.info(
       {
@@ -310,6 +364,8 @@ export class SearchService {
         resultCount: enhancedResults.length,
         dedupedFrom: allResults.length,
         intents: intents.map((i) => `${i.intent}(${i.confidence.toFixed(2)})`),
+        maxRawScore: mode !== 'fts' ? maxRawScore : undefined,
+        confidence,
         timeMs,
       },
       'Search complete'
@@ -322,6 +378,8 @@ export class SearchService {
       results: enhancedResults,
       totalResults: enhancedResults.length,
       timeMs,
+      confidence,
+      maxRawScore: mode !== 'fts' ? maxRawScore : undefined,
     };
   }
 
@@ -412,27 +470,41 @@ export class SearchService {
     return normalized;
   }
 
-  private async vectorSearch(
+  /**
+   * Fetch raw vector search results without normalization.
+   * Returns results with raw cosine similarity scores [0-1].
+   */
+  private async vectorSearchRaw(
     query: string,
     stores: readonly StoreId[],
-    limit: number,
-    threshold?: number
+    limit: number
   ): Promise<SearchResult[]> {
     const queryVector = await this.embeddingEngine.embed(query);
     const results: SearchResult[] = [];
 
     for (const storeId of stores) {
-      const hits = await this.lanceStore.search(storeId, queryVector, limit, threshold);
+      const hits = await this.lanceStore.search(storeId, queryVector, limit);
       results.push(
         ...hits.map((r) => ({
           id: r.id,
-          score: r.score,
+          score: r.score, // Raw cosine similarity (1 - distance)
           content: r.content,
           metadata: r.metadata,
         }))
       );
     }
 
+    return results.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+
+  private async vectorSearch(
+    query: string,
+    stores: readonly StoreId[],
+    limit: number,
+    threshold?: number
+  ): Promise<SearchResult[]> {
+    const results = await this.vectorSearchRaw(query, stores, limit);
+
     // Normalize scores and apply threshold filter
     const normalized = this.normalizeAndFilterScores(results, threshold);
     return normalized.slice(0, limit);
@@ -460,20 +532,37 @@ export class SearchService {
     return results.sort((a, b) => b.score - a.score).slice(0, limit);
   }
 
-  private async hybridSearch(
+  /**
+   * Internal hybrid search result with additional metadata for confidence calculation.
+   */
+  private async hybridSearchWithMetadata(
     query: string,
     stores: readonly StoreId[],
     limit: number,
     threshold?: number
-  ): Promise<SearchResult[]> {
+  ): Promise<{ results: SearchResult[]; maxRawScore: number }> {
     // Classify query intents for context-aware ranking (supports multiple intents)
     const intents = classifyQueryIntents(query);
 
-    // Get both result sets (don't pass threshold - apply after RRF normalization)
-    const [vectorResults, ftsResults] = await Promise.all([
-      this.vectorSearch(query, stores, limit * 2),
-      this.ftsSearch(query, stores, limit * 2),
-    ]);
+    // Get raw vector results (unnormalized) to track raw cosine similarity
+    // We use these for both raw score tracking and as the basis for normalized vector results
+    const rawVectorResults = await this.vectorSearchRaw(query, stores, limit * 2);
+
+    // Build map of raw vector scores by document ID
+    const rawVectorScores = new Map<string, number>();
+    rawVectorResults.forEach((r) => {
+      rawVectorScores.set(r.id, r.score);
+    });
+
+    // Track max raw score for confidence calculation
+    const maxRawScore = rawVectorResults.length > 0 ? (rawVectorResults[0]?.score ?? 0) : 0;
+
+    // Normalize raw vector results directly (avoids duplicate embedding call)
+    // Don't apply threshold here - it's applied to final RRF-normalized scores at the end
+    const vectorResults = this.normalizeAndFilterScores(rawVectorResults);
+
+    // Get FTS results in parallel (only one call needed now)
+    const ftsResults = await this.ftsSearch(query, stores, limit * 2);
 
     // Build rank maps
     const vectorRanks = new Map<string, number>();
@@ -497,6 +586,7 @@ export class SearchService {
       id: string;
       score: number;
       result: SearchResult;
+      rawVectorScore: number | undefined;
       metadata: {
         vectorRank?: number;
         ftsRank?: number;
@@ -506,6 +596,7 @@ export class SearchService {
         frameworkBoost: number;
         urlKeywordBoost: number;
         pathKeywordBoost: number;
+        rawVectorScore?: number;
       };
     }> = [];
 
@@ -516,6 +607,7 @@ export class SearchService {
     for (const [id, result] of allDocs) {
       const vectorRank = vectorRanks.get(id) ?? Infinity;
       const ftsRank = ftsRanks.get(id) ?? Infinity;
+      const rawVectorScore = rawVectorScores.get(id);
 
       const vectorRRF = vectorRank !== Infinity ? vectorWeight / (k + vectorRank) : 0;
       const ftsRRF = ftsRank !== Infinity ? ftsWeight / (k + ftsRank) : 0;
@@ -545,6 +637,7 @@ export class SearchService {
         frameworkBoost: number;
         urlKeywordBoost: number;
         pathKeywordBoost: number;
+        rawVectorScore?: number;
       } = {
         vectorRRF,
         ftsRRF,
@@ -560,6 +653,9 @@ export class SearchService {
       if (ftsRank !== Infinity) {
         metadata.ftsRank = ftsRank;
       }
+      if (rawVectorScore !== undefined) {
+        metadata.rawVectorScore = rawVectorScore;
+      }
 
       rrfScores.push({
         id,
@@ -570,6 +666,7 @@ export class SearchService {
           urlKeywordBoost *
           pathKeywordBoost,
         result,
+        rawVectorScore,
         metadata,
       });
     }
@@ -616,10 +713,10 @@ export class SearchService {
 
     // Apply threshold filter on normalized scores (UX consistency)
     if (threshold !== undefined) {
-      return normalizedResults.filter((r) => r.score >= threshold);
+      normalizedResults = normalizedResults.filter((r) => r.score >= threshold);
     }
 
-    return normalizedResults;
+    return { results: normalizedResults, maxRawScore };
   }
 
   async searchAllStores(query: SearchQuery, storeIds: StoreId[]): Promise<SearchResponse> {
@@ -655,7 +752,7 @@ export class SearchService {
         baseBoost = 0.75; // Internal implementation files (not too harsh)
         break;
       case 'test':
-        baseBoost = 0.7; // Tests significantly lower
+        baseBoost = parseFloat(process.env['SEARCH_TEST_FILE_BOOST'] ?? '0.5'); // Tests strongly penalized
         break;
       case 'config':
         baseBoost = 0.5; // Config files rarely answer questions
@@ -676,8 +773,14 @@ export class SearchService {
     }
 
     const blendedMultiplier = totalConfidence > 0 ? weightedMultiplier / totalConfidence : 1.0;
+    const finalBoost = baseBoost * blendedMultiplier;
+
+    // Cap test file boost to prevent intent multipliers from overriding the penalty
+    if (fileType === 'test') {
+      return Math.min(finalBoost, 0.6);
+    }
 
-    return baseBoost * blendedMultiplier;
+    return finalBoost;
   }
 
   /**