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

package/dist/ai/rag/quality.js

@@ -2957,6 +2957,18 @@ var buildComparisonOverviewPresentation = (input) => {
       value: input.resolveLabel(input.summary.bestByMultivectorVectorHitCases)
     });
   }
+  if (input.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases) {
+    rows.push({
+      label: "Lowest runtime budget exhaustion",
+      value: input.resolveLabel(input.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases)
+    });
+  }
+  if (input.summary.bestByLowestRuntimeUnderfilledTopKCases) {
+    rows.push({
+      label: "Lowest runtime underfilled TopK",
+      value: input.resolveLabel(input.summary.bestByLowestRuntimeUnderfilledTopKCases)
+    });
+  }
   return {
     rows,
     winnerLabel,
@@ -3009,6 +3021,9 @@ var buildRAGComparisonTraceSummaryRows = (entry) => {
   }, {
     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: "Runtime",
+    value: `budget ${formatTraceRatio(trace.runtimeCandidateBudgetExhaustedCases, trace.totalCases)} \xB7 underfilled ${formatTraceRatio(trace.runtimeUnderfilledTopKCases, trace.totalCases)}`
   }, {
     label: "TopK",
     value: `${trace.averageCandidateTopK.toFixed(1)} / ${trace.averageLexicalTopK.toFixed(1)}`
@@ -3113,6 +3128,12 @@ var buildRAGComparisonTraceDiffRows = (entry, leader) => {
   }, {
     label: "Round robin delta",
     value: formatTraceCountDelta(trace.roundRobinCases - leaderTrace.roundRobinCases)
+  }, {
+    label: "Runtime budget delta",
+    value: formatTraceCountDelta(trace.runtimeCandidateBudgetExhaustedCases - leaderTrace.runtimeCandidateBudgetExhaustedCases)
+  }, {
+    label: "Runtime underfilled delta",
+    value: formatTraceCountDelta(trace.runtimeUnderfilledTopKCases - leaderTrace.runtimeUnderfilledTopKCases)
   });
   if (stageDelta) {
     rows.push({ label: "Stage delta", value: stageDelta });
@@ -3564,6 +3585,77 @@ var buildRAGEvaluationSuiteSnapshotHistoryPresentation = (history) => ({
   snapshots: buildRAGEvaluationSuiteSnapshotPresentations(history),
   summary: history?.latestSnapshot ? `v${history.latestSnapshot.version}` : "No saved suite snapshots yet."
 });
+var isRuntimeGateReason = (reason) => /runtime|candidate-budget|underfilled/i.test(reason);
+var buildRAGRetrievalReleaseHistoryRunPresentation = (run) => {
+  const runtimeGateReasons = (run.decisionSummary?.gate?.reasons ?? run.releaseVerdict?.gate?.reasons ?? []).filter(isRuntimeGateReason);
+  const rows = [
+    { label: "Finished", value: formatDateLabel(run.finishedAt) },
+    {
+      label: "Passing-rate winner",
+      value: run.comparison.summary.bestByPassingRate ?? "n/a"
+    },
+    {
+      label: "Average F1 winner",
+      value: run.comparison.summary.bestByAverageF1 ?? "n/a"
+    }
+  ];
+  if (run.comparison.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases) {
+    rows.push({
+      label: "Lowest runtime budget exhaustion",
+      value: run.comparison.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases
+    });
+  }
+  if (run.comparison.summary.bestByLowestRuntimeUnderfilledTopKCases) {
+    rows.push({
+      label: "Lowest runtime underfilled TopK",
+      value: run.comparison.summary.bestByLowestRuntimeUnderfilledTopKCases
+    });
+  }
+  rows.push({
+    label: "Gate status",
+    value: run.decisionSummary?.gate?.status ?? run.releaseVerdict?.gate?.status ?? "n/a"
+  }, {
+    label: "Runtime gate failures",
+    value: runtimeGateReasons.length > 0 ? runtimeGateReasons.join("; ") : "none"
+  });
+  return {
+    label: run.label,
+    rows,
+    runId: run.id,
+    summary: runtimeGateReasons.length > 0 ? `${run.label} \xB7 runtime gate blocked` : `${run.label} \xB7 ${run.comparison.summary.bestByPassingRate ?? "n/a"} leads passing rate`
+  };
+};
+var buildRAGRetrievalReleaseGroupHistoryPresentation = (input) => {
+  const recentRuns = (input.runs ?? []).map(buildRAGRetrievalReleaseHistoryRunPresentation);
+  const runtimeBlockedRuns = recentRuns.filter((entry) => entry.rows.some((row) => row.label === "Runtime gate failures" && row.value !== "none")).length;
+  const rows = [
+    {
+      label: "Latest decision",
+      value: input.timeline?.latestDecisionKind ?? "none"
+    },
+    {
+      label: "Latest decision at",
+      value: formatDateLabel(input.timeline?.latestDecisionAt)
+    },
+    {
+      label: "Last promoted",
+      value: formatDateLabel(input.timeline?.lastPromotedAt)
+    },
+    {
+      label: "Last reverted",
+      value: formatDateLabel(input.timeline?.lastRevertedAt)
+    },
+    {
+      label: "Recent runtime-blocked runs",
+      value: String(runtimeBlockedRuns)
+    }
+  ];
+  return {
+    recentRuns,
+    rows,
+    summary: input.timeline?.latestDecisionKind ? `${input.timeline.latestDecisionKind} \xB7 ${recentRuns.length} recent runs` : recentRuns.length > 0 ? `${recentRuns.length} recent runs` : "No release history yet."
+  };
+};
 var buildRAGAnswerGroundingCaseSnapshotPresentations = (history) => {
   if (!history?.caseSnapshots.length) {
     return [];
@@ -4074,6 +4166,12 @@ var evaluateRetrievalComparisonGate = ({
   if (typeof policy.minMultiVectorVectorHitCasesDelta === "number" && (delta.multiVectorVectorHitCasesDelta ?? 0) < policy.minMultiVectorVectorHitCasesDelta) {
     reasons.push(`multivector vector-hit delta ${delta.multiVectorVectorHitCasesDelta ?? 0} is below ${policy.minMultiVectorVectorHitCasesDelta}`);
   }
+  if (typeof policy.maxRuntimeCandidateBudgetExhaustedCasesDelta === "number" && (delta.runtimeCandidateBudgetExhaustedCasesDelta ?? 0) > policy.maxRuntimeCandidateBudgetExhaustedCasesDelta) {
+    reasons.push(`runtime candidate-budget-exhausted delta ${delta.runtimeCandidateBudgetExhaustedCasesDelta ?? 0} exceeds ${policy.maxRuntimeCandidateBudgetExhaustedCasesDelta}`);
+  }
+  if (typeof policy.maxRuntimeUnderfilledTopKCasesDelta === "number" && (delta.runtimeUnderfilledTopKCasesDelta ?? 0) > policy.maxRuntimeUnderfilledTopKCasesDelta) {
+    reasons.push(`runtime underfilled-topk delta ${delta.runtimeUnderfilledTopKCasesDelta ?? 0} exceeds ${policy.maxRuntimeUnderfilledTopKCasesDelta}`);
+  }
   if (reasons.length === 0) {
     return {
       policy,
@@ -4604,6 +4702,20 @@ var buildTraceSummaryAggregate = ({
         direction: "flat",
         metric: "multiVectorCollapsedCases",
         previous: 0
+      },
+      {
+        current: 0,
+        delta: 0,
+        direction: "flat",
+        metric: "runtimeCandidateBudgetExhaustedCases",
+        previous: 0
+      },
+      {
+        current: 0,
+        delta: 0,
+        direction: "flat",
+        metric: "runtimeUnderfilledTopKCases",
+        previous: 0
       }
     ];
     return {
@@ -4726,6 +4838,20 @@ var buildTraceSummaryAggregate = ({
       direction: buildTraceSummaryDirection(latest.multiVectorCollapsedCases - previous.multiVectorCollapsedCases),
       metric: "multiVectorCollapsedCases",
       previous: previous.multiVectorCollapsedCases
+    },
+    {
+      current: latest.runtimeCandidateBudgetExhaustedCases,
+      delta: latest.runtimeCandidateBudgetExhaustedCases - previous.runtimeCandidateBudgetExhaustedCases,
+      direction: buildTraceSummaryDirection(latest.runtimeCandidateBudgetExhaustedCases - previous.runtimeCandidateBudgetExhaustedCases),
+      metric: "runtimeCandidateBudgetExhaustedCases",
+      previous: previous.runtimeCandidateBudgetExhaustedCases
+    },
+    {
+      current: latest.runtimeUnderfilledTopKCases,
+      delta: latest.runtimeUnderfilledTopKCases - previous.runtimeUnderfilledTopKCases,
+      direction: buildTraceSummaryDirection(latest.runtimeUnderfilledTopKCases - previous.runtimeUnderfilledTopKCases),
+      metric: "runtimeUnderfilledTopKCases",
+      previous: previous.runtimeUnderfilledTopKCases
     }
   ];
   const absoluteSorted = [...aggregate].sort((left, right) => Math.abs(right.delta) - Math.abs(left.delta) || left.metric.localeCompare(right.metric));
@@ -4780,12 +4906,15 @@ var summarizeRetrievalTraces = (traces) => {
   let multiVectorVectorHitCases = 0;
   let multiVectorLexicalHitCases = 0;
   let multiVectorCollapsedCases = 0;
+  let runtimeCandidateBudgetExhaustedCases = 0;
+  let runtimeUnderfilledTopKCases = 0;
   let finalCountSum = 0;
   let vectorCountSum = 0;
   let lexicalCountSum = 0;
   let candidateTopKSum = 0;
   let lexicalTopKSum = 0;
   for (const trace of traces) {
+    const vectorSearchMetadata = trace.steps.find((step) => step.stage === "vector_search")?.metadata;
     modeSet.add(trace.mode);
     sourceBalanceStrategySet.add(trace.sourceBalanceStrategy ?? "cap");
     if (trace.runVector) {
@@ -4818,6 +4947,18 @@ var summarizeRetrievalTraces = (traces) => {
     if ((trace.multiVector?.collapsedParents ?? 0) > 0) {
       multiVectorCollapsedCases += 1;
     }
+    if (vectorSearchMetadata?.sqliteQueryCandidateBudgetExhausted) {
+      runtimeCandidateBudgetExhaustedCases += 1;
+    }
+    if (vectorSearchMetadata?.postgresQueryCandidateBudgetExhausted) {
+      runtimeCandidateBudgetExhaustedCases += 1;
+    }
+    if (vectorSearchMetadata?.sqliteQueryUnderfilledTopK) {
+      runtimeUnderfilledTopKCases += 1;
+    }
+    if (vectorSearchMetadata?.postgresQueryUnderfilledTopK) {
+      runtimeUnderfilledTopKCases += 1;
+    }
     finalCountSum += trace.resultCounts.final;
     vectorCountSum += trace.resultCounts.vector;
     lexicalCountSum += trace.resultCounts.lexical;
@@ -4843,6 +4984,8 @@ var summarizeRetrievalTraces = (traces) => {
     multiVectorVectorHitCases,
     multiVectorLexicalHitCases,
     multiVectorCollapsedCases,
+    runtimeCandidateBudgetExhaustedCases,
+    runtimeUnderfilledTopKCases,
     vectorCases
   };
 };
@@ -8428,7 +8571,9 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
     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)
+    multiVectorVectorHitCasesDelta: (candidateEntry.traceSummary?.multiVectorVectorHitCases ?? 0) - (baselineEntry.traceSummary?.multiVectorVectorHitCases ?? 0),
+    runtimeCandidateBudgetExhaustedCasesDelta: (candidateEntry.traceSummary?.runtimeCandidateBudgetExhaustedCases ?? 0) - (baselineEntry.traceSummary?.runtimeCandidateBudgetExhaustedCases ?? 0),
+    runtimeUnderfilledTopKCasesDelta: (candidateEntry.traceSummary?.runtimeUnderfilledTopKCases ?? 0) - (baselineEntry.traceSummary?.runtimeUnderfilledTopKCases ?? 0)
   } : undefined;
   return {
     baseline: baselineEntry ? {
@@ -8438,6 +8583,8 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
       multiVectorCollapsedCases: baselineEntry.traceSummary?.multiVectorCollapsedCases,
       multiVectorLexicalHitCases: baselineEntry.traceSummary?.multiVectorLexicalHitCases,
       multiVectorVectorHitCases: baselineEntry.traceSummary?.multiVectorVectorHitCases,
+      runtimeCandidateBudgetExhaustedCases: baselineEntry.traceSummary?.runtimeCandidateBudgetExhaustedCases,
+      runtimeUnderfilledTopKCases: baselineEntry.traceSummary?.runtimeUnderfilledTopKCases,
       passingRate: baselineEntry.response.passingRate,
       retrievalId: baselineEntry.retrievalId
     } : undefined,
@@ -8449,6 +8596,8 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
       multiVectorCollapsedCases: candidateEntry.traceSummary?.multiVectorCollapsedCases,
       multiVectorLexicalHitCases: candidateEntry.traceSummary?.multiVectorLexicalHitCases,
       multiVectorVectorHitCases: candidateEntry.traceSummary?.multiVectorVectorHitCases,
+      runtimeCandidateBudgetExhaustedCases: candidateEntry.traceSummary?.runtimeCandidateBudgetExhaustedCases,
+      runtimeUnderfilledTopKCases: candidateEntry.traceSummary?.runtimeUnderfilledTopKCases,
       passingRate: candidateEntry.response.passingRate,
       retrievalId: candidateEntry.retrievalId
     } : undefined,
@@ -8460,7 +8609,9 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
     winnerByPassingRate: comparison.summary.bestByPassingRate,
     winnerByMultivectorCollapsedCases: comparison.summary.bestByMultivectorCollapsedCases,
     winnerByMultivectorLexicalHitCases: comparison.summary.bestByMultivectorLexicalHitCases,
-    winnerByMultivectorVectorHitCases: comparison.summary.bestByMultivectorVectorHitCases
+    winnerByMultivectorVectorHitCases: comparison.summary.bestByMultivectorVectorHitCases,
+    winnerByLowestRuntimeCandidateBudgetExhaustedCases: comparison.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases,
+    winnerByLowestRuntimeUnderfilledTopKCases: comparison.summary.bestByLowestRuntimeUnderfilledTopKCases
   };
 };
 var loadRAGSearchTracePruneHistory = async ({
@@ -9148,6 +9299,24 @@ var selectComparisonEntryByTraceMetric = (entries, idKey, metric) => {
   }
   return typeof winner[idKey] === "string" ? winner[idKey] : undefined;
 };
+var selectComparisonEntryByLowestTraceMetric = (entries, idKey, metric) => {
+  const ranked = [...entries].sort((left, right) => {
+    const leftMetric = left.traceSummary?.[metric] ?? 0;
+    const rightMetric = right.traceSummary?.[metric] ?? 0;
+    if (leftMetric !== rightMetric) {
+      return leftMetric - rightMetric;
+    }
+    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];
+  return typeof winner?.[idKey] === "string" ? winner[idKey] : undefined;
+};
 var resolveRetrievalMode = (candidate) => {
   if (!candidate.retrieval) {
     return "vector";
@@ -9241,7 +9410,9 @@ var compareRAGRetrievalTraceSummaries = (current, previous) => ({
   multiVectorCasesDelta: current.multiVectorCases - previous.multiVectorCases,
   multiVectorVectorHitCasesDelta: current.multiVectorVectorHitCases - previous.multiVectorVectorHitCases,
   multiVectorLexicalHitCasesDelta: current.multiVectorLexicalHitCases - previous.multiVectorLexicalHitCases,
-  multiVectorCollapsedCasesDelta: current.multiVectorCollapsedCases - previous.multiVectorCollapsedCases
+  multiVectorCollapsedCasesDelta: current.multiVectorCollapsedCases - previous.multiVectorCollapsedCases,
+  runtimeCandidateBudgetExhaustedCasesDelta: current.runtimeCandidateBudgetExhaustedCases - previous.runtimeCandidateBudgetExhaustedCases,
+  runtimeUnderfilledTopKCasesDelta: current.runtimeUnderfilledTopKCases - previous.runtimeUnderfilledTopKCases
 });
 var buildSearchTraceResultSnapshots = (results) => results.map((result) => ({
   chunkId: result.chunkId,
@@ -9603,6 +9774,63 @@ var generateRAGEvaluationSuiteFromDocuments = ({
     metadata
   });
 };
+var DEFAULT_NATIVE_PLANNER_BENCHMARK_SUITE_ID = "rag-native-planner-larger-corpus";
+var DEFAULT_NATIVE_PLANNER_BENCHMARK_LABEL = "Adaptive Native Planner Benchmark";
+var DEFAULT_NATIVE_PLANNER_BENCHMARK_QUERY = "Which launch checklist phrase is exact wording?";
+var DEFAULT_NATIVE_PLANNER_BENCHMARK_FILTER = {
+  lane: "focus"
+};
+var createRAGAdaptiveNativePlannerBenchmarkSuite = (input) => createRAGEvaluationSuite({
+  description: input?.description ?? "Stress-tests larger-corpus native planner selection, candidate-budget pressure, and transformed-query recovery on filtered retrieval.",
+  id: input?.id ?? DEFAULT_NATIVE_PLANNER_BENCHMARK_SUITE_ID,
+  input: {
+    cases: [
+      {
+        expectedDocumentIds: ["focus-target"],
+        filter: { ...DEFAULT_NATIVE_PLANNER_BENCHMARK_FILTER },
+        hardNegativeDocumentIds: [
+          "focus-distractor-0",
+          "focus-distractor-1",
+          "focus-distractor-2"
+        ],
+        id: "planner-pressure-exact-phrase",
+        label: "Exact phrase survives larger-corpus native pressure",
+        query: DEFAULT_NATIVE_PLANNER_BENCHMARK_QUERY,
+        topK: input?.topK ?? 1
+      }
+    ],
+    filter: { ...DEFAULT_NATIVE_PLANNER_BENCHMARK_FILTER },
+    retrieval: "vector",
+    topK: input?.topK ?? 1
+  },
+  label: input?.label ?? DEFAULT_NATIVE_PLANNER_BENCHMARK_LABEL,
+  metadata: {
+    benchmarkKind: "adaptive_native_planner",
+    benchmarkScope: "larger_corpus",
+    expectedSignals: [
+      "selected native planner profile",
+      "candidate-budget exhaustion",
+      "underfilled topk"
+    ],
+    recommendedGroupKey: "runtime-native-planner",
+    recommendedTags: ["runtime", "native", "planner"],
+    ...input?.metadata
+  }
+});
+var createRAGAdaptiveNativePlannerBenchmarkSnapshot = (input) => {
+  const suite = input?.suite ?? createRAGAdaptiveNativePlannerBenchmarkSuite();
+  return createRAGEvaluationSuiteSnapshot({
+    createdAt: input?.createdAt,
+    id: input?.id,
+    metadata: {
+      artifactKind: "adaptive_native_planner_benchmark",
+      persistForReleaseHistory: true,
+      ...input?.metadata
+    },
+    suite,
+    version: input?.version
+  });
+};
 var createRAGEvaluationSuiteSnapshot = ({
   suite,
   id,
@@ -9810,7 +10038,9 @@ var summarizeRAGRetrievalComparison = (entries) => ({
   ...summarizeEvaluationResponseComparison(entries, "retrievalId"),
   bestByMultivectorCollapsedCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorCollapsedCases"),
   bestByMultivectorLexicalHitCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorLexicalHitCases"),
-  bestByMultivectorVectorHitCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorVectorHitCases")
+  bestByMultivectorVectorHitCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorVectorHitCases"),
+  bestByLowestRuntimeCandidateBudgetExhaustedCases: selectComparisonEntryByLowestTraceMetric(entries, "retrievalId", "runtimeCandidateBudgetExhaustedCases"),
+  bestByLowestRuntimeUnderfilledTopKCases: selectComparisonEntryByLowestTraceMetric(entries, "retrievalId", "runtimeUnderfilledTopKCases")
 });
 export {
   updateRAGEvaluationSuiteCase,
@@ -9911,6 +10141,8 @@ export {
   createRAGFileAnswerGroundingCaseDifficultyHistoryStore,
   createRAGEvaluationSuiteSnapshot,
   createRAGEvaluationSuite,
+  createRAGAdaptiveNativePlannerBenchmarkSuite,
+  createRAGAdaptiveNativePlannerBenchmarkSnapshot,
   compareRAGRetrievalTraceSummaries,
   compareRAGRetrievalStrategies,
   compareRAGRerankers,
@@ -9935,5 +10167,5 @@ export {
   addRAGEvaluationSuiteCase
 };
 
-//# debugId=BC6237465C42931C64756E2164756E21
+//# debugId=31297D55AFFF65BE64756E2164756E21
 //# sourceMappingURL=quality.js.map