Method scoreAndSortResults

src/core/search.ts:515–809

(
    query: string,
    limit: number,
    results: {
      semantic: Map<string, { chunk: CodeChunk; ranks: Array<{ rank: number; weight: number }> }>;
      keyword: Map<string, { chunk: CodeChunk; ranks: Array<{ rank: number; weight: number }> }>;
    },
    profile: SearchIntentProfile,
    intent: QueryIntent,
    totalVariantWeight: number
  )

  }

  private scoreAndSortResults(
    query: string,
    limit: number,
    results: {
      semantic: Map<string, { chunk: CodeChunk; ranks: Array<{ rank: number; weight: number }> }>;
      keyword: Map<string, { chunk: CodeChunk; ranks: Array<{ rank: number; weight: number }> }>;
    },
    profile: SearchIntentProfile,
    intent: QueryIntent,
    totalVariantWeight: number
  ): SearchResult[] {
    const likelyWiringQuery = this.isLikelyWiringOrFlowQuery(query);
    const actionQuery = this.isActionOrHowQuery(query);

    // RRF: k=60 is the standard parameter (proven robust in Elasticsearch + TOSS paper arXiv:2208.11274)
    const RRF_K = 60;

    // Collect all unique chunks from both retrieval channels
    const allChunks = new Map<string, CodeChunk>();
    const rrfScores = new Map<string, number>();

    // Gather all chunks
    for (const [id, entry] of results.semantic) {
      allChunks.set(id, entry.chunk);
    }
    for (const [id, entry] of results.keyword) {
      if (!allChunks.has(id)) {
        allChunks.set(id, entry.chunk);
      }
    }

    // Calculate RRF scores: RRF(d) = SUM(weight_i / (k + rank_i))
    for (const [id] of allChunks) {
      let rrfScore = 0;

      // Add contributions from semantic ranks
      const semanticEntry = results.semantic.get(id);
      if (semanticEntry) {
        for (const { rank, weight } of semanticEntry.ranks) {
          rrfScore += weight / (RRF_K + rank);
        }
      }

      // Add contributions from keyword ranks
      const keywordEntry = results.keyword.get(id);
      if (keywordEntry) {
        for (const { rank, weight } of keywordEntry.ranks) {
          rrfScore += weight / (RRF_K + rank);
        }
      }

      rrfScores.set(id, rrfScore);
    }

    // Normalize by theoretical maximum (rank-0 in every list), NOT by actual max.
    // Using actual max makes top result always 1.0, breaking quality confidence gating.
    const theoreticalMaxRrf = totalVariantWeight / (RRF_K + 0);
    const maxRrfScore = Math.max(theoreticalMaxRrf, 0.01);