@gmickel/gno 1.22.0 → 1.23.0

package/src/pipeline/explain.ts

@@ -11,8 +11,11 @@ import type {
   ExplainResult,
   QueryModeSummary,
   RerankedCandidate,
+  SearchResult,
 } from "./types";
 
+import { SEARCH_RESULT_PLANNER_METADATA } from "./types";
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Formatter
 // ─────────────────────────────────────────────────────────────────────────────
@@ -35,7 +38,8 @@ export function formatResultExplain(results: ExplainResult[]): string {
       r.fusionScore !== undefined ||
       r.bm25Score !== undefined ||
       r.vecScore !== undefined ||
-      r.rerankScore !== undefined
+      r.rerankScore !== undefined ||
+      r.projectAffinity !== undefined
     ) {
       msg += " (";
       if (r.fusionScore !== undefined) {
@@ -59,6 +63,12 @@ export function formatResultExplain(results: ExplainResult[]): string {
         }
         msg += `rerank=${r.rerankScore.toFixed(2)}`;
       }
+      if (r.projectAffinity) {
+        if (msg.at(-1) !== "(") {
+          msg += ", ";
+        }
+        msg += `raw=${r.projectAffinity.rawScoreKind}:${r.projectAffinity.rawScore.toFixed(3)}, base=${r.projectAffinity.baseScore.toFixed(3)}, affinity=${r.projectAffinity.affinityApplied.toFixed(3)}/${r.projectAffinity.affinityRequested.toFixed(3)}, auxiliary=${r.projectAffinity.combinedAuxiliaryApplied.toFixed(3)}/${r.projectAffinity.combinedAuxiliaryCap.toFixed(3)}, collection=${r.projectAffinity.collectionAlias}, root=${r.projectAffinity.rootAlias}, source=${r.projectAffinity.source}, final=${r.projectAffinity.finalScore.toFixed(3)}`;
+      }
       msg += ")";
     }
     lines.push(`[explain] result ${r.rank}: ${r.docid} ${msg}`);
@@ -206,18 +216,49 @@ export function explainTimings(timings: StageTimingsInput): ExplainLine {
 
 export function buildExplainResults(
   candidates: RerankedCandidate[],
-  docidMap: Map<string, string>
+  docidMap: Map<string, string>,
+  finalResults?: SearchResult[]
 ): ExplainResult[] {
-  return candidates.slice(0, 20).map((c, i) => {
-    const key = `${c.mirrorHash}:${c.seq}`;
-    return {
-      rank: i + 1,
-      docid: docidMap.get(key) ?? "#unknown",
-      score: c.blendedScore,
-      fusionScore: c.fusionScore,
-      bm25Score: c.bm25Rank !== null ? 1 / (60 + c.bm25Rank) : undefined,
-      vecScore: c.vecRank !== null ? 1 / (60 + c.vecRank) : undefined,
-      rerankScore: c.rerankScore ?? undefined,
-    };
+  if (finalResults) {
+    return finalResults.slice(0, 20).map((result, index) => {
+      const planner = result[SEARCH_RESULT_PLANNER_METADATA];
+      const candidate = candidates.find(
+        (entry) =>
+          entry.mirrorHash === result.conversion?.mirrorHash &&
+          entry.seq === (planner?.retrievalSeq ?? planner?.seq)
+      );
+      return buildExplainResult(result.docid, result.score, index, candidate);
+    });
+  }
+  return candidates.slice(0, 20).map((candidate, index) => {
+    const key = `${candidate.mirrorHash}:${candidate.seq}`;
+    return buildExplainResult(
+      docidMap.get(key) ?? "#unknown",
+      candidate.blendedScore,
+      index,
+      candidate
+    );
   });
 }
+
+function buildExplainResult(
+  docid: string,
+  score: number,
+  index: number,
+  candidate?: RerankedCandidate
+): ExplainResult {
+  if (!candidate) {
+    return { rank: index + 1, docid, score };
+  }
+  return {
+    rank: index + 1,
+    docid,
+    score,
+    fusionScore: candidate.fusionScore,
+    bm25Score:
+      candidate.bm25Rank !== null ? 1 / (60 + candidate.bm25Rank) : undefined,
+    vecScore:
+      candidate.vecRank !== null ? 1 / (60 + candidate.vecRank) : undefined,
+    rerankScore: candidate.rerankScore ?? undefined,
+  };
+}

package/src/pipeline/hybrid.ts

@@ -41,6 +41,11 @@ import { evaluateDocumentChunkFilters } from "./filters";
 import { type RankedInput, rrfFuse, toRankedInput } from "./fusion";
 import { expandGraphCandidates } from "./graph-retrieval";
 import { selectBestChunkForSteering } from "./intent";
+import {
+  applyProjectAffinity,
+  getProjectAffinityMetadata,
+  hasProjectAffinity,
+} from "./project-affinity";
 import { detectQueryLanguage } from "./query-language";
 import {
   buildExpansionFromQueryModes,
@@ -301,6 +306,7 @@ export async function searchHybrid(
   const runStartedAt = performance.now();
   const { store, vectorIndex, embedPort, expandPort, rerankPort } = deps;
   const pipelineConfig = deps.pipelineConfig ?? DEFAULT_PIPELINE_CONFIG;
+  const affinityActive = hasProjectAffinity(options.projectAffinity);
 
   const limit = options.limit ?? 20;
   const recencySort = shouldSortByRecency(query);
@@ -719,7 +725,7 @@ export async function searchHybrid(
   // ─────────────────────────────────────────────────────────────────────────
   const minScore = options.minScore ?? 0;
   const filteredCandidates =
-    minScore > 0
+    minScore > 0 && !affinityActive
       ? rerankResult.candidates.filter((c) => c.blendedScore >= minScore)
       : rerankResult.candidates;
 
@@ -875,7 +881,7 @@ export async function searchHybrid(
   // Iterate until we have enough results (don't slice early - deduping may skip candidates)
   for (const [candidateIndex, candidate] of filteredCandidates.entries()) {
     // Stop when we have enough results
-    if (results.length >= assemblyLimit) {
+    if (!affinityActive && results.length >= assemblyLimit) {
       break;
     }
 
@@ -939,64 +945,76 @@ export async function searchHybrid(
     }
 
     for (const doc of candidateDocs) {
-      if (results.length >= assemblyLimit) break;
+      if (!affinityActive && results.length >= assemblyLimit) break;
       const filterEval = evaluateDocumentChunkFilters(
         query,
         doc,
         docChunks,
         options
       );
-      if (!filterEval.matches || (options.full && seenDocids.has(doc.docid))) {
+      if (
+        !filterEval.matches ||
+        (options.full && !affinityActive && seenDocids.has(doc.docid))
+      ) {
         continue;
       }
       const docidKey = `${candidate.mirrorHash}:${candidate.seq}`;
       if (!docidMap.has(docidKey)) docidMap.set(docidKey, doc.docid);
       const collectionPath = collectionPaths.get(doc.collection);
-      seenDocids.add(doc.docid);
-      results.push(
-        attachSearchResultPlannerMetadata(
-          {
-            docid: doc.docid,
-            score: candidate.blendedScore,
-            uri: doc.uri,
-            title: doc.title ?? undefined,
-            contentType: doc.contentType ?? undefined,
-            categories: doc.categories ?? undefined,
-            line: snippetChunk.startLine,
-            snippet,
-            snippetLanguage: chunk.language ?? undefined,
-            snippetRange,
-            source: {
-              relPath: doc.relPath,
-              absPath: collectionPath
-                ? `${collectionPath}/${doc.relPath}`
-                : undefined,
-              mime: doc.sourceMime,
-              ext: doc.sourceExt,
-              modifiedAt: doc.sourceMtime,
-              documentDate: doc.frontmatterDate ?? undefined,
-              sizeBytes: doc.sourceSize,
-              sourceHash: doc.sourceHash,
-            },
-            conversion: {
-              mirrorHash: candidate.mirrorHash,
-              converterId: doc.converterId ?? undefined,
-              converterVersion: doc.converterVersion ?? undefined,
-            },
+      if (options.full && !affinityActive) {
+        seenDocids.add(doc.docid);
+      }
+      const scoredResult = applyProjectAffinity(
+        {
+          docid: doc.docid,
+          score: candidate.blendedScore,
+          uri: doc.uri,
+          title: doc.title ?? undefined,
+          contentType: doc.contentType ?? undefined,
+          categories: doc.categories ?? undefined,
+          line: snippetChunk.startLine,
+          snippet,
+          snippetLanguage: chunk.language ?? undefined,
+          snippetRange,
+          source: {
+            relPath: doc.relPath,
+            absPath: collectionPath
+              ? `${collectionPath}/${doc.relPath}`
+              : undefined,
+            mime: doc.sourceMime,
+            ext: doc.sourceExt,
+            modifiedAt: doc.sourceMtime,
+            documentDate: doc.frontmatterDate ?? undefined,
+            sizeBytes: doc.sourceSize,
+            sourceHash: doc.sourceHash,
           },
-          {
-            retrievalRank: candidateIndex + 1,
+          conversion: {
             mirrorHash: candidate.mirrorHash,
-            seq: snippetChunk.seq,
-            sources: [...candidate.sources].sort(),
-            graphExpanded: candidate.sources.includes("graph"),
-            startLine: snippetChunk.startLine,
-            endLine: snippetChunk.endLine,
-            passageHash: new Bun.CryptoHasher("sha256")
-              .update(snippetChunk.text)
-              .digest("hex"),
-          }
-        )
+            converterId: doc.converterId ?? undefined,
+            converterVersion: doc.converterVersion ?? undefined,
+          },
+        },
+        doc.collection,
+        options.projectAffinity,
+        { kind: "hybrid_blended", score: candidate.blendedScore }
+      );
+      if (scoredResult.score < minScore) continue;
+      results.push(
+        attachSearchResultPlannerMetadata(scoredResult, {
+          retrievalRank: candidateIndex + 1,
+          mirrorHash: candidate.mirrorHash,
+          seq: snippetChunk.seq,
+          ...(affinityActive && snippetChunk.seq !== candidate.seq
+            ? { retrievalSeq: candidate.seq }
+            : {}),
+          sources: [...candidate.sources].sort(),
+          graphExpanded: candidate.sources.includes("graph"),
+          startLine: snippetChunk.startLine,
+          endLine: snippetChunk.endLine,
+          passageHash: new Bun.CryptoHasher("sha256")
+            .update(snippetChunk.text)
+            .digest("hex"),
+        })
       );
     }
   }
@@ -1008,21 +1026,16 @@ export async function searchHybrid(
   // ─────────────────────────────────────────────────────────────────────────
   // 6. Build explain data (if requested)
   // ─────────────────────────────────────────────────────────────────────────
-  const explainData = options.explain
-    ? {
-        lines: explainLines,
-        results: buildExplainResults(
-          filteredCandidates.slice(0, limit),
-          docidMap
-        ),
-      }
-    : undefined;
-
   // ─────────────────────────────────────────────────────────────────────────
   // 7. Return results
   // ─────────────────────────────────────────────────────────────────────────
+  const dedupedResults =
+    options.full && affinityActive
+      ? dedupeFullResultsByDocid(results)
+      : results;
+
   if (recencySort) {
-    results.sort((a, b) => {
+    dedupedResults.sort((a, b) => {
       const aTs = resolveRecencyTimestamp(
         a.source.documentDate,
         a.source.modifiedAt
@@ -1036,9 +1049,26 @@ export async function searchHybrid(
       }
       return b.score - a.score;
     });
+  } else if (affinityActive) {
+    dedupedResults.sort((a, b) => b.score - a.score);
   }
 
-  const finalResults = results.slice(0, limit);
+  const finalResults = dedupedResults.slice(0, limit);
+  const explainData = options.explain
+    ? {
+        lines: explainLines,
+        results: affinityActive
+          ? buildExplainResults(filteredCandidates, docidMap, finalResults).map(
+              (result, index) => ({
+                ...result,
+                projectAffinity: getProjectAffinityMetadata(
+                  finalResults[index]!
+                ),
+              })
+            )
+          : buildExplainResults(filteredCandidates.slice(0, limit), docidMap),
+      }
+    : undefined;
   await attachSearchResultContexts(store, finalResults);
 
   const output: SearchResults = {
@@ -1143,3 +1173,14 @@ export async function searchHybrid(
   }
   return ok(output);
 }
+
+function dedupeFullResultsByDocid(results: SearchResult[]): SearchResult[] {
+  const bestByDocid = new Map<string, SearchResult>();
+  for (const result of results) {
+    const existing = bestByDocid.get(result.docid);
+    if (!existing || result.score > existing.score) {
+      bestByDocid.set(result.docid, result);
+    }
+  }
+  return [...bestByDocid.values()];
+}

package/src/pipeline/project-affinity.ts

@@ -0,0 +1,162 @@
+/**
+ * Bounded auxiliary scoring for trusted project affinity.
+ *
+ * @module src/pipeline/project-affinity
+ */
+
+import type {
+  ProjectAffinityMatch,
+  ProjectAffinityResolution,
+} from "../core/project-affinity";
+import type { SearchResult } from "./types";
+
+import {
+  AUXILIARY_RANKING_MAX_CONTRIBUTION,
+  PROJECT_AFFINITY_MAX_CONTRIBUTION,
+} from "../config/types";
+
+export interface ProjectAffinityScoringInput {
+  enabled?: boolean;
+  contribution?: number;
+  resolution: ProjectAffinityResolution;
+}
+
+export interface ProjectAffinityScoreMetadata {
+  affinityAdjustedScore: number;
+  affinityApplied: number;
+  affinityRequested: number;
+  affinityWeight: number;
+  baseScore: number;
+  collectionAlias: string | null;
+  combinedAuxiliaryApplied: number;
+  combinedAuxiliaryCap: number;
+  combinedAuxiliaryRequested: number;
+  finalBlendedScore: number;
+  finalScore: number;
+  matched: boolean;
+  rawScore: number;
+  rawScoreKind: "bm25" | "hybrid_blended" | "normalized" | "vector_distance";
+  rootAlias: string | null;
+  source: ProjectAffinityMatch["source"] | null;
+}
+
+export const SEARCH_RESULT_AFFINITY_METADATA = Symbol(
+  "gno.searchResultAffinityMetadata"
+);
+
+const clamp = (value: number, min: number, max: number): number =>
+  Math.min(max, Math.max(min, value));
+
+export function applyAuxiliaryScore(
+  baseScore: number,
+  contributions: readonly number[]
+): {
+  applied: number;
+  finalScore: number;
+  requested: number;
+} {
+  const requested = [...contributions]
+    .sort((left, right) => left - right)
+    .reduce((total, contribution) => total + contribution, 0);
+  const applied = clamp(
+    requested,
+    -AUXILIARY_RANKING_MAX_CONTRIBUTION,
+    AUXILIARY_RANKING_MAX_CONTRIBUTION
+  );
+  return {
+    requested,
+    applied,
+    finalScore: clamp(baseScore + applied, 0, 1),
+  };
+}
+
+const matchingCollection = (
+  input: ProjectAffinityScoringInput | undefined,
+  collection: string
+): ProjectAffinityMatch | undefined => {
+  if (input?.enabled === false) return undefined;
+  return input?.resolution.matches.find(
+    (match) => match.collection === collection
+  );
+};
+
+export function scoreProjectAffinity(
+  baseScore: number,
+  collection: string,
+  input: ProjectAffinityScoringInput | undefined,
+  raw: {
+    kind: ProjectAffinityScoreMetadata["rawScoreKind"];
+    score: number;
+  } = { kind: "normalized", score: baseScore }
+): ProjectAffinityScoreMetadata {
+  const match = matchingCollection(input, collection);
+  const configuredWeight = clamp(
+    input?.contribution ?? PROJECT_AFFINITY_MAX_CONTRIBUTION,
+    0,
+    PROJECT_AFFINITY_MAX_CONTRIBUTION
+  );
+  const affinityRequested = match ? configuredWeight : 0;
+  const auxiliary = applyAuxiliaryScore(baseScore, [affinityRequested]);
+  const affinityApplied = auxiliary.finalScore - baseScore;
+
+  return {
+    affinityAdjustedScore: auxiliary.finalScore,
+    affinityApplied,
+    affinityRequested,
+    affinityWeight: configuredWeight,
+    baseScore,
+    collectionAlias: match?.collectionAlias ?? null,
+    combinedAuxiliaryApplied: auxiliary.applied,
+    combinedAuxiliaryCap: AUXILIARY_RANKING_MAX_CONTRIBUTION,
+    combinedAuxiliaryRequested: auxiliary.requested,
+    finalBlendedScore: auxiliary.finalScore,
+    finalScore: auxiliary.finalScore,
+    matched: Boolean(match),
+    rawScore: raw.score,
+    rawScoreKind: raw.kind,
+    rootAlias: match?.rootAlias ?? null,
+    source: match?.source ?? null,
+  };
+}
+
+export function hasProjectAffinity(
+  input: ProjectAffinityScoringInput | undefined
+): boolean {
+  return (
+    Boolean(input) &&
+    input?.enabled !== false &&
+    (input?.contribution ?? PROJECT_AFFINITY_MAX_CONTRIBUTION) > 0 &&
+    (input?.resolution.matches.length ?? 0) !== 0
+  );
+}
+
+export function applyProjectAffinity(
+  result: SearchResult,
+  collection: string,
+  input: ProjectAffinityScoringInput | undefined,
+  raw?: {
+    kind: ProjectAffinityScoreMetadata["rawScoreKind"];
+    score: number;
+  }
+): SearchResult {
+  if (!hasProjectAffinity(input)) return result;
+  const metadata = scoreProjectAffinity(result.score, collection, input, raw);
+  result.score = metadata.finalScore;
+  Object.defineProperty(result, SEARCH_RESULT_AFFINITY_METADATA, {
+    configurable: true,
+    enumerable: false,
+    value: metadata,
+    writable: true,
+  });
+  return result;
+}
+
+export function getProjectAffinityMetadata(
+  result: SearchResult
+): ProjectAffinityScoreMetadata | undefined {
+  return (
+    result as SearchResult & {
+      [SEARCH_RESULT_AFFINITY_METADATA]?: ProjectAffinityScoreMetadata;
+    }
+  )[SEARCH_RESULT_AFFINITY_METADATA];
+}

package/src/pipeline/search.ts

@@ -20,6 +20,7 @@ import { err, ok } from "../store/types";
 import { createChunkLookup } from "./chunk-lookup";
 import { matchesExcludedChunks, matchesExcludedText } from "./exclude";
 import { selectBestChunkForSteering } from "./intent";
+import { applyProjectAffinity, hasProjectAffinity } from "./project-affinity";
 import { detectQueryLanguage } from "./query-language";
 import { attachSearchResultContexts } from "./result-context";
 import {
@@ -160,8 +161,9 @@ export async function searchBm25(
   const traceStartedAt = options.traceSession ? performance.now() : 0;
   const limit = options.limit ?? 20;
   const minScore = options.minScore ?? 0;
+  const affinityActive = hasProjectAffinity(options.projectAffinity);
   const recencySort = shouldSortByRecency(query);
-  const retrievalLimit = recencySort ? limit * 3 : limit;
+  const retrievalLimit = recencySort || affinityActive ? limit * 3 : limit;
   const temporalRange = resolveTemporalRange(
     query,
     options.since,
@@ -208,6 +210,10 @@ export async function searchBm25(
 
   // Build results
   const results: SearchResult[] = [];
+  const scoringByResult = new WeakMap<
+    SearchResult,
+    { collection: string; rawScore: number }
+  >();
 
   // Pre-fetch all chunks in one batch query (eliminates N+1)
   const uniqueHashes = [
@@ -229,6 +235,11 @@ export async function searchBm25(
     string,
     { fts: FtsResult; chunk: ChunkRow | null; score: number }
   >();
+  const fullAffinityEntries: {
+    fts: FtsResult;
+    chunk: ChunkRow | null;
+    score: number;
+  }[] = [];
 
   for (const fts of ftsResult.value) {
     // Dedup by uri+seq - eliminates rows from mirror_hash join fan-out
@@ -278,6 +289,10 @@ export async function searchBm25(
     // For --full, de-dupe by docid (keep best scoring chunk per doc)
     // Raw BM25: smaller (more negative) is better
     if (options.full) {
+      if (affinityActive) {
+        fullAffinityEntries.push({ fts, chunk, score: fts.score });
+        continue;
+      }
       const docid = fts.docid ?? "";
       const existing = bestByDocid.get(docid);
       if (!existing || fts.score < existing.score) {
@@ -289,16 +304,22 @@ export async function searchBm25(
     const collectionPath = fts.collection
       ? collectionPaths.get(fts.collection)
       : undefined;
-
-    results.push(buildSearchResult({ fts, chunk, collectionPath, options }));
+    const result = buildSearchResult({ fts, chunk, collectionPath, options });
+    if (fts.collection) {
+      scoringByResult.set(result, {
+        collection: fts.collection,
+        rawScore: fts.score,
+      });
+    }
+    results.push(result);
   }
 
   // For --full, fetch full content and build results
   if (options.full) {
     // Sort by raw BM25 score (smaller = better) before building results
-    const sortedEntries = [...bestByDocid.values()].sort(
-      (a, b) => a.score - b.score
-    );
+    const sortedEntries = (
+      affinityActive ? fullAffinityEntries : [...bestByDocid.values()]
+    ).sort((a, b) => a.score - b.score);
     const fullContentResult = await getContentBatch(
       store,
       sortedEntries
@@ -317,18 +338,50 @@ export async function searchBm25(
       const collectionPath = fts.collection
         ? collectionPaths.get(fts.collection)
         : undefined;
-      results.push(
-        buildSearchResult({ fts, chunk, collectionPath, options, fullContent })
-      );
+      const result = buildSearchResult({
+        fts,
+        chunk,
+        collectionPath,
+        options,
+        fullContent,
+      });
+      if (fts.collection) {
+        scoringByResult.set(result, {
+          collection: fts.collection,
+          rawScore: fts.score,
+        });
+      }
+      results.push(result);
     }
   }
 
   // Normalize scores to 0-1 range (batch min-max)
   normalizeBm25Scores(results);
 
+  if (affinityActive) {
+    for (const result of results) {
+      const scoring = scoringByResult.get(result);
+      if (scoring) {
+        applyProjectAffinity(
+          result,
+          scoring.collection,
+          options.projectAffinity,
+          { kind: "bm25", score: scoring.rawScore }
+        );
+      }
+    }
+  }
+
+  const dedupedResults =
+    options.full && affinityActive
+      ? dedupeFullResultsByDocid(results)
+      : results;
+
   // Apply minScore filter after normalization
   const filteredResults =
-    minScore > 0 ? results.filter((r) => r.score >= minScore) : results;
+    minScore > 0
+      ? dedupedResults.filter((r) => r.score >= minScore)
+      : dedupedResults;
 
   if (recencySort) {
     filteredResults.sort((a, b) => {
@@ -345,6 +398,8 @@ export async function searchBm25(
       }
       return b.score - a.score;
     });
+  } else if (affinityActive) {
+    filteredResults.sort((a, b) => b.score - a.score);
   }
 
   const finalResults = filteredResults.slice(0, limit);
@@ -384,3 +439,14 @@ export async function searchBm25(
   }
   return ok(output);
 }
+
+function dedupeFullResultsByDocid(results: SearchResult[]): SearchResult[] {
+  const bestByDocid = new Map<string, SearchResult>();
+  for (const result of results) {
+    const existing = bestByDocid.get(result.docid);
+    if (!existing || result.score > existing.score) {
+      bestByDocid.set(result.docid, result);
+    }
+  }
+  return [...bestByDocid.values()];
+}

package/src/pipeline/types.ts

@@ -13,6 +13,10 @@ import type { RetrievalTraceSession } from "../core/retrieval-trace-session";
 import type { StoreResult } from "../store/types";
 import type { ClaimVerificationResult } from "./claim-verification";
 import type { SemanticVerificationCapability } from "./claim-verifier";
+import type {
+  ProjectAffinityScoreMetadata,
+  ProjectAffinityScoringInput,
+} from "./project-affinity";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Search Result Types
@@ -53,6 +57,8 @@ export interface SearchResultPlannerMetadata {
   retrievalRank: number;
   mirrorHash: string;
   seq: number;
+  /** Original retrieval seq when intent steering selects another snippet. */
+  retrievalSeq?: number;
   sources: FusionSource[];
   graphExpanded: boolean;
   /** Exact canonical chunk coordinates, retained even for full-content output. */
@@ -164,6 +170,8 @@ export interface SearchResults {
 export interface SearchOptions {
   /** Internal receipt seam; never serialized or included in public schemas. */
   traceSession?: RetrievalTraceSession;
+  /** Trusted, already-resolved project affinity; never accepts raw roots. */
+  projectAffinity?: ProjectAffinityScoringInput;
   /** Max results */
   limit?: number;
   /** Min score threshold (0-1) */
@@ -536,4 +544,5 @@ export interface ExplainResult {
   bm25Score?: number;
   vecScore?: number;
   rerankScore?: number;
+  projectAffinity?: ProjectAffinityScoreMetadata;
 }