@absolutejs/absolute 0.19.0-beta.641 → 0.19.0-beta.643

package/dist/ai/index.js

@@ -2933,21 +2933,40 @@ var formatTraceCountDelta = (value) => `${value >= 0 ? "+" : ""}${value}`;
 var buildComparisonOverviewPresentation = (input) => {
   const winnerLabel = input.resolveLabel(input.summary.bestByPassingRate);
   const winnerEntry = input.resolveEntry(input.summary.bestByPassingRate);
+  const rows = [
+    {
+      label: "Best passing rate",
+      value: input.resolveLabel(input.summary.bestByPassingRate)
+    },
+    {
+      label: "Best average F1",
+      value: input.resolveLabel(input.summary.bestByAverageF1)
+    },
+    {
+      label: "Fastest",
+      value: input.resolveLabel(input.summary.fastest)
+    }
+  ];
+  if (input.summary.bestByMultivectorCollapsedCases) {
+    rows.push({
+      label: "Best multivector collapse",
+      value: input.resolveLabel(input.summary.bestByMultivectorCollapsedCases)
+    });
+  }
+  if (input.summary.bestByMultivectorLexicalHitCases) {
+    rows.push({
+      label: "Best multivector lexical hits",
+      value: input.resolveLabel(input.summary.bestByMultivectorLexicalHitCases)
+    });
+  }
+  if (input.summary.bestByMultivectorVectorHitCases) {
+    rows.push({
+      label: "Best multivector vector hits",
+      value: input.resolveLabel(input.summary.bestByMultivectorVectorHitCases)
+    });
+  }
   return {
-    rows: [
-      {
-        label: "Best passing rate",
-        value: input.resolveLabel(input.summary.bestByPassingRate)
-      },
-      {
-        label: "Best average F1",
-        value: input.resolveLabel(input.summary.bestByAverageF1)
-      },
-      {
-        label: "Fastest",
-        value: input.resolveLabel(input.summary.fastest)
-      }
-    ],
+    rows,
     winnerLabel,
     summary: winnerEntry ? `passing ${formatEvaluationPassingRate(winnerEntry.response.passingRate)} \xB7 f1 ${winnerEntry.response.summary.averageF1.toFixed(3)} \xB7 latency ${winnerEntry.response.summary.averageLatencyMs.toFixed(1)}ms` : "Stored benchmark comparison"
   };
@@ -2995,6 +3014,9 @@ var buildRAGComparisonTraceSummaryRows = (entry) => {
   }, {
     label: "Variants",
     value: formatTraceRatio(trace.variantCases, trace.totalCases)
+  }, {
+    label: "Multivector",
+    value: `${formatTraceRatio(trace.multiVectorCases, trace.totalCases)} \xB7 collapse ${formatTraceRatio(trace.multiVectorCollapsedCases, trace.totalCases)} \xB7 lexical ${formatTraceRatio(trace.multiVectorLexicalHitCases, trace.totalCases)} \xB7 vector ${formatTraceRatio(trace.multiVectorVectorHitCases, trace.totalCases)}`
   }, {
     label: "TopK",
     value: `${trace.averageCandidateTopK.toFixed(1)} / ${trace.averageLexicalTopK.toFixed(1)}`
@@ -4051,6 +4073,15 @@ var evaluateRetrievalComparisonGate = ({
   if (typeof policy.maxElapsedMsDelta === "number" && delta.elapsedMsDelta > policy.maxElapsedMsDelta) {
     reasons.push(`elapsed ms delta ${delta.elapsedMsDelta} exceeds ${policy.maxElapsedMsDelta}`);
   }
+  if (typeof policy.minMultiVectorCollapsedCasesDelta === "number" && (delta.multiVectorCollapsedCasesDelta ?? 0) < policy.minMultiVectorCollapsedCasesDelta) {
+    reasons.push(`multivector collapsed delta ${delta.multiVectorCollapsedCasesDelta ?? 0} is below ${policy.minMultiVectorCollapsedCasesDelta}`);
+  }
+  if (typeof policy.minMultiVectorLexicalHitCasesDelta === "number" && (delta.multiVectorLexicalHitCasesDelta ?? 0) < policy.minMultiVectorLexicalHitCasesDelta) {
+    reasons.push(`multivector lexical-hit delta ${delta.multiVectorLexicalHitCasesDelta ?? 0} is below ${policy.minMultiVectorLexicalHitCasesDelta}`);
+  }
+  if (typeof policy.minMultiVectorVectorHitCasesDelta === "number" && (delta.multiVectorVectorHitCasesDelta ?? 0) < policy.minMultiVectorVectorHitCasesDelta) {
+    reasons.push(`multivector vector-hit delta ${delta.multiVectorVectorHitCasesDelta ?? 0} is below ${policy.minMultiVectorVectorHitCasesDelta}`);
+  }
   if (reasons.length === 0) {
     return {
       policy,
@@ -4553,6 +4584,34 @@ var buildTraceSummaryAggregate = ({
         direction: "flat",
         metric: "variantCases",
         previous: 0
+      },
+      {
+        current: 0,
+        delta: 0,
+        direction: "flat",
+        metric: "multiVectorCases",
+        previous: 0
+      },
+      {
+        current: 0,
+        delta: 0,
+        direction: "flat",
+        metric: "multiVectorVectorHitCases",
+        previous: 0
+      },
+      {
+        current: 0,
+        delta: 0,
+        direction: "flat",
+        metric: "multiVectorLexicalHitCases",
+        previous: 0
+      },
+      {
+        current: 0,
+        delta: 0,
+        direction: "flat",
+        metric: "multiVectorCollapsedCases",
+        previous: 0
       }
     ];
     return {
@@ -4647,6 +4706,34 @@ var buildTraceSummaryAggregate = ({
       direction: buildTraceSummaryDirection(latest.variantCases - previous.variantCases),
       metric: "variantCases",
       previous: previous.variantCases
+    },
+    {
+      current: latest.multiVectorCases,
+      delta: latest.multiVectorCases - previous.multiVectorCases,
+      direction: buildTraceSummaryDirection(latest.multiVectorCases - previous.multiVectorCases),
+      metric: "multiVectorCases",
+      previous: previous.multiVectorCases
+    },
+    {
+      current: latest.multiVectorVectorHitCases,
+      delta: latest.multiVectorVectorHitCases - previous.multiVectorVectorHitCases,
+      direction: buildTraceSummaryDirection(latest.multiVectorVectorHitCases - previous.multiVectorVectorHitCases),
+      metric: "multiVectorVectorHitCases",
+      previous: previous.multiVectorVectorHitCases
+    },
+    {
+      current: latest.multiVectorLexicalHitCases,
+      delta: latest.multiVectorLexicalHitCases - previous.multiVectorLexicalHitCases,
+      direction: buildTraceSummaryDirection(latest.multiVectorLexicalHitCases - previous.multiVectorLexicalHitCases),
+      metric: "multiVectorLexicalHitCases",
+      previous: previous.multiVectorLexicalHitCases
+    },
+    {
+      current: latest.multiVectorCollapsedCases,
+      delta: latest.multiVectorCollapsedCases - previous.multiVectorCollapsedCases,
+      direction: buildTraceSummaryDirection(latest.multiVectorCollapsedCases - previous.multiVectorCollapsedCases),
+      metric: "multiVectorCollapsedCases",
+      previous: previous.multiVectorCollapsedCases
     }
   ];
   const absoluteSorted = [...aggregate].sort((left, right) => Math.abs(right.delta) - Math.abs(left.delta) || left.metric.localeCompare(right.metric));
@@ -4697,6 +4784,10 @@ var summarizeRetrievalTraces = (traces) => {
   let roundRobinCases = 0;
   let transformedCases = 0;
   let variantCases = 0;
+  let multiVectorCases = 0;
+  let multiVectorVectorHitCases = 0;
+  let multiVectorLexicalHitCases = 0;
+  let multiVectorCollapsedCases = 0;
   let finalCountSum = 0;
   let vectorCountSum = 0;
   let lexicalCountSum = 0;
@@ -4723,6 +4814,18 @@ var summarizeRetrievalTraces = (traces) => {
     if (trace.variantQueries.length > 0) {
       variantCases += 1;
     }
+    if (trace.multiVector?.configured) {
+      multiVectorCases += 1;
+    }
+    if ((trace.multiVector?.vectorVariantHits ?? 0) > 0) {
+      multiVectorVectorHitCases += 1;
+    }
+    if ((trace.multiVector?.lexicalVariantHits ?? 0) > 0) {
+      multiVectorLexicalHitCases += 1;
+    }
+    if ((trace.multiVector?.collapsedParents ?? 0) > 0) {
+      multiVectorCollapsedCases += 1;
+    }
     finalCountSum += trace.resultCounts.final;
     vectorCountSum += trace.resultCounts.vector;
     lexicalCountSum += trace.resultCounts.lexical;
@@ -4744,6 +4847,10 @@ var summarizeRetrievalTraces = (traces) => {
     totalCases,
     transformedCases,
     variantCases,
+    multiVectorCases,
+    multiVectorVectorHitCases,
+    multiVectorLexicalHitCases,
+    multiVectorCollapsedCases,
     vectorCases
   };
 };
@@ -8326,13 +8433,19 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
   const delta = baselineEntry && candidateEntry ? {
     averageF1Delta: candidateEntry.response.summary.averageF1 - baselineEntry.response.summary.averageF1,
     elapsedMsDelta: candidateEntry.response.elapsedMs - baselineEntry.response.elapsedMs,
-    passingRateDelta: candidateEntry.response.passingRate - baselineEntry.response.passingRate
+    passingRateDelta: candidateEntry.response.passingRate - baselineEntry.response.passingRate,
+    multiVectorCollapsedCasesDelta: (candidateEntry.traceSummary?.multiVectorCollapsedCases ?? 0) - (baselineEntry.traceSummary?.multiVectorCollapsedCases ?? 0),
+    multiVectorLexicalHitCasesDelta: (candidateEntry.traceSummary?.multiVectorLexicalHitCases ?? 0) - (baselineEntry.traceSummary?.multiVectorLexicalHitCases ?? 0),
+    multiVectorVectorHitCasesDelta: (candidateEntry.traceSummary?.multiVectorVectorHitCases ?? 0) - (baselineEntry.traceSummary?.multiVectorVectorHitCases ?? 0)
   } : undefined;
   return {
     baseline: baselineEntry ? {
       averageF1: baselineEntry.response.summary.averageF1,
       elapsedMs: baselineEntry.response.elapsedMs,
       label: baselineEntry.label,
+      multiVectorCollapsedCases: baselineEntry.traceSummary?.multiVectorCollapsedCases,
+      multiVectorLexicalHitCases: baselineEntry.traceSummary?.multiVectorLexicalHitCases,
+      multiVectorVectorHitCases: baselineEntry.traceSummary?.multiVectorVectorHitCases,
       passingRate: baselineEntry.response.passingRate,
       retrievalId: baselineEntry.retrievalId
     } : undefined,
@@ -8341,6 +8454,9 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
       averageF1: candidateEntry.response.summary.averageF1,
       elapsedMs: candidateEntry.response.elapsedMs,
       label: candidateEntry.label,
+      multiVectorCollapsedCases: candidateEntry.traceSummary?.multiVectorCollapsedCases,
+      multiVectorLexicalHitCases: candidateEntry.traceSummary?.multiVectorLexicalHitCases,
+      multiVectorVectorHitCases: candidateEntry.traceSummary?.multiVectorVectorHitCases,
       passingRate: candidateEntry.response.passingRate,
       retrievalId: candidateEntry.retrievalId
     } : undefined,
@@ -8349,7 +8465,10 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
     fastest: comparison.summary.fastest,
     gate: evaluateRetrievalComparisonGate({ delta, policy }),
     winnerByAverageF1: comparison.summary.bestByAverageF1,
-    winnerByPassingRate: comparison.summary.bestByPassingRate
+    winnerByPassingRate: comparison.summary.bestByPassingRate,
+    winnerByMultivectorCollapsedCases: comparison.summary.bestByMultivectorCollapsedCases,
+    winnerByMultivectorLexicalHitCases: comparison.summary.bestByMultivectorLexicalHitCases,
+    winnerByMultivectorVectorHitCases: comparison.summary.bestByMultivectorVectorHitCases
   };
 };
 var loadRAGSearchTracePruneHistory = async ({
@@ -9011,6 +9130,32 @@ var summarizeEvaluationResponseComparison = (entries, idKey) => {
     fastest: getId(byLatency[0])
   };
 };
+var selectComparisonEntryByTraceMetric = (entries, idKey, metric) => {
+  const ranked = [...entries].sort((left, right) => {
+    const leftMetric = left.traceSummary?.[metric] ?? 0;
+    const rightMetric = right.traceSummary?.[metric] ?? 0;
+    if (rightMetric !== leftMetric) {
+      return rightMetric - leftMetric;
+    }
+    const leftEvidenceScore = (left.traceSummary?.multiVectorCollapsedCases ?? 0) + (left.traceSummary?.multiVectorLexicalHitCases ?? 0) + (left.traceSummary?.multiVectorVectorHitCases ?? 0);
+    const rightEvidenceScore = (right.traceSummary?.multiVectorCollapsedCases ?? 0) + (right.traceSummary?.multiVectorLexicalHitCases ?? 0) + (right.traceSummary?.multiVectorVectorHitCases ?? 0);
+    if (rightEvidenceScore !== leftEvidenceScore) {
+      return rightEvidenceScore - leftEvidenceScore;
+    }
+    if (right.response.passingRate !== left.response.passingRate) {
+      return right.response.passingRate - left.response.passingRate;
+    }
+    if (right.response.summary.averageF1 !== left.response.summary.averageF1) {
+      return right.response.summary.averageF1 - left.response.summary.averageF1;
+    }
+    return left.response.summary.averageLatencyMs - right.response.summary.averageLatencyMs;
+  });
+  const winner = ranked[0];
+  if (!winner || (winner.traceSummary?.[metric] ?? 0) === 0) {
+    return;
+  }
+  return typeof winner[idKey] === "string" ? winner[idKey] : undefined;
+};
 var resolveRetrievalMode = (candidate) => {
   if (!candidate.retrieval) {
     return "vector";
@@ -9100,7 +9245,11 @@ var compareRAGRetrievalTraceSummaries = (current, previous) => ({
   totalCasesDelta: current.totalCases - previous.totalCases,
   transformedCasesDelta: current.transformedCases - previous.transformedCases,
   vectorCasesDelta: current.vectorCases - previous.vectorCases,
-  variantCasesDelta: current.variantCases - previous.variantCases
+  variantCasesDelta: current.variantCases - previous.variantCases,
+  multiVectorCasesDelta: current.multiVectorCases - previous.multiVectorCases,
+  multiVectorVectorHitCasesDelta: current.multiVectorVectorHitCases - previous.multiVectorVectorHitCases,
+  multiVectorLexicalHitCasesDelta: current.multiVectorLexicalHitCases - previous.multiVectorLexicalHitCases,
+  multiVectorCollapsedCasesDelta: current.multiVectorCollapsedCases - previous.multiVectorCollapsedCases
 });
 var buildSearchTraceResultSnapshots = (results) => results.map((result) => ({
   chunkId: result.chunkId,
@@ -9665,7 +9814,12 @@ var summarizeRAGEvaluationCase = ({
 var summarizeRAGRerankerComparison = (entries) => {
   return summarizeEvaluationResponseComparison(entries, "rerankerId");
 };
-var summarizeRAGRetrievalComparison = (entries) => summarizeEvaluationResponseComparison(entries, "retrievalId");
+var summarizeRAGRetrievalComparison = (entries) => ({
+  ...summarizeEvaluationResponseComparison(entries, "retrievalId"),
+  bestByMultivectorCollapsedCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorCollapsedCases"),
+  bestByMultivectorLexicalHitCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorLexicalHitCases"),
+  bestByMultivectorVectorHitCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorVectorHitCases")
+});
 // src/ai/providers/openai.ts
 var DEFAULT_BASE_URL = "https://api.openai.com";
 var SSE_DATA_PREFIX_LENGTH = 6;
@@ -12780,6 +12934,43 @@ var scoreStructuredEvidenceMatch = (query, queryTokens, result) => {
   }
   return score;
 };
+var scoreMultivectorEvidenceMatch = (query, queryTokens, result) => {
+  const metadata = result.metadata ?? {};
+  const matchedVariantCount = typeof metadata.multivectorMatchedVariantCount === "number" ? metadata.multivectorMatchedVariantCount : 0;
+  const matchedVariantLabel = metadataString(metadata.multivectorMatchedVariantLabel);
+  const matchedVariantText = metadataString(metadata.multivectorMatchedVariantText);
+  if (matchedVariantCount === 0 && !matchedVariantLabel && !matchedVariantText) {
+    return 0;
+  }
+  let score = 0;
+  const exactPhraseIntent = queryHasAnyToken(queryTokens, [
+    "phrase",
+    "phrasing",
+    "wording",
+    "verbatim",
+    "quote",
+    "quoted",
+    "precise",
+    "exact"
+  ]);
+  if (matchedVariantCount > 0) {
+    score += Math.min(0.18, matchedVariantCount * 0.06);
+  }
+  if (matchedVariantLabel) {
+    score += 0.18 * scoreLoosePhraseMatch2(query, matchedVariantLabel);
+    if (exactPhraseIntent && queryTokens.some((token) => matchedVariantLabel.includes(token))) {
+      score += 0.08;
+    }
+  }
+  if (matchedVariantText) {
+    const phraseScore = scoreLoosePhraseMatch2(query, matchedVariantText);
+    score += exactPhraseIntent ? 1.1 * phraseScore : 0.6 * phraseScore;
+    if (queryHasQuotedPhraseMatch(query, matchedVariantText)) {
+      score += 0.45;
+    }
+  }
+  return score;
+};
 var scoreHeuristicMatch = ({
   query,
   queryTokens,
@@ -12797,7 +12988,8 @@ var scoreHeuristicMatch = ({
   const sourcePathBoost = typeof result.source === "string" && queryTokens.some((token) => result.source?.toLowerCase().includes(token)) ? 0.5 : 0;
   const metadataBoost = metadataValues.length > 0 ? queryTokens.filter((token) => metadataValues.some((value) => value.toLowerCase().includes(token))).length / queryTokens.length : 0;
   const structuredEvidenceBoost = scoreStructuredEvidenceMatch(query, queryTokens, result);
-  return result.score + overlapBoost + exactPhraseBoost + sourcePathBoost + metadataBoost + structuredEvidenceBoost;
+  const multivectorEvidenceBoost = scoreMultivectorEvidenceMatch(query, queryTokens, result);
+  return result.score + overlapBoost + exactPhraseBoost + sourcePathBoost + metadataBoost + structuredEvidenceBoost + multivectorEvidenceBoost;
 };
 var normalizeText = (value) => tokenize3(value).join(" ");
 var applyRAGReranking = async ({
@@ -16711,6 +16903,13 @@ var prepareRAGDirectoryDocuments = async (input) => prepareRAGDocuments(await lo
 
 // src/ai/rag/collection.ts
 var DEFAULT_TOP_K2 = 6;
+var MULTIVECTOR_VARIANT_CHUNK_DELIMITER = "__mv__";
+var MULTIVECTOR_PARENT_CHUNK_ID = "absoluteMultivectorParentChunkId";
+var MULTIVECTOR_VARIANT_ID = "absoluteMultivectorVariantId";
+var MULTIVECTOR_VARIANT_LABEL = "absoluteMultivectorVariantLabel";
+var MULTIVECTOR_VARIANT_TEXT = "absoluteMultivectorVariantText";
+var MULTIVECTOR_VARIANT_METADATA = "absoluteMultivectorVariantMetadata";
+var MULTIVECTOR_PRIMARY = "absoluteMultivectorPrimary";
 var resolveNativeQueryProfile = (input) => {
   if (!input.profile) {
     return;
@@ -16752,6 +16951,29 @@ var queryIncludesTraceCue = (query, value) => {
   const normalizedValue = normalizeTraceCueText(value);
   return normalizedQuery.length > 0 && normalizedValue.length > 0 && normalizedQuery.includes(normalizedValue);
 };
+var queryIncludesLooseTraceCue = (query, value) => {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return false;
+  }
+  const normalizedQuery = normalizeTraceCueText(query);
+  const normalizedValue = normalizeTraceCueText(value);
+  if (normalizedQuery.length === 0 || normalizedValue.length === 0) {
+    return false;
+  }
+  if (normalizedValue.includes(normalizedQuery)) {
+    return true;
+  }
+  const words = normalizedQuery.split(" ").filter(Boolean);
+  for (let size = Math.min(5, words.length);size >= 2; size -= 1) {
+    for (let index = 0;index <= words.length - size; index += 1) {
+      const phrase = words.slice(index, index + size).join(" ");
+      if (phrase.length > 0 && normalizedValue.includes(phrase)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
 var queryHasAnyTraceToken = (query, candidates) => {
   const normalizedQuery = normalizeTraceCueText(query);
   return candidates.some((candidate) => normalizedQuery.includes(normalizeTraceCueText(candidate)));
@@ -16803,6 +17025,33 @@ var buildMediaRerankTraceMetadata = (query, result) => {
   }
   return traceMetadata;
 };
+var buildMultivectorRerankTraceMetadata = (query, result) => {
+  if (!result?.metadata) {
+    return {};
+  }
+  const metadata = result.metadata;
+  const traceMetadata = {};
+  const matchedVariantId = typeof metadata.multivectorMatchedVariantId === "string" ? metadata.multivectorMatchedVariantId : undefined;
+  const matchedVariantLabel = typeof metadata.multivectorMatchedVariantLabel === "string" ? metadata.multivectorMatchedVariantLabel : undefined;
+  const matchedVariantText = typeof metadata.multivectorMatchedVariantText === "string" ? metadata.multivectorMatchedVariantText : undefined;
+  const matchedVariantCount = typeof metadata.multivectorMatchedVariantCount === "number" ? metadata.multivectorMatchedVariantCount : null;
+  if (!matchedVariantId && !matchedVariantLabel && !matchedVariantText) {
+    return {};
+  }
+  traceMetadata.leadMultivectorVariantCount = matchedVariantCount;
+  traceMetadata.leadMultivectorVariantId = matchedVariantId ?? null;
+  traceMetadata.leadMultivectorVariantLabel = matchedVariantLabel ?? null;
+  if (queryIncludesQuotedTraceCue(query, matchedVariantText)) {
+    traceMetadata.leadMultivectorVariantCue = "quoted_match";
+  } else if (queryIncludesLooseTraceCue(query, matchedVariantText) || queryIncludesTraceCue(query, matchedVariantText)) {
+    traceMetadata.leadMultivectorVariantCue = "phrase_match";
+  } else if (queryIncludesTraceCue(query, matchedVariantLabel)) {
+    traceMetadata.leadMultivectorVariantCue = "label_match";
+  } else {
+    traceMetadata.leadMultivectorVariantCue = "variant_match";
+  }
+  return traceMetadata;
+};
 var mergeQueryResults = (results) => {
   const merged = new Map;
   for (const result of results) {
@@ -16826,6 +17075,111 @@ var mergeQueryResults = (results) => {
     return left.chunkId.localeCompare(right.chunkId);
   });
 };
+var getMultivectorParentChunkId = (result) => typeof result.metadata?.[MULTIVECTOR_PARENT_CHUNK_ID] === "string" ? result.metadata[MULTIVECTOR_PARENT_CHUNK_ID] : undefined;
+var stripMultivectorInternalMetadata = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const cleaned = { ...metadata };
+  delete cleaned[MULTIVECTOR_PARENT_CHUNK_ID];
+  delete cleaned[MULTIVECTOR_VARIANT_ID];
+  delete cleaned[MULTIVECTOR_VARIANT_LABEL];
+  delete cleaned[MULTIVECTOR_VARIANT_TEXT];
+  delete cleaned[MULTIVECTOR_VARIANT_METADATA];
+  delete cleaned[MULTIVECTOR_PRIMARY];
+  return cleaned;
+};
+var collapseMultivectorResults = (results) => {
+  const grouped = new Map;
+  for (const result of results) {
+    const parentChunkId = getMultivectorParentChunkId(result) ?? result.chunkId;
+    const existing = grouped.get(parentChunkId);
+    const nextVariantHits = getMultivectorParentChunkId(result) ? 1 : 0;
+    if (existing) {
+      existing.results.push(result);
+      existing.variantHits += nextVariantHits;
+      continue;
+    }
+    grouped.set(parentChunkId, {
+      parentChunkId,
+      results: [result],
+      variantHits: nextVariantHits
+    });
+  }
+  let variantHits = 0;
+  let collapsedParents = 0;
+  const collapsed = [...grouped.values()].map((entry) => {
+    variantHits += entry.variantHits;
+    if (entry.variantHits > 0) {
+      collapsedParents += 1;
+    }
+    const preferred = entry.results.reduce((best, current) => current.score > best.score ? current : best);
+    const variantMatches = entry.results.map((result) => {
+      const variantId = result.metadata?.[MULTIVECTOR_VARIANT_ID];
+      if (typeof variantId !== "string") {
+        return;
+      }
+      return {
+        id: variantId,
+        label: typeof result.metadata?.[MULTIVECTOR_VARIANT_LABEL] === "string" ? String(result.metadata?.[MULTIVECTOR_VARIANT_LABEL]) : undefined,
+        text: typeof result.metadata?.[MULTIVECTOR_VARIANT_TEXT] === "string" ? String(result.metadata?.[MULTIVECTOR_VARIANT_TEXT]) : undefined,
+        score: result.score
+      };
+    }).filter((value) => value !== undefined).sort((left, right) => right.score - left.score);
+    const cleanedMetadata = stripMultivectorInternalMetadata(preferred.metadata);
+    return {
+      ...preferred,
+      chunkId: entry.parentChunkId,
+      metadata: {
+        ...cleanedMetadata ?? {},
+        multivectorMatchedVariantCount: variantMatches.length,
+        multivectorMatchedVariantId: variantMatches[0]?.id,
+        multivectorMatchedVariantLabel: variantMatches[0]?.label,
+        multivectorMatchedVariantText: variantMatches[0]?.text,
+        multivectorMatchedVariants: variantMatches.length > 0 ? variantMatches.map((match) => ({
+          id: match.id,
+          label: match.label,
+          text: match.text,
+          score: match.score
+        })) : undefined
+      }
+    };
+  }).sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.chunkId.localeCompare(right.chunkId);
+  });
+  return {
+    collapsed,
+    collapsedParents,
+    variantHits
+  };
+};
+var expandChunkForMultivectorStorage = (chunk) => {
+  const expanded = [{ ...chunk }];
+  for (const variant of chunk.embeddingVariants ?? []) {
+    if (!variant.id) {
+      continue;
+    }
+    expanded.push({
+      ...chunk,
+      chunkId: `${chunk.chunkId}${MULTIVECTOR_VARIANT_CHUNK_DELIMITER}${variant.id}`,
+      embedding: variant.embedding,
+      metadata: {
+        ...chunk.metadata ?? {},
+        [MULTIVECTOR_PARENT_CHUNK_ID]: chunk.chunkId,
+        [MULTIVECTOR_PRIMARY]: false,
+        [MULTIVECTOR_VARIANT_ID]: variant.id,
+        ...variant.label ? { [MULTIVECTOR_VARIANT_LABEL]: variant.label } : {},
+        ...variant.text ? { [MULTIVECTOR_VARIANT_TEXT]: variant.text } : {},
+        ...variant.metadata ? { [MULTIVECTOR_VARIANT_METADATA]: variant.metadata } : {}
+      },
+      text: variant.text ?? chunk.text
+    });
+  }
+  return expanded;
+};
 var getRAGSourceDiversityKey = (result) => {
   const documentId = typeof result.metadata?.documentId === "string" ? result.metadata.documentId : undefined;
   return result.source ?? documentId ?? result.title ?? result.chunkId;
@@ -17272,23 +17626,34 @@ var createRAGCollection = (options) => {
           topK: lexicalTopK
         }) ?? Promise.resolve([]) : Promise.resolve([])
       ]);
+      const annotatedLexicalResults = annotateRetrievalQueryOrigin({
+        inputQuery: input.query,
+        query,
+        queryIndex,
+        results: weightQueryResults(lexicalResults2, queryIndex),
+        transformedQuery: transformed.query
+      });
+      const annotatedVectorResults = annotateRetrievalQueryOrigin({
+        inputQuery: input.query,
+        query,
+        queryIndex,
+        results: weightQueryResults(vectorResults2, queryIndex),
+        transformedQuery: transformed.query
+      });
+      const collapsedLexicalResults = collapseMultivectorResults(annotatedLexicalResults);
+      const collapsedVectorResults = collapseMultivectorResults(annotatedVectorResults);
       return {
-        lexicalResults: annotateRetrievalQueryOrigin({
-          inputQuery: input.query,
-          query,
-          queryIndex,
-          results: weightQueryResults(lexicalResults2, queryIndex),
-          transformedQuery: transformed.query
-        }),
-        vectorResults: annotateRetrievalQueryOrigin({
-          inputQuery: input.query,
-          query,
-          queryIndex,
-          results: weightQueryResults(vectorResults2, queryIndex),
-          transformedQuery: transformed.query
-        })
+        lexicalResults: collapsedLexicalResults.collapsed,
+        lexicalVariantHits: collapsedLexicalResults.variantHits,
+        lexicalCollapsedParents: collapsedLexicalResults.collapsedParents,
+        vectorResults: collapsedVectorResults.collapsed,
+        vectorVariantHits: collapsedVectorResults.variantHits,
+        vectorCollapsedParents: collapsedVectorResults.collapsedParents
       };
     }));
+    const vectorVariantHits = resultGroups.reduce((total, group) => total + group.vectorVariantHits, 0);
+    const lexicalVariantHits = resultGroups.reduce((total, group) => total + group.lexicalVariantHits, 0);
+    const collapsedParents = resultGroups.reduce((total, group) => total + Math.max(group.vectorCollapsedParents, group.lexicalCollapsedParents), 0);
     const vectorResults = mergeQueryResults(resultGroups.flatMap((group) => group.vectorResults));
     if (runVector) {
       const vectorPlanMetadata = buildStoreQueryPlanTraceMetadata(options.store);
@@ -17296,6 +17661,8 @@ var createRAGCollection = (options) => {
         count: vectorResults.length,
         label: "Collected vector candidates",
         metadata: {
+          collapsedParents,
+          multiVectorVariantHits: vectorVariantHits,
           queryCount: searchQueries.length,
           topK: candidateTopK,
           ...vectorPlanMetadata
@@ -17311,6 +17678,8 @@ var createRAGCollection = (options) => {
         count: lexicalResults.length,
         label: "Collected lexical candidates",
         metadata: {
+          collapsedParents,
+          multiVectorVariantHits: lexicalVariantHits,
           queryCount: searchQueries.length,
           topK: lexicalTopK
         },
@@ -17356,7 +17725,8 @@ var createRAGCollection = (options) => {
       label: hasReranker ? "Reranked retrieval candidates" : "Skipped reranking and kept retrieval order",
       metadata: {
         applied: hasReranker,
-        ...buildMediaRerankTraceMetadata(transformed.query, reranked[0])
+        ...buildMediaRerankTraceMetadata(transformed.query, reranked[0]),
+        ...buildMultivectorRerankTraceMetadata(transformed.query, reranked[0])
       },
       sectionCounts: buildTraceSectionCounts(reranked),
       sectionScores: buildTraceSectionScores(reranked),
@@ -17419,6 +17789,12 @@ var createRAGCollection = (options) => {
           queryTransformLabel: transformed.label,
           queryTransformProvider: resolvedQueryTransform?.providerName,
           queryTransformReason: transformed.reason,
+          multiVector: {
+            collapsedParents,
+            configured: vectorVariantHits > 0 || lexicalVariantHits > 0,
+            lexicalVariantHits,
+            vectorVariantHits
+          },
           resultCounts: {
             final: limited.length,
             fused: results.length,
@@ -17475,6 +17851,12 @@ var createRAGCollection = (options) => {
         queryTransformLabel: transformed.label,
         queryTransformProvider: resolvedQueryTransform?.providerName,
         queryTransformReason: transformed.reason,
+        multiVector: {
+          collapsedParents,
+          configured: vectorVariantHits > 0 || lexicalVariantHits > 0,
+          lexicalVariantHits,
+          vectorVariantHits
+        },
         resultCounts: {
           final: filtered.length,
           fused: results.length,
@@ -17502,19 +17884,31 @@ var createRAGCollection = (options) => {
     return result.results;
   };
   const ingest = async (input) => {
-    const chunks = await Promise.all(input.chunks.map(async (chunk) => {
-      if (chunk.embedding) {
-        validateRAGEmbeddingDimensions(chunk.embedding, getExpectedDimensions(), "chunk");
-        return chunk;
-      }
-      return {
-        ...chunk,
-        embedding: await embed({
+    const chunks = (await Promise.all(input.chunks.map(async (chunk) => {
+      const normalizedEmbedding = chunk.embedding ? (validateRAGEmbeddingDimensions(chunk.embedding, getExpectedDimensions(), "chunk"), chunk.embedding) : await embed({
+        model: options.defaultModel,
+        text: chunk.text
+      }, "chunk");
+      const normalizedVariants = chunk.embeddingVariants ? await Promise.all(chunk.embeddingVariants.map(async (variant) => {
+        const embedding = variant.embedding ? (validateRAGEmbeddingDimensions(variant.embedding, getExpectedDimensions(), "chunk"), variant.embedding) : await embed({
           model: options.defaultModel,
-          text: chunk.text
-        }, "chunk")
-      };
-    }));
+          text: variant.text ?? chunk.text
+        }, "chunk");
+        return {
+          ...variant,
+          embedding
+        };
+      })) : undefined;
+      return expandChunkForMultivectorStorage({
+        ...chunk,
+        embedding: normalizedEmbedding,
+        embeddingVariants: normalizedVariants,
+        metadata: {
+          ...chunk.metadata ?? {},
+          [MULTIVECTOR_PRIMARY]: true
+        }
+      });
+    }))).flat();
     await options.store.upsert({ chunks });
   };
   return {
@@ -17723,11 +18117,25 @@ var renderMaintenancePanel = (input) => {
   const route = input.path ? `${input.path}/status/maintenance` : undefined;
   return route ? `<div id="rag-status-maintenance-panel" hx-get="${escapeHtml2(route)}" hx-trigger="load, rag:mutated from:body" hx-swap="outerHTML">${content}</div>` : `<div id="rag-status-maintenance-panel">${content}</div>`;
 };
+var renderRetrievalGovernancePanel = (retrievalComparisons) => {
+  if (!retrievalComparisons?.latest && !retrievalComparisons?.alerts?.length) {
+    return "";
+  }
+  const latest = retrievalComparisons.latest;
+  const alerts = (retrievalComparisons.alerts ?? []).slice(0, 3);
+  const releaseGroups = (retrievalComparisons.releaseGroups ?? []).slice(0, 2);
+  const formatClassification = (classification) => classification === "multivector" ? "multivector regression" : classification === "general" ? "general regression" : undefined;
+  return `<section class="rag-status-governance"><h3>Retrieval governance</h3>` + (latest ? `<dl class="rag-status">` + `<div><dt>Latest comparison</dt><dd>${escapeHtml2(latest.label)}</dd></div>` + (latest.bestByPassingRate ? `<div><dt>Best passing rate</dt><dd>${escapeHtml2(latest.bestByPassingRate)}</dd></div>` : "") + (latest.bestByAverageF1 ? `<div><dt>Best average F1</dt><dd>${escapeHtml2(latest.bestByAverageF1)}</dd></div>` : "") + (latest.bestByMultivectorCollapsedCases ? `<div><dt>Best multivector collapse</dt><dd>${escapeHtml2(latest.bestByMultivectorCollapsedCases)}</dd></div>` : "") + (latest.bestByMultivectorLexicalHitCases ? `<div><dt>Best multivector lexical hits</dt><dd>${escapeHtml2(latest.bestByMultivectorLexicalHitCases)}</dd></div>` : "") + (latest.bestByMultivectorVectorHitCases ? `<div><dt>Best multivector vector hits</dt><dd>${escapeHtml2(latest.bestByMultivectorVectorHitCases)}</dd></div>` : "") + (latest.decisionSummary?.gate?.status ? `<div><dt>Gate</dt><dd>${escapeHtml2(latest.decisionSummary.gate.status)}</dd></div>` : "") + (latest.releaseVerdict?.status ? `<div><dt>Verdict</dt><dd>${escapeHtml2(latest.releaseVerdict.status)}</dd></div>` : "") + `</dl>` : "") + `<h4>Active alerts</h4>` + (alerts.length > 0 ? `<ul class="rag-status-capabilities">${alerts.map((alert) => `<li><strong>${escapeHtml2(alert.kind)}</strong>${formatClassification(alert.classification) ? ` <span>${escapeHtml2(formatClassification(alert.classification) ?? "")}</span>` : ""} ${escapeHtml2(alert.message)}</li>`).join("")}</ul>` : `<p class="rag-empty">No active retrieval comparison alerts.</p>`) + (releaseGroups.length > 0 ? `<h4>Release groups</h4><ul class="rag-status-capabilities">${releaseGroups.map((group) => {
+    const reasons = group.recommendedActionReasons?.slice(0, 2).join("; ") ?? "No recommended action.";
+    return `<li><strong>${escapeHtml2(group.groupKey)}</strong>${formatClassification(group.classification) ? ` <span>${escapeHtml2(formatClassification(group.classification) ?? "")}</span>` : ""} ${escapeHtml2(group.recommendedAction ?? "monitor")} \xB7 ${escapeHtml2(reasons)}</li>`;
+  }).join("")}</ul>` : "") + `</section>`;
+};
 var defaultStatus = ({
   admin,
   adminActions,
   adminJobs,
   maintenance,
+  retrievalComparisons,
   path,
   status,
   capabilities,
@@ -17736,7 +18144,7 @@ var defaultStatus = ({
   if (!status) {
     return renderEmptyState("status");
   }
-  return `<section class="rag-status-panel">` + `<dl class="rag-status">` + `<div><dt>Backend</dt><dd>${escapeHtml2(status.backend)}</dd></div>` + `<div><dt>Vector mode</dt><dd>${escapeHtml2(status.vectorMode)}</dd></div>` + `<div><dt>Embedding dimensions</dt><dd>${status.dimensions ?? "n/a"}</dd></div>` + `<div><dt>Vector acceleration</dt><dd>${status.native?.active ? "active" : "inactive"}</dd></div>` + `<div><dt>Documents</dt><dd>${documents?.total ?? "n/a"}</dd></div>` + `<div><dt>Total chunks</dt><dd>${documents?.chunkCount ?? "n/a"}</dd></div>` + `<div><dt>Seed docs</dt><dd>${documents?.byKind.seed ?? 0}</dd></div>` + `<div><dt>Custom docs</dt><dd>${documents?.byKind.custom ?? 0}</dd></div>` + `</dl>${renderPostgresNativeStatus(status)}${renderSQLiteNativeStatus(status)}${renderMaintenancePanel({
+  return `<section class="rag-status-panel">` + `<dl class="rag-status">` + `<div><dt>Backend</dt><dd>${escapeHtml2(status.backend)}</dd></div>` + `<div><dt>Vector mode</dt><dd>${escapeHtml2(status.vectorMode)}</dd></div>` + `<div><dt>Embedding dimensions</dt><dd>${status.dimensions ?? "n/a"}</dd></div>` + `<div><dt>Vector acceleration</dt><dd>${status.native?.active ? "active" : "inactive"}</dd></div>` + `<div><dt>Documents</dt><dd>${documents?.total ?? "n/a"}</dd></div>` + `<div><dt>Total chunks</dt><dd>${documents?.chunkCount ?? "n/a"}</dd></div>` + `<div><dt>Seed docs</dt><dd>${documents?.byKind.seed ?? 0}</dd></div>` + `<div><dt>Custom docs</dt><dd>${documents?.byKind.custom ?? 0}</dd></div>` + `</dl>${renderPostgresNativeStatus(status)}${renderSQLiteNativeStatus(status)}${renderRetrievalGovernancePanel(retrievalComparisons)}${renderMaintenancePanel({
     admin,
     adminActions,
     adminJobs,
@@ -18233,6 +18641,20 @@ var parseRAGRetrieval = (value) => {
   return retrieval;
 };
 var getNumericStatus = (status) => typeof status === "number" ? status : HTTP_STATUS_OK;
+var classifyGovernanceReasons = (reasons) => (reasons ?? []).some((reason) => reason.toLowerCase().includes("multivector")) ? "multivector" : "general";
+var buildRegressionRemediationLabel = (classification) => classification === "multivector" ? "Inspect multivector coverage deltas, variant-hit traces, and collapsed-parent recovery before promotion." : "Inspect the latest retrieval comparison deltas and resolve the gate failure before promotion.";
+var summarizeIncidentClassifications = (incidents) => {
+  const allIncidents = incidents ?? [];
+  const countBy = (status, classification) => allIncidents.filter((entry) => entry.status === status && (entry.classification ?? "general") === classification).length;
+  return {
+    openGeneralCount: countBy("open", "general"),
+    openMultiVectorCount: countBy("open", "multivector"),
+    resolvedGeneralCount: countBy("resolved", "general"),
+    resolvedMultiVectorCount: countBy("resolved", "multivector"),
+    totalGeneralCount: allIncidents.filter((entry) => (entry.classification ?? "general") === "general").length,
+    totalMultiVectorCount: allIncidents.filter((entry) => (entry.classification ?? "general") === "multivector").length
+  };
+};
 var getBooleanProperty = (value, key) => {
   if (!isObjectRecord2(value)) {
     return;
@@ -19944,6 +20366,7 @@ var ragChat = (config) => {
       return existing.find((entry) => entry.groupKey === groupKey && typeof entry.corpusGroupKey === "string")?.corpusGroupKey ?? comparisonRunCorpusGroups.find((entry) => entry.groupKey === groupKey && typeof entry.corpusGroupKey === "string")?.corpusGroupKey ?? baselineCorpusGroups.find((entry) => entry.groupKey === groupKey && typeof entry.corpusGroupKey === "string")?.corpusGroupKey ?? releaseDecisionCorpusGroups.find((entry) => entry.groupKey === groupKey && typeof entry.corpusGroupKey === "string")?.corpusGroupKey;
     };
     const nextByKey = new Map;
+    const classifyPromotionIncident = (reasons) => (reasons ?? []).some((reason) => reason.toLowerCase().includes("multivector")) ? "multivector" : "general";
     for (const candidate of input.promotionCandidates) {
       if (!candidate.groupKey || !candidate.targetRolloutLabel) {
         continue;
@@ -19961,6 +20384,7 @@ var ragChat = (config) => {
         id: key,
         kind,
         message: candidate.reasons[0] ?? candidate.sortReason ?? "release action required",
+        classification: classifyPromotionIncident(candidate.reasons),
         severity: getRetrievalReleaseIncidentSeverity(candidate.targetRolloutLabel),
         sourceRunId: candidate.sourceRunId,
         status: "open",
@@ -20135,7 +20559,7 @@ var ragChat = (config) => {
           actions.add("Renew or record the required approval for this rollout lane.");
         }
         if (reason.includes("gate") || reason.includes("passing rate") || reason.includes("average")) {
-          actions.add("Inspect the latest retrieval comparison deltas and resolve the gate failure before promotion.");
+          actions.add(buildRegressionRemediationLabel(classifyGovernanceReasons([reason])));
         }
         if (reason.includes("source comparison run was not found")) {
           actions.add("Re-run the comparison so the rollout action has a valid source run.");
@@ -20168,7 +20592,7 @@ var ragChat = (config) => {
         if (reason.includes("gate") || reason.includes("passing rate") || reason.includes("average")) {
           steps.push({
             kind: "inspect_gate",
-            label: "Inspect the latest retrieval comparison deltas and resolve the gate failure before promotion.",
+            label: buildRegressionRemediationLabel(classifyGovernanceReasons([reason])),
             actions: buildRemediationStepActions({
               candidateRetrievalId: input.retrievalId,
               groupKey: input.groupKey,
@@ -20225,6 +20649,7 @@ var ragChat = (config) => {
     const base = {
       baselineRetrievalId,
       candidateRetrievalId: input.retrievalId,
+      classification: input.baseline ? "general" : undefined,
       effectiveBaselineGatePolicy: targetRolloutLabel || input.groupKey ? getDefaultRetrievalBaselineGatePolicy(input.groupKey, targetRolloutLabel) : undefined,
       effectiveReleasePolicy: getRetrievalReleasePolicy(input.groupKey, targetRolloutLabel),
       groupKey: input.groupKey,
@@ -20281,6 +20706,7 @@ var ragChat = (config) => {
     if (!sourceRun) {
       return {
         ...base,
+        classification: "general",
         reasons: [
           "source comparison run was not found for this rollout action"
         ],
@@ -20316,6 +20742,7 @@ var ragChat = (config) => {
     return {
       baselineRetrievalId: state.baselineRetrievalId ?? baselineRetrievalId,
       candidateRetrievalId: state.candidateRetrievalId ?? input.retrievalId,
+      classification: classifyGovernanceReasons(state.reasons),
       effectiveBaselineGatePolicy: state.effectiveBaselineGatePolicy,
       effectiveReleasePolicy: state.effectiveReleasePolicy,
       gateStatus: state.gateStatus,
@@ -21775,13 +22202,15 @@ var ragChat = (config) => {
   };
   const handleRetrievalReleaseIncidentStatus = async (request) => {
     const ops = await buildOperationsPayload(request);
+    const recentIncidents = ops.retrievalComparisons?.recentIncidents;
     return {
+      incidentClassificationSummary: summarizeIncidentClassifications(recentIncidents),
       incidentRemediationExecutionSummary: ops.retrievalComparisons?.incidentRemediationExecutionSummary,
       incidentSummary: ops.retrievalComparisons?.incidentSummary,
       ok: true,
       recentIncidentRemediationDecisions: ops.retrievalComparisons?.recentIncidentRemediationDecisions,
       recentIncidentRemediationExecutions: ops.retrievalComparisons?.recentIncidentRemediationExecutions,
-      recentIncidents: ops.retrievalComparisons?.recentIncidents,
+      recentIncidents,
       recentReleaseLaneEscalationPolicyHistory: ops.retrievalComparisons?.recentReleaseLaneEscalationPolicyHistory,
       releaseLaneIncidentSummaries: ops.retrievalComparisons?.releaseLaneIncidentSummaries
     };
@@ -21811,6 +22240,7 @@ var ragChat = (config) => {
   const handleRetrievalIncidentRemediationStatus = async (request) => {
     const ops = await buildOperationsPayload(request);
     return {
+      incidentClassificationSummary: summarizeIncidentClassifications(ops.retrievalComparisons?.recentIncidents),
       incidentRemediationExecutionSummary: ops.retrievalComparisons?.incidentRemediationExecutionSummary,
       ok: true,
       recentIncidentRemediationExecutions: ops.retrievalComparisons?.recentIncidentRemediationExecutions
@@ -23037,8 +23467,9 @@ var ragChat = (config) => {
         ];
         const recommendedActionReasons = (() => {
           if (groupCandidates.some((entry) => entry.priority === "gate_fail")) {
+            const gateFailReason = groupCandidates.find((entry) => entry.priority === "gate_fail" && entry.reasons[0])?.reasons[0];
             return [
-              "candidate regressed or failed the active gate and should be investigated"
+              gateFailReason ?? "candidate regressed or failed the active gate and should be investigated"
             ];
           }
           if (groupCandidates.some((entry) => entry.reviewStatus === "needs_review")) {
@@ -23056,6 +23487,11 @@ var ragChat = (config) => {
           }
           return ["continue monitoring release state"];
         })();
+        const classification = classifyGovernanceReasons([
+          ...blockedReasons,
+          ...actionRequiredReasons,
+          ...recommendedActionReasons
+        ]);
         const recommendedAction = groupCandidates.some((entry) => entry.priority === "gate_fail") ? "investigate_regression" : groupCandidates.some((entry) => entry.reviewStatus === "needs_review") ? "renew_approval" : groupCandidates.some((entry) => entry.requiresApproval && entry.approved !== true && entry.reviewStatus === "blocked") ? "await_approval" : groupCandidates.some((entry) => entry.ready) ? "promote_candidate" : "monitor";
         const escalationSeverity = groupCandidates.some((entry) => entry.priority === "gate_fail") ? "critical" : groupCandidates.some((entry) => entry.reviewStatus === "needs_review" || entry.priority === "gate_warn") ? "warning" : actionRequiredReasons.length > 0 ? "info" : "none";
         return {
@@ -23068,6 +23504,7 @@ var ragChat = (config) => {
           approvalMaxAgeMs: getRetrievalReleasePolicy(groupKey).approvalMaxAgeMs,
           approvalRequired: getRetrievalReleasePolicy(groupKey).requireApprovalBeforePromotion === true,
           blockedReasons,
+          classification,
           corpusGroupKey: getComparisonCorpusGroupKey(groupKey),
           escalationSeverity,
           groupKey,
@@ -23089,6 +23526,7 @@ var ragChat = (config) => {
       return {
         ...group,
         acknowledgedOpenIncidentCount,
+        classification: groupOpenIncidents.some((entry) => entry.classification === "multivector") ? "multivector" : group.classification,
         openIncidentCount: groupOpenIncidents.length,
         unacknowledgedOpenIncidentCount: groupOpenIncidents.length - acknowledgedOpenIncidentCount
       };
@@ -23296,9 +23734,11 @@ var ragChat = (config) => {
           ] : candidate?.ready ? [
             "latest candidate is ready to promote"
           ] : ["continue monitoring release state"];
+          const classification = candidate?.reasons?.length ? classifyGovernanceReasons(candidate.reasons) : (recentIncidents ?? []).some((entry) => entry.groupKey === group.groupKey && entry.targetRolloutLabel === targetRolloutLabel && entry.classification === "multivector") ? "multivector" : "general";
           summaries.push({
             baselineRetrievalId: candidate?.baselineRetrievalId,
             candidateRetrievalId: candidate?.candidateRetrievalId,
+            classification,
             effectiveBaselineGatePolicy: candidate?.effectiveBaselineGatePolicy,
             effectiveReleasePolicy: candidate?.effectiveReleasePolicy,
             gateStatus: candidate?.gateStatus,
@@ -23306,10 +23746,12 @@ var ragChat = (config) => {
             ready: candidate?.ready ?? false,
             recommendedAction,
             recommendedActionReasons,
-            remediationActions: [...recommendedActionReasons],
+            remediationActions: recommendedAction === "investigate_regression" ? [
+              buildRegressionRemediationLabel(classification)
+            ] : [...recommendedActionReasons],
             remediationSteps: recommendedActionReasons.map((label) => ({
               kind: recommendedAction === "renew_approval" ? "renew_approval" : recommendedAction === "await_approval" ? "record_approval" : recommendedAction === "investigate_regression" ? "inspect_gate" : recommendedAction === "promote_candidate" ? "monitor_lane" : "review_readiness",
-              label,
+              label: recommendedAction === "investigate_regression" ? buildRegressionRemediationLabel(classification) : label,
               actions: buildRemediationStepActions({
                 candidateRetrievalId: candidate?.candidateRetrievalId,
                 groupKey: group.groupKey,
@@ -23752,6 +24194,7 @@ var ragChat = (config) => {
       if (!latestRetrievalComparisonRun) {
         return alerts;
       }
+      const classifyRetrievalRegression = (input) => (input.reasons ?? []).some((reason) => reason.toLowerCase().includes("multivector")) || typeof input.delta?.multiVectorCollapsedCasesDelta === "number" || typeof input.delta?.multiVectorLexicalHitCasesDelta === "number" || typeof input.delta?.multiVectorVectorHitCasesDelta === "number" ? "multivector" : "general";
       const latestWinner = latestRetrievalComparisonRun.comparison.summary.bestByPassingRate;
       if (latestWinner && stableWinnerByPassingRate?.retrievalId && stableWinnerByPassingRate.retrievalId !== latestWinner) {
         alerts.push({
@@ -23777,11 +24220,13 @@ var ragChat = (config) => {
           kind: "baseline_regression",
           latestRunId: latestRetrievalComparisonRun.id,
           message: "Candidate retrieval regressed against the baseline on the latest persisted comparison run.",
+          classification: classifyRetrievalRegression({ delta }),
           severity: "warning",
           tag: latestRetrievalComparisonRun.tags?.[0]
         });
       }
       if (gate && gate.status !== "pass") {
+        const gateReasonText = gate.reasons.length > 0 ? ` ${gate.reasons.join("; ")}` : "";
         alerts.push({
           baselineRetrievalId: latestRetrievalComparisonRun.decisionSummary?.baselineRetrievalId,
           candidateRetrievalId: latestRetrievalComparisonRun.decisionSummary?.candidateRetrievalId,
@@ -23791,7 +24236,11 @@ var ragChat = (config) => {
           groupKey: latestRetrievalComparisonRun.groupKey,
           kind: "baseline_gate_failed",
           latestRunId: latestRetrievalComparisonRun.id,
-          message: gate.status === "warn" ? "Candidate retrieval triggered a baseline gate warning." : "Candidate retrieval failed the active baseline gate.",
+          message: gate.status === "warn" ? `Candidate retrieval triggered a baseline gate warning.${gateReasonText}` : `Candidate retrieval failed the active baseline gate.${gateReasonText}`,
+          classification: classifyRetrievalRegression({
+            delta,
+            reasons: gate.reasons
+          }),
           severity: gate.status === "warn" ? "warning" : "warning",
           tag: latestRetrievalComparisonRun.tags?.[0]
         });
@@ -23925,6 +24374,9 @@ var ragChat = (config) => {
         configured: Boolean(retrievalComparisonHistoryStore),
         latest: latestRetrievalComparisonRun ? {
           bestByAverageF1: latestRetrievalComparisonRun.comparison.summary.bestByAverageF1,
+          bestByMultivectorCollapsedCases: latestRetrievalComparisonRun.comparison.summary.bestByMultivectorCollapsedCases,
+          bestByMultivectorLexicalHitCases: latestRetrievalComparisonRun.comparison.summary.bestByMultivectorLexicalHitCases,
+          bestByMultivectorVectorHitCases: latestRetrievalComparisonRun.comparison.summary.bestByMultivectorVectorHitCases,
           bestByPassingRate: latestRetrievalComparisonRun.comparison.summary.bestByPassingRate,
           corpusGroupKey: latestRetrievalComparisonRun.corpusGroupKey,
           elapsedMs: latestRetrievalComparisonRun.elapsedMs,
@@ -25437,6 +25889,7 @@ var ragChat = (config) => {
         capabilities: result.capabilities,
         documents: result.documents,
         maintenance: result.maintenance,
+        retrievalComparisons: result.retrievalComparisons,
         path,
         status: result.status
       }));
@@ -25545,6 +25998,7 @@ var ragChat = (config) => {
         capabilities: result.capabilities,
         documents: result.documents,
         maintenance: result.maintenance,
+        retrievalComparisons: result.retrievalComparisons,
         path,
         status: result.status
       }));
@@ -25919,6 +26373,28 @@ var createRAGHTMXWorkflowRenderConfig = (config) => config;
 // src/ai/rag/retrievalStrategies.ts
 var tokenize4 = (value) => value.toLowerCase().split(/[^a-z0-9]+/i).map((token) => token.trim()).filter((token) => token.length > 0);
 var hasAnyToken2 = (tokens, values) => values.some((value) => tokens.includes(value));
+var buildSelectorMetadata = (selector, extra = {}) => ({
+  selector,
+  ...extra
+});
+var countLongTokens = (tokens) => tokens.filter((token) => token.length >= 5).length;
+var hasExactPhraseIntent = (tokens) => {
+  const exactPhraseCue = hasAnyToken2(tokens, [
+    "phrase",
+    "phrasing",
+    "wording",
+    "verbatim",
+    "quoted",
+    "quote",
+    "snippet",
+    "precise",
+    "exact"
+  ]);
+  if (!exactPhraseCue) {
+    return false;
+  }
+  return tokens.length >= 6 || countLongTokens(tokens) >= 4;
+};
 var createHeuristicRAGRetrievalStrategy = (options = {}) => ({
   defaultLabel: options.defaultLabel ?? "Heuristic retrieval routing",
   providerName: options.providerName ?? "heuristic_retrieval_strategy",
@@ -25930,24 +26406,32 @@ var createHeuristicRAGRetrievalStrategy = (options = {}) => ({
         label: "Scoped direct route",
         mode: "vector",
         reason: scopedDocumentId ? "documentId filter narrows retrieval to one target document" : "source filter narrows retrieval to one source family",
-        metadata: {
-          selector: "scoped_direct_route"
-        }
+        metadata: buildSelectorMetadata("scoped_direct_route")
       };
     }
     const tokens = tokenize4(input.query);
     const transformedTokens = tokenize4(input.transformedQuery);
     const combined = Array.from(new Set([...tokens, ...transformedTokens]));
     const hasVariants = input.variantQueries.length > 0;
+    const exactPhraseHybrid = !hasVariants && hasExactPhraseIntent(combined);
     const supportLexical = hasAnyToken2(combined, ["faq", "policy", "password", "billing"]) && !hasVariants;
     if (supportLexical) {
       return {
         label: "Support lexical route",
         mode: "lexical",
         reason: "faq/support phrase matched",
-        metadata: {
-          selector: "support_lexical"
-        }
+        metadata: buildSelectorMetadata("support_lexical")
+      };
+    }
+    if (exactPhraseHybrid && input.retrieval.mode === "vector") {
+      return {
+        label: "Exact phrase hybrid route",
+        mode: "hybrid",
+        lexicalTopK: Math.max(input.topK, Math.floor(input.retrieval.lexicalTopK ?? input.candidateTopK)),
+        reason: "exact sub-span wording benefits from lexical evidence",
+        metadata: buildSelectorMetadata("exact_phrase_hybrid", {
+          exactPhraseIntent: true
+        })
       };
     }
     const sourceNativeHybrid = hasVariants || hasAnyToken2(combined, [
@@ -25966,9 +26450,7 @@ var createHeuristicRAGRetrievalStrategy = (options = {}) => ({
         mode: "hybrid",
         lexicalTopK: Math.max(input.topK, Math.floor(input.retrieval.lexicalTopK ?? input.candidateTopK)),
         reason: hasVariants ? "query expansion introduced source-native variants" : "source-native terminology benefits from hybrid retrieval",
-        metadata: {
-          selector: "source_native_hybrid"
-        }
+        metadata: buildSelectorMetadata("source_native_hybrid")
       };
     }
     return;
@@ -33909,5 +34391,5 @@ export {
   addRAGEvaluationSuiteCase
 };
 
-//# debugId=27461AB67370F55164756E2164756E21
+//# debugId=E1F755AF5BA36E2664756E2164756E21
 //# sourceMappingURL=index.js.map