@absolutejs/absolute 0.19.0-beta.623 → 0.19.0-beta.625

package/dist/ai/rag/quality.js

@@ -653,10 +653,3046 @@ var buildRAGGroundingReferences = (sources) => {
   });
 };
 
+// src/ai/rag/presentation.ts
+var buildSourceGroupKey = (source) => source.source ?? source.title ?? source.chunkId;
+var buildSourceLabel2 = (source) => source.source ?? source.title ?? source.chunkId;
+var getContextNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var getContextString2 = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+var isRAGRetrievalTrace = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.query === "string" && typeof candidate.transformedQuery === "string" && Array.isArray(candidate.variantQueries) && Array.isArray(candidate.steps);
+};
+var formatTimestampLabel2 = (value) => {
+  const timestamp = typeof value === "number" && Number.isFinite(value) ? value : typeof value === "string" ? Date.parse(value) : Number.NaN;
+  if (!Number.isFinite(timestamp)) {
+    return;
+  }
+  return new Date(timestamp).toLocaleString("en-US", {
+    dateStyle: "medium",
+    timeStyle: "short"
+  });
+};
+var formatRAGTraceValue = (value) => {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.join(", ");
+  }
+  if (value && typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return "n/a";
+};
+var formatLeadContinuityCue = (value) => {
+  const cue = getContextString2(value);
+  switch (cue) {
+    case "immediate_follow_up":
+      return "Immediate follow-up";
+    case "near_follow_up":
+      return "Near follow-up";
+    case "close_follow_up":
+      return "Close follow-up";
+    case "delayed_follow_up":
+      return "Delayed follow-up";
+    case "immediate_prior":
+      return "Immediate prior segment";
+    case "near_prior":
+      return "Near prior segment";
+    case "close_prior":
+      return "Close prior segment";
+    case "delayed_prior":
+      return "Delayed prior segment";
+    default:
+      return;
+  }
+};
+var formatLeadSpeakerAttributionCue = (value) => {
+  const cue = getContextString2(value);
+  switch (cue) {
+    case "quoted_match":
+      return "Quoted speaker match";
+    default:
+      return;
+  }
+};
+var formatLeadChannelAttributionCue = (value) => {
+  const cue = getContextString2(value);
+  switch (cue) {
+    case "quoted_match":
+      return "Quoted channel match";
+    default:
+      return;
+  }
+};
+var formatLeadMediaCueSummary = (input) => {
+  const parts = [
+    input?.leadSpeakerCue ? `speaker ${input.leadSpeakerCue}` : undefined,
+    input?.leadSpeakerAttributionCue === "quoted_match" ? "quoted speaker match" : undefined,
+    input?.leadChannelCue ? `channel ${input.leadChannelCue}` : undefined,
+    input?.leadChannelAttributionCue === "quoted_match" ? "quoted channel match" : undefined,
+    formatLeadContinuityCue(input?.leadContinuityCue)
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  return parts.length > 0 ? parts.join(" \xB7 ") : "none";
+};
+var formatRAGTraceMetadataRow = (key, value) => ({
+  label: key === "sqliteQueryMode" ? "SQLite query mode" : key === "sqliteQueryPushdownApplied" ? "SQLite pushdown applied" : key === "sqliteQueryPushdownClauseCount" ? "SQLite pushdown clauses" : key === "sqliteQueryFilteredCandidates" ? "SQLite filtered candidates" : key === "sqliteQueryInitialSearchK" ? "SQLite initial searchK" : key === "sqliteQueryFinalSearchK" ? "SQLite final searchK" : key === "sqliteQueryBackfillCount" ? "SQLite backfill count" : key === "leadSpeakerCue" ? "Lead speaker cue" : key === "leadSpeakerAttributionCue" ? "Lead speaker attribution" : key === "leadChannelAttributionCue" ? "Lead channel attribution" : key === "leadChannelCue" ? "Lead channel cue" : key === "leadContinuityCue" ? "Lead continuity cue" : key,
+  value: key === "sourceAwareChunkReason" ? formatSourceAwareChunkReason(value) ?? formatRAGTraceValue(value) : key === "leadSpeakerAttributionCue" ? formatLeadSpeakerAttributionCue(value) ?? formatRAGTraceValue(value) : key === "leadChannelAttributionCue" ? formatLeadChannelAttributionCue(value) ?? formatRAGTraceValue(value) : key === "leadContinuityCue" ? formatLeadContinuityCue(value) ?? formatRAGTraceValue(value) : formatRAGTraceValue(value)
+});
+var buildRAGRetrievalTracePresentation = (trace) => {
+  if (!trace) {
+    return {
+      details: [],
+      stats: [],
+      steps: []
+    };
+  }
+  const stats = [
+    { label: "Mode", value: trace.mode },
+    { label: "Final Results", value: String(trace.resultCounts.final) },
+    {
+      label: "Vector Candidates",
+      value: String(trace.resultCounts.vector)
+    },
+    {
+      label: "Lexical Candidates",
+      value: String(trace.resultCounts.lexical)
+    }
+  ];
+  const details = [
+    { label: "Transformed query", value: trace.transformedQuery },
+    ...trace.queryTransformLabel || trace.queryTransformProvider ? [
+      {
+        label: "Query transform",
+        value: trace.queryTransformLabel ?? trace.queryTransformProvider ?? "configured"
+      },
+      ...trace.queryTransformReason ? [
+        {
+          label: "Query transform reason",
+          value: trace.queryTransformReason
+        }
+      ] : []
+    ] : [],
+    {
+      label: "Variant queries",
+      value: trace.variantQueries.length > 0 ? trace.variantQueries.join(" \xB7 ") : "none"
+    },
+    ...trace.requestedMode && trace.requestedMode !== trace.mode ? [{ label: "Requested mode", value: trace.requestedMode }] : [],
+    ...trace.routingLabel || trace.routingProvider ? [
+      {
+        label: "Routing decision",
+        value: trace.routingLabel ?? trace.routingProvider ?? "configured"
+      },
+      ...trace.routingReason ? [
+        {
+          label: "Routing reason",
+          value: trace.routingReason
+        }
+      ] : []
+    ] : [],
+    { label: "Candidate topK", value: String(trace.candidateTopK) },
+    { label: "Lexical topK", value: String(trace.lexicalTopK) }
+  ];
+  const steps = trace.steps.map((step) => ({
+    count: step.count,
+    label: step.label,
+    rows: [
+      { label: "stage", value: step.stage },
+      ...typeof step.count === "number" ? [{ label: "count", value: String(step.count) }] : [],
+      ...typeof step.durationMs === "number" ? [{ label: "durationMs", value: String(step.durationMs) }] : [],
+      ...Object.entries(step.metadata ?? {}).map(([key, value]) => formatRAGTraceMetadataRow(key, value))
+    ],
+    stage: step.stage
+  }));
+  return {
+    details,
+    stats,
+    steps
+  };
+};
+var formatCompactList = (values) => values && values.length > 0 ? values.join(", ") : "none";
+var formatCoverageMap = (entries) => {
+  if (!entries) {
+    return "none";
+  }
+  const values = Object.entries(entries);
+  return values.length > 0 ? values.map(([key, value]) => `${key} ${value}`).join(" \xB7 ") : "none";
+};
+var formatDurationLabel = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return "n/a";
+  }
+  if (value < 1000) {
+    return `${value}ms`;
+  }
+  if (value < 60000) {
+    return `${(value / 1000).toFixed(value >= 1e4 ? 0 : 1)}s`;
+  }
+  if (value < 3600000) {
+    return `${(value / 60000).toFixed(value >= 600000 ? 0 : 1)}m`;
+  }
+  return `${(value / 3600000).toFixed(value >= 36000000 ? 0 : 1)}h`;
+};
+var formatDateLabel = (value) => typeof value === "number" && Number.isFinite(value) ? new Date(value).toLocaleString("en-US") : "n/a";
+var formatAgeLabel = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return "n/a";
+  }
+  if (value < 1000) {
+    return `${Math.round(value)}ms`;
+  }
+  if (value < 60000) {
+    return `${(value / 1000).toFixed(value >= 1e4 ? 0 : 1)}s`;
+  }
+  if (value < 3600000) {
+    return `${(value / 60000).toFixed(value >= 600000 ? 0 : 1)}m`;
+  }
+  if (value < 86400000) {
+    return `${(value / 3600000).toFixed(value >= 36000000 ? 0 : 1)}h`;
+  }
+  return `${(value / 86400000).toFixed(value >= 864000000 ? 0 : 1)}d`;
+};
+var formatSourceAwareChunkReason = (value) => {
+  const reason = getContextString2(value);
+  if (reason === "section_boundary") {
+    return "Chunk boundary section";
+  }
+  if (reason === "size_limit") {
+    return "Chunk boundary size limit";
+  }
+  if (reason === "source_native_unit") {
+    return "Chunk boundary source-native unit";
+  }
+  return;
+};
+var buildSourceAwareUnitScopeLabel = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const sectionKind = getContextString2(metadata.sectionKind);
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getContextString2(metadata.sectionTitle) ?? sectionPath.at(-1);
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const officeBlockKind = getContextString2(metadata.officeBlockKind);
+  const sheetName = getContextString2(metadata.sheetName);
+  const spreadsheetTableLabel = formatSpreadsheetTableLabel(getContextNumber2(metadata.spreadsheetTableIndex), getContextNumber2(metadata.spreadsheetTableCount));
+  const slideTitle = getContextString2(metadata.slideTitle);
+  const slideNumber = getContextNumber2(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : undefined);
+  if (sectionPath.length > 0 && (sectionKind === "markdown_heading" || sectionKind === "html_heading" || sectionKind === "office_heading" || sectionKind === undefined)) {
+    return `Source-aware section ${sectionPath.join(" > ")}`;
+  }
+  if (sectionKind === "pdf_block") {
+    if (pdfTextKind === "table_like" && sectionTitle) {
+      return `Source-aware PDF table block ${sectionTitle}`;
+    }
+    if (sectionTitle) {
+      return `Source-aware PDF block ${sectionTitle}`;
+    }
+    return "Source-aware PDF block";
+  }
+  if (sectionKind === "office_block") {
+    if (officeBlockKind && sectionTitle) {
+      return `Source-aware office ${officeBlockKind} block ${sectionTitle}`;
+    }
+    if (sectionTitle) {
+      return `Source-aware office block ${sectionTitle}`;
+    }
+    return "Source-aware office block";
+  }
+  if (sectionKind === "spreadsheet_rows" || sectionKind === undefined && (sheetName || spreadsheetTableLabel || getContextNumber2(metadata.spreadsheetRowStart) !== undefined || getContextNumber2(metadata.spreadsheetRowEnd) !== undefined)) {
+    if (sheetName && spreadsheetTableLabel) {
+      return `Source-aware spreadsheet ${sheetName} ${spreadsheetTableLabel}`;
+    }
+    if (sheetName) {
+      return `Source-aware spreadsheet ${sheetName}`;
+    }
+    return "Source-aware spreadsheet";
+  }
+  if (sectionKind === "presentation_slide") {
+    if (slideNumber && slideTitle) {
+      return `Source-aware slide ${slideNumber} ${slideTitle}`;
+    }
+    if (slideTitle) {
+      return `Source-aware slide ${slideTitle}`;
+    }
+    if (slideNumber) {
+      return `Source-aware slide ${slideNumber}`;
+    }
+    return "Source-aware slide";
+  }
+  return;
+};
+var buildSyncOverviewLatestRow = (sources) => {
+  const latest = [...sources].filter((record) => typeof record.lastSuccessfulSyncAt === "number" || typeof record.lastSyncedAt === "number").sort((left, right) => (right.lastSuccessfulSyncAt ?? right.lastSyncedAt ?? 0) - (left.lastSuccessfulSyncAt ?? left.lastSyncedAt ?? 0))[0];
+  if (!latest) {
+    return {
+      label: "Latest sync",
+      value: "No completed run yet"
+    };
+  }
+  return {
+    label: "Latest sync",
+    value: [
+      latest.label,
+      typeof latest.documentCount === "number" ? `${latest.documentCount} docs` : "",
+      typeof latest.chunkCount === "number" ? `${latest.chunkCount} chunks` : "",
+      typeof latest.lastSyncDurationMs === "number" ? formatDurationLabel(latest.lastSyncDurationMs) : "",
+      typeof latest.lastSuccessfulSyncAt === "number" ? formatDateLabel(latest.lastSuccessfulSyncAt) : typeof latest.lastSyncedAt === "number" ? formatDateLabel(latest.lastSyncedAt) : ""
+    ].filter(Boolean).join(" \xB7 ")
+  };
+};
+var formatAdminActionLabel = (value) => value.replaceAll("_", " ");
+var buildAdminTimingLabel = (input) => typeof input.elapsedMs === "number" ? formatDurationLabel(input.elapsedMs) : formatDateLabel(input.startedAt);
+var buildRAGAdminJobPresentation = (job) => ({
+  id: job.id,
+  action: job.action,
+  status: job.status,
+  summary: [
+    job.status.toUpperCase(),
+    formatAdminActionLabel(job.action),
+    job.target,
+    buildAdminTimingLabel(job)
+  ].filter(Boolean).join(" \xB7 "),
+  rows: [
+    { label: "Action", value: formatAdminActionLabel(job.action) },
+    { label: "Status", value: job.status },
+    ...job.target ? [{ label: "Target", value: job.target }] : [],
+    { label: "Timing", value: buildAdminTimingLabel(job) },
+    ...job.error ? [{ label: "Error", value: job.error }] : []
+  ]
+});
+var buildRAGAdminJobPresentations = (jobs) => (jobs ?? []).slice(0, 3).map(buildRAGAdminJobPresentation);
+var buildRAGAdminActionPresentation = (action) => ({
+  id: action.id,
+  action: action.action,
+  status: action.status,
+  summary: [
+    action.status.toUpperCase(),
+    formatAdminActionLabel(action.action),
+    action.documentId ?? action.target,
+    buildAdminTimingLabel(action)
+  ].filter(Boolean).join(" \xB7 "),
+  rows: [
+    { label: "Action", value: formatAdminActionLabel(action.action) },
+    { label: "Status", value: action.status },
+    ...action.documentId ? [{ label: "Document", value: action.documentId }] : action.target ? [{ label: "Target", value: action.target }] : [],
+    { label: "Timing", value: buildAdminTimingLabel(action) },
+    ...action.error ? [{ label: "Error", value: action.error }] : []
+  ]
+});
+var buildRAGAdminActionPresentations = (actions) => (actions ?? []).slice(0, 3).map(buildRAGAdminActionPresentation);
+var buildRAGSyncSourceRunPresentations = (source) => {
+  if (!Array.isArray(source.metadata?.recentRuns)) {
+    return [];
+  }
+  return source.metadata.recentRuns.slice(0, 3).map((entry, index) => {
+    const trigger = typeof entry.trigger === "string" ? entry.trigger : "sync";
+    const status = typeof entry.status === "string" ? entry.status : "unknown";
+    const finishedAt = typeof entry.finishedAt === "number" ? formatDateLabel(entry.finishedAt) : "n/a";
+    const duration = typeof entry.durationMs === "number" ? formatDurationLabel(entry.durationMs) : "n/a";
+    const docs = typeof entry.documentCount === "number" ? `${entry.documentCount} docs` : "n/a";
+    const chunks = typeof entry.chunkCount === "number" ? `${entry.chunkCount} chunks` : "n/a";
+    const error = typeof entry.error === "string" && entry.error.length > 0 ? entry.error : undefined;
+    return {
+      label: `Run ${index + 1}`,
+      status,
+      summary: `${trigger} \xB7 ${status} \xB7 ${docs} \xB7 ${chunks} \xB7 ${duration} \xB7 ${finishedAt}`,
+      rows: [
+        { label: "Trigger", value: trigger },
+        { label: "Status", value: status },
+        { label: "Output", value: `${docs} \xB7 ${chunks}` },
+        { label: "Duration", value: duration },
+        { label: "Finished", value: finishedAt },
+        ...error ? [{ label: "Error", value: error }] : []
+      ]
+    };
+  });
+};
+var buildRAGSyncSourcePresentation = (source) => {
+  const provider = typeof source.metadata?.provider === "string" ? source.metadata.provider : undefined;
+  const accountMode = typeof source.metadata?.accountMode === "string" ? source.metadata.accountMode : undefined;
+  const schedule = typeof source.metadata?.schedule === "string" ? source.metadata.schedule : undefined;
+  const lastTrigger = typeof source.metadata?.lastTrigger === "string" ? source.metadata.lastTrigger : undefined;
+  const liveReady = typeof source.metadata?.liveReady === "string" ? source.metadata.liveReady : undefined;
+  const diagnosticSummary = source.diagnostics?.summary;
+  const diagnosticTags = source.diagnostics?.entries.map((entry) => entry.code.replace(/_/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase())) ?? [];
+  const retryGuidance = source.diagnostics?.retryGuidance;
+  return {
+    id: source.id,
+    label: source.label,
+    kind: source.kind,
+    status: source.status,
+    summary: [
+      source.kind,
+      source.status,
+      typeof source.documentCount === "number" ? `${source.documentCount} docs` : "",
+      typeof source.chunkCount === "number" ? `${source.chunkCount} chunks` : "",
+      typeof source.lastSyncDurationMs === "number" ? formatDurationLabel(source.lastSyncDurationMs) : "",
+      typeof source.lastSuccessfulSyncAt === "number" ? `last success ${formatDateLabel(source.lastSuccessfulSyncAt)}` : typeof source.lastSyncedAt === "number" ? `last sync ${formatDateLabel(source.lastSyncedAt)}` : ""
+    ].filter(Boolean).join(" \xB7 "),
+    rows: [
+      ...source.target ? [{ label: "Target", value: source.target }] : [],
+      ...provider ? [{ label: "Provider", value: provider }] : [],
+      ...accountMode ? [{ label: "Account mode", value: accountMode }] : [],
+      ...schedule ? [{ label: "Schedule", value: schedule }] : [],
+      ...lastTrigger ? [{ label: "Last trigger", value: lastTrigger }] : [],
+      ...typeof source.lastSuccessfulSyncAt === "number" ? [
+        {
+          label: "Last success",
+          value: formatDateLabel(source.lastSuccessfulSyncAt)
+        }
+      ] : [],
+      ...typeof source.nextRetryAt === "number" ? [
+        {
+          label: "Next retry",
+          value: formatDateLabel(source.nextRetryAt)
+        }
+      ] : [],
+      ...source.lastError ? [{ label: "Last error", value: source.lastError }] : [],
+      ...diagnosticSummary ? [{ label: "Diagnostics", value: diagnosticSummary }] : [],
+      ...retryGuidance ? [{ label: "Retry guidance", value: retryGuidance.reason }] : []
+    ],
+    tags: [
+      provider,
+      accountMode ? `mode ${accountMode}` : undefined,
+      liveReady,
+      ...diagnosticTags
+    ].filter((value) => Boolean(value)),
+    extendedSummary: diagnosticSummary ?? source.description ?? liveReady,
+    runs: buildRAGSyncSourceRunPresentations(source)
+  };
+};
+var buildRAGSyncSourcePresentations = (sources) => (sources ?? []).map(buildRAGSyncSourcePresentation);
+var buildRAGReadinessPresentation = (readiness) => {
+  if (!readiness) {
+    return {
+      sections: [
+        {
+          label: "Provider",
+          title: "Unavailable",
+          summary: "Readiness data is not available yet."
+        }
+      ]
+    };
+  }
+  return {
+    sections: [
+      {
+        label: "Provider",
+        title: readiness.providerConfigured ? readiness.providerName ?? "Runtime provider routing" : "Not configured",
+        summary: readiness.providerConfigured ? readiness.model ? `Requests route through ${readiness.providerName ?? "the runtime provider registry"} with default model ${readiness.model}.` : `Requests route through ${readiness.providerName ?? "the runtime provider registry"}.` : "Provider-backed retrieval is not configured yet."
+      },
+      {
+        label: "Embeddings",
+        title: readiness.embeddingConfigured ? readiness.embeddingModel === "collection-managed embeddings" ? "Collection-managed" : "Configured" : "Missing",
+        summary: readiness.embeddingConfigured ? readiness.embeddingModel === "collection-managed embeddings" ? "Embeddings come from the collection and vector store layer, so retrieval stays vector-backed without a separate top-level embedding provider." : readiness.embeddingModel ?? "Embedding model configured." : "Embeddings are not configured yet."
+      },
+      {
+        label: "Retrieval Stack",
+        title: readiness.rerankerConfigured ? "Reranker ready" : "Vector only",
+        summary: readiness.indexManagerConfigured ? "Index manager configured." : "Index manager not configured."
+      },
+      {
+        label: "Extractors",
+        title: readiness.extractorsConfigured ? `${readiness.extractorNames.length} configured` : "None configured",
+        summary: readiness.extractorsConfigured ? `Configured extractors: ${formatCompactList(readiness.extractorNames)}` : "No extractors configured.",
+        tags: readiness.extractorNames.length > 0 ? readiness.extractorNames : ["No extractors configured"]
+      }
+    ]
+  };
+};
+var buildRAGCorpusHealthPresentation = (health) => {
+  if (!health) {
+    return {
+      sections: [
+        {
+          label: "Corpus health",
+          title: "Unavailable",
+          summary: "Corpus health is not available yet."
+        }
+      ]
+    };
+  }
+  return {
+    sections: [
+      {
+        label: "Corpus coverage",
+        title: `Formats: ${formatCoverageMap(health.coverageByFormat)}`,
+        summary: `Kinds: ${formatCoverageMap(health.coverageByKind)}`,
+        rows: [
+          {
+            label: "Average chunks per document",
+            value: health.averageChunksPerDocument.toFixed(2)
+          }
+        ]
+      },
+      {
+        label: "Chunk quality",
+        title: `${health.averageChunksPerDocument.toFixed(2)} avg chunks/doc`,
+        summary: `Empty docs ${health.emptyDocuments} \xB7 empty chunks ${health.emptyChunks} \xB7 low signal ${health.lowSignalChunks}`,
+        rows: [
+          {
+            label: "Missing source",
+            value: String(health.documentsMissingSource)
+          },
+          {
+            label: "Missing title",
+            value: String(health.documentsMissingTitle)
+          },
+          {
+            label: "Missing metadata",
+            value: String(health.documentsMissingMetadata)
+          }
+        ]
+      },
+      {
+        label: "Freshness",
+        title: `${health.staleDocuments.length} stale docs`,
+        summary: `Stale threshold ${formatAgeLabel(health.staleAfterMs)}`,
+        rows: [
+          {
+            label: "Oldest age",
+            value: formatAgeLabel(health.oldestDocumentAgeMs)
+          },
+          {
+            label: "Newest age",
+            value: formatAgeLabel(health.newestDocumentAgeMs)
+          }
+        ]
+      },
+      {
+        label: "Failures",
+        title: `${health.failedIngestJobs} ingest \xB7 ${health.failedAdminJobs} admin`,
+        summary: `Duplicate sources ${health.duplicateSourceGroups.length} \xB7 duplicate ids ${health.duplicateDocumentIdGroups.length}`,
+        rows: [
+          {
+            label: "Failures by input",
+            value: formatCoverageMap(health.failuresByInputKind)
+          },
+          {
+            label: "Failures by extractor",
+            value: formatCoverageMap(health.failuresByExtractor)
+          },
+          {
+            label: "Failures by admin action",
+            value: formatCoverageMap(health.failuresByAdminAction)
+          }
+        ]
+      }
+    ]
+  };
+};
+var buildRAGSyncOverviewPresentation = (sources) => {
+  const records = sources ?? [];
+  if (records.length === 0) {
+    return {
+      rows: [
+        { label: "Configured sync sources", value: "0" },
+        {
+          label: "Latest sync",
+          value: "No sync sources configured yet."
+        }
+      ],
+      sections: [
+        {
+          label: "Sync overview",
+          title: "No sync sources configured",
+          summary: "Add sync sources to monitor directories, URLs, storage, or mailboxes."
+        }
+      ]
+    };
+  }
+  const countByStatus = (status) => records.filter((record) => record.status === status).length;
+  return {
+    rows: [
+      { label: "Configured sync sources", value: String(records.length) },
+      { label: "Completed", value: String(countByStatus("completed")) },
+      { label: "Running", value: String(countByStatus("running")) },
+      {
+        label: "Failed",
+        value: String(countByStatus("failed"))
+      },
+      buildSyncOverviewLatestRow(records)
+    ],
+    sections: [
+      {
+        label: "Sync overview",
+        title: `${records.length} configured`,
+        summary: `${countByStatus("completed")} completed \xB7 ${countByStatus("running")} running \xB7 ${countByStatus("failed")} failed`
+      },
+      {
+        label: "Latest sync",
+        title: buildSyncOverviewLatestRow(records).value,
+        summary: "Most recent completed or last-known sync activity."
+      }
+    ]
+  };
+};
+var formatMediaTimestamp2 = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return;
+  }
+  const totalSeconds = Math.floor(value / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  const milliseconds = Math.floor(value % 1000);
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(milliseconds).padStart(3, "0")}`;
+};
+var getAttachmentName2 = (source, title) => {
+  const sourceAttachment = source?.split("/").at(-1);
+  if (sourceAttachment && sourceAttachment.includes(".")) {
+    return sourceAttachment;
+  }
+  const titleAttachment = title?.split(" \xB7 ").at(-1);
+  if (titleAttachment && titleAttachment.includes(".")) {
+    return titleAttachment;
+  }
+  return;
+};
+var getSpreadsheetHeaders = (metadata) => Array.isArray(metadata?.spreadsheetHeaders) ? metadata.spreadsheetHeaders.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+var formatSpreadsheetColumnRange = (columnStart, columnEnd) => {
+  if (typeof columnStart !== "string" || columnStart.length === 0) {
+    return;
+  }
+  if (typeof columnEnd !== "string" || columnEnd.length === 0) {
+    return `Columns ${columnStart}`;
+  }
+  if (columnStart === columnEnd) {
+    return `Columns ${columnStart}`;
+  }
+  return `Columns ${columnStart}-${columnEnd}`;
+};
+var formatSpreadsheetRowRange = (rowStart, rowEnd) => {
+  if (typeof rowStart !== "number" || !Number.isFinite(rowStart)) {
+    return;
+  }
+  if (typeof rowEnd !== "number" && typeof rowStart === "number" && Number.isFinite(rowStart)) {
+    return `Rows ${rowStart}`;
+  }
+  if (rowStart === rowEnd) {
+    return `Rows ${rowStart}`;
+  }
+  return `Rows ${rowStart}-${rowEnd}`;
+};
+var formatSpreadsheetTableLabel = (tableIndex, tableCount) => {
+  if (typeof tableIndex !== "number" || !Number.isFinite(tableIndex) || tableIndex < 1) {
+    return;
+  }
+  if (typeof tableCount === "number" && Number.isFinite(tableCount) && tableCount >= tableIndex) {
+    return `Table ${tableIndex} of ${tableCount}`;
+  }
+  return `Table ${tableIndex}`;
+};
+var formatMediaDurationLabel2 = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return;
+  }
+  return formatMediaTimestamp2(value);
+};
+var buildContextLabel2 = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const officeBlockKind = getContextString2(metadata.officeBlockKind);
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getContextString2(metadata.sectionTitle) ?? sectionPath.at(-1);
+  if (pdfTextKind === "table_like" && sectionTitle) {
+    return `PDF table block ${sectionTitle}`;
+  }
+  if (pdfTextKind === "paragraph" && sectionTitle) {
+    return `PDF text block ${sectionTitle}`;
+  }
+  if (officeBlockKind === "table" && sectionTitle) {
+    return `Office table block ${sectionTitle}`;
+  }
+  if (officeBlockKind === "list" && sectionTitle) {
+    return `Office list block ${sectionTitle}`;
+  }
+  if (officeBlockKind === "paragraph" && sectionTitle) {
+    return `Office paragraph block ${sectionTitle}`;
+  }
+  const emailKind = getContextString2(metadata.emailKind);
+  if (emailKind === "attachment") {
+    const attachmentName = getContextString2(metadata.attachmentName);
+    const threadTopic2 = getContextString2(metadata.threadTopic);
+    return attachmentName ? threadTopic2 ? `Attachment evidence ${attachmentName} in ${threadTopic2}` : `Attachment evidence ${attachmentName}` : "Attachment evidence";
+  }
+  if (emailKind === "message") {
+    const threadTopic2 = getContextString2(metadata.threadTopic);
+    const from = getContextString2(metadata.from);
+    if (threadTopic2) {
+      return from ? `Message in ${threadTopic2} from ${from}` : `Message in ${threadTopic2}`;
+    }
+    return from ? `Message from ${from}` : "Message evidence";
+  }
+  const page = getContextNumber2(metadata.page) ?? getContextNumber2(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber2(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  const hasOCRTrace = typeof metadata.ocrRegionConfidence === "number" || typeof metadata.ocrConfidence === "number" || getContextString2(metadata.pdfTextMode) === "ocr" || typeof metadata.ocrRegionCount === "number";
+  const ocrPageStart = getContextNumber2(metadata.ocrPageStart);
+  const ocrPageEnd = getContextNumber2(metadata.ocrPageEnd);
+  if (page && region) {
+    if (hasOCRTrace) {
+      return `OCR page ${page} region ${region}`;
+    }
+    return `Page ${page} region ${region}`;
+  }
+  if (page) {
+    if (hasOCRTrace) {
+      return `OCR page ${page}`;
+    }
+    return `Page ${page}`;
+  }
+  if (hasOCRTrace && typeof ocrPageStart === "number" && typeof ocrPageEnd === "number") {
+    return ocrPageStart === ocrPageEnd ? `OCR page ${ocrPageStart}` : `OCR pages ${ocrPageStart}-${ocrPageEnd}`;
+  }
+  const sheet = getContextString2(metadata.sheetName) ?? (Array.isArray(metadata.sheetNames) ? getContextString2(metadata.sheetNames[0]) : undefined);
+  if (sheet) {
+    const tableLabel = formatSpreadsheetTableLabel(getContextNumber2(metadata.spreadsheetTableIndex), getContextNumber2(metadata.spreadsheetTableCount));
+    const columnRange = formatSpreadsheetColumnRange(getContextString2(metadata.spreadsheetColumnStart), getContextString2(metadata.spreadsheetColumnEnd));
+    const rowRange = formatSpreadsheetRowRange(getContextNumber2(metadata.spreadsheetRowStart), getContextNumber2(metadata.spreadsheetRowEnd));
+    const headers = getSpreadsheetHeaders(metadata);
+    if (tableLabel && rowRange && columnRange) {
+      return `Sheet ${sheet} ${tableLabel} ${rowRange} ${columnRange}`;
+    }
+    if (tableLabel && rowRange) {
+      return `Sheet ${sheet} ${tableLabel} ${rowRange}`;
+    }
+    if (tableLabel && columnRange) {
+      return `Sheet ${sheet} ${tableLabel} ${columnRange}`;
+    }
+    if (tableLabel) {
+      return `Sheet ${sheet} ${tableLabel}`;
+    }
+    if (rowRange && columnRange) {
+      return `Sheet ${sheet} ${rowRange} ${columnRange}`;
+    }
+    if (rowRange) {
+      return `Sheet ${sheet} ${rowRange}`;
+    }
+    if (columnRange) {
+      return `Sheet ${sheet} ${columnRange}`;
+    }
+    if (headers.length > 0) {
+      return `Sheet ${sheet} by ${headers.slice(0, 2).join(", ")}`;
+    }
+    return `Sheet ${sheet}`;
+  }
+  const slide = getContextNumber2(metadata.slide) ?? getContextNumber2(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : undefined);
+  const slideTitle = getContextString2(metadata.slideTitle);
+  if (slide) {
+    if (slideTitle) {
+      return `Slide ${slide} ${slideTitle}`;
+    }
+    return `Slide ${slide}`;
+  }
+  const archiveEntry = getContextString2(metadata.archiveFullPath) ?? getContextString2(metadata.archivePath) ?? getContextString2(metadata.archiveEntryPath) ?? getContextString2(metadata.entryPath);
+  if (archiveEntry) {
+    return `Archive entry ${archiveEntry}`;
+  }
+  const threadTopic = getContextString2(metadata.threadTopic);
+  if (threadTopic) {
+    return `Thread ${threadTopic}`;
+  }
+  const speaker = getContextString2(metadata.speaker);
+  if (speaker) {
+    return `Speaker ${speaker}`;
+  }
+  if (sectionTitle) {
+    return `Section ${sectionTitle}`;
+  }
+  return;
+};
+var buildLocatorLabel2 = (metadata, source, title) => {
+  if (!metadata) {
+    return;
+  }
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const officeBlockKind = getContextString2(metadata.officeBlockKind);
+  const pdfBlockNumber = getContextNumber2(metadata.pdfBlockNumber);
+  const officeBlockNumber = getContextNumber2(metadata.officeBlockNumber);
+  const spreadsheetRowStart = getContextNumber2(metadata.spreadsheetRowStart);
+  const spreadsheetRowEnd = getContextNumber2(metadata.spreadsheetRowEnd);
+  const slideTitle = getContextString2(metadata.slideTitle);
+  const page = getContextNumber2(metadata.page) ?? getContextNumber2(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber2(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  const ocrPageStart = getContextNumber2(metadata.ocrPageStart);
+  const ocrPageEnd = getContextNumber2(metadata.ocrPageEnd);
+  if (page && region) {
+    return `Page ${page} \xB7 Region ${region}`;
+  }
+  if (page && pdfBlockNumber && pdfTextKind === "table_like") {
+    return `Page ${page} \xB7 Table Block ${pdfBlockNumber}`;
+  }
+  if (page && pdfBlockNumber) {
+    return `Page ${page} \xB7 Text Block ${pdfBlockNumber}`;
+  }
+  if (page) {
+    return `Page ${page}`;
+  }
+  if (typeof ocrPageStart === "number" && typeof ocrPageEnd === "number") {
+    return ocrPageStart === ocrPageEnd ? `Page ${ocrPageStart}` : `Pages ${ocrPageStart}-${ocrPageEnd}`;
+  }
+  const sheet = getContextString2(metadata.sheetName) ?? (Array.isArray(metadata.sheetNames) ? getContextString2(metadata.sheetNames[0]) : undefined);
+  if (sheet) {
+    const tableLabel = formatSpreadsheetTableLabel(getContextNumber2(metadata.spreadsheetTableIndex), getContextNumber2(metadata.spreadsheetTableCount));
+    const columnRange = formatSpreadsheetColumnRange(getContextString2(metadata.spreadsheetColumnStart), getContextString2(metadata.spreadsheetColumnEnd));
+    const rowRange = formatSpreadsheetRowRange(spreadsheetRowStart, spreadsheetRowEnd);
+    if (tableLabel && rowRange && columnRange) {
+      return `Sheet ${sheet} \xB7 ${tableLabel} \xB7 ${rowRange} \xB7 ${columnRange}`;
+    }
+    if (tableLabel && rowRange) {
+      return `Sheet ${sheet} \xB7 ${tableLabel} \xB7 ${rowRange}`;
+    }
+    if (tableLabel && columnRange) {
+      return `Sheet ${sheet} \xB7 ${tableLabel} \xB7 ${columnRange}`;
+    }
+    if (tableLabel) {
+      return `Sheet ${sheet} \xB7 ${tableLabel}`;
+    }
+    if (rowRange && columnRange) {
+      return `Sheet ${sheet} \xB7 ${rowRange} \xB7 ${columnRange}`;
+    }
+    if (rowRange) {
+      return `Sheet ${sheet} \xB7 ${rowRange}`;
+    }
+    return columnRange ? `Sheet ${sheet} \xB7 ${columnRange}` : `Sheet ${sheet}`;
+  }
+  const slide = getContextNumber2(metadata.slide) ?? getContextNumber2(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : undefined);
+  if (slide) {
+    return slideTitle ? `Slide ${slide} \xB7 ${slideTitle}` : `Slide ${slide}`;
+  }
+  const archiveEntry = getContextString2(metadata.archiveFullPath) ?? getContextString2(metadata.archivePath) ?? getContextString2(metadata.archiveEntryPath) ?? getContextString2(metadata.entryPath);
+  if (archiveEntry) {
+    return `Archive entry ${archiveEntry}`;
+  }
+  const emailKind = getContextString2(metadata.emailKind);
+  if (emailKind === "attachment") {
+    const attachmentName = getContextString2(metadata.attachmentName) ?? getAttachmentName2(source, title);
+    const replyDepth = getContextNumber2(metadata.replyDepth);
+    if (attachmentName && replyDepth && replyDepth > 0) {
+      return `Attachment ${attachmentName} \xB7 Reply depth ${replyDepth}`;
+    }
+    return attachmentName ? `Attachment ${attachmentName}` : "Attachment";
+  }
+  const mediaStart = formatMediaTimestamp2(metadata.startMs);
+  const mediaEnd = formatMediaTimestamp2(metadata.endMs);
+  if (mediaStart && mediaEnd) {
+    return `Timestamp ${mediaStart} - ${mediaEnd}`;
+  }
+  if (mediaStart) {
+    return `Timestamp ${mediaStart}`;
+  }
+  if (officeBlockNumber && officeBlockKind === "table") {
+    return `Office table block ${officeBlockNumber}`;
+  }
+  if (officeBlockNumber && officeBlockKind === "list") {
+    return `Office list block ${officeBlockNumber}`;
+  }
+  if (officeBlockNumber && officeBlockKind === "paragraph") {
+    return `Office paragraph block ${officeBlockNumber}`;
+  }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  if (sectionPath.length > 0) {
+    return `Section ${sectionPath.join(" > ")}`;
+  }
+  return;
+};
+var buildProvenanceLabel2 = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const threadTopic = getContextString2(metadata.threadTopic);
+  const replyDepth = getContextNumber2(metadata.replyDepth);
+  const threadMessageCount = getContextNumber2(metadata.threadMessageCount);
+  const threadRootMessageId = getContextString2(metadata.threadRootMessageId);
+  const from = getContextString2(metadata.from);
+  const sentAt = formatTimestampLabel2(metadata.sentAt) ?? formatTimestampLabel2(metadata.receivedAt);
+  const speaker = getContextString2(metadata.speaker);
+  const mediaKind = getContextString2(metadata.mediaKind);
+  const transcriptSource = getContextString2(metadata.transcriptSource);
+  const mediaSpeakerCount = getContextNumber2(metadata.mediaSpeakerCount);
+  const mediaSegmentCount = getContextNumber2(metadata.mediaSegmentCount);
+  const mediaSegmentGroupSize = getContextNumber2(metadata.mediaSegmentGroupSize);
+  const mediaSegmentGroupIndex = getContextNumber2(metadata.mediaSegmentGroupIndex);
+  const mediaChannel = getContextString2(metadata.mediaChannel);
+  const mediaDurationLabel = formatMediaDurationLabel2(metadata.mediaDurationMs);
+  const mediaSegmentWindowDurationLabel = formatMediaDurationLabel2(metadata.mediaSegmentGroupDurationMs);
+  const mediaSegmentGapLabel = formatMediaDurationLabel2(metadata.mediaSegmentGapFromPreviousMs);
+  const spreadsheetHeaders = getSpreadsheetHeaders(metadata);
+  const spreadsheetColumnRange = formatSpreadsheetColumnRange(getContextString2(metadata.spreadsheetColumnStart), getContextString2(metadata.spreadsheetColumnEnd));
+  const slideNotesText = getContextString2(metadata.slideNotesText);
+  const pdfTextMode = getContextString2(metadata.pdfTextMode);
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const officeBlockKind = getContextString2(metadata.officeBlockKind);
+  const ocrEngine = getContextString2(metadata.ocrEngine);
+  const extractorRegistryMatch = getContextString2(metadata.extractorRegistryMatch);
+  const chunkingProfile = getContextString2(metadata.chunkingProfile);
+  const archiveDepth = getContextNumber2(metadata.archiveDepth);
+  const archiveNestedDepth = getContextNumber2(metadata.archiveNestedDepth);
+  const archiveContainerPath = getContextString2(metadata.archiveContainerPath);
+  const archiveRootName = getContextString2(metadata.archiveRootName);
+  const sourceAwareChunkReason = formatSourceAwareChunkReason(metadata.sourceAwareChunkReason);
+  const sourceAwareUnitScope = buildSourceAwareUnitScopeLabel(metadata);
+  const spreadsheetTableLabel = formatSpreadsheetTableLabel(getContextNumber2(metadata.spreadsheetTableIndex), getContextNumber2(metadata.spreadsheetTableCount));
+  const ocrConfidence = getContextNumber2(metadata.ocrRegionConfidence) ?? getContextNumber2(metadata.ocrConfidence);
+  const ocrAverageConfidence = getContextNumber2(metadata.ocrPageAverageConfidence) ?? getContextNumber2(metadata.ocrAverageConfidence);
+  const ocrMinConfidence = getContextNumber2(metadata.ocrPageMinConfidence) ?? getContextNumber2(metadata.ocrMinConfidence);
+  const ocrMaxConfidence = getContextNumber2(metadata.ocrPageMaxConfidence) ?? getContextNumber2(metadata.ocrMaxConfidence);
+  const ocrRegionCount = getContextNumber2(metadata.ocrRegionCount);
+  const labels = [
+    pdfTextMode ? `PDF ${pdfTextMode}` : "",
+    pdfTextKind === "table_like" ? "PDF table block" : pdfTextKind === "paragraph" ? "PDF text block" : "",
+    officeBlockKind ? `Office ${officeBlockKind}` : "",
+    ocrEngine ? `OCR ${ocrEngine}` : "",
+    extractorRegistryMatch ? `Extractor ${extractorRegistryMatch}` : "",
+    chunkingProfile ? `Chunking ${chunkingProfile}` : "",
+    sourceAwareChunkReason ?? "",
+    sourceAwareUnitScope ?? "",
+    typeof ocrConfidence === "number" ? `Confidence ${ocrConfidence.toFixed(2)}` : "",
+    typeof ocrAverageConfidence === "number" && ocrAverageConfidence !== ocrConfidence ? `Average ${ocrAverageConfidence.toFixed(2)}` : "",
+    typeof ocrMinConfidence === "number" && typeof ocrMaxConfidence === "number" && ocrMinConfidence !== ocrMaxConfidence ? `Range ${ocrMinConfidence.toFixed(2)}-${ocrMaxConfidence.toFixed(2)}` : "",
+    typeof ocrRegionCount === "number" ? `${ocrRegionCount} regions` : "",
+    spreadsheetHeaders.length > 0 ? `Spreadsheet ${spreadsheetHeaders.join(", ")}` : "",
+    spreadsheetColumnRange ? `Spreadsheet ${spreadsheetColumnRange}` : "",
+    spreadsheetTableLabel ? `Spreadsheet ${spreadsheetTableLabel}` : "",
+    mediaKind ? `Media ${mediaKind}` : "",
+    mediaSegmentCount ? `${mediaSegmentCount} segments` : "",
+    mediaSegmentGroupSize ? `${mediaSegmentGroupSize} grouped segments` : "",
+    mediaSegmentGroupIndex !== undefined ? `Segment group ${mediaSegmentGroupIndex + 1}` : "",
+    mediaChannel ? `Channel ${mediaChannel}` : "",
+    mediaSpeakerCount ? `${mediaSpeakerCount} speakers` : "",
+    mediaDurationLabel ? `Duration ${mediaDurationLabel}` : "",
+    mediaSegmentWindowDurationLabel ? `Segment window ${mediaSegmentWindowDurationLabel}` : "",
+    mediaSegmentGapLabel ? `Gap ${mediaSegmentGapLabel} from previous window` : "",
+    transcriptSource ? `Transcript ${transcriptSource}` : "",
+    threadTopic ? `Thread ${threadTopic}` : "",
+    threadRootMessageId ? `Thread root ${threadRootMessageId}` : "",
+    threadMessageCount ? `${threadMessageCount} thread messages` : "",
+    replyDepth ? `Reply depth ${replyDepth}` : "",
+    slideNotesText ? "Speaker notes" : "",
+    archiveDepth ? `Archive depth ${archiveDepth}` : "",
+    archiveNestedDepth ? `Archive nested depth ${archiveNestedDepth}` : "",
+    archiveContainerPath ? `Archive container ${archiveContainerPath}` : "",
+    archiveRootName ? `Archive root ${archiveRootName}` : "",
+    speaker ? `Speaker ${speaker}` : "",
+    from ? `Sender ${from}` : "",
+    sentAt ? `Sent ${sentAt}` : ""
+  ].filter((value) => value.length > 0);
+  return labels.length > 0 ? labels.join(" \xB7 ") : undefined;
+};
+var buildRAGSourceLabels = ({
+  metadata,
+  source,
+  title
+}) => {
+  const contextLabel = buildContextLabel2(metadata);
+  const locatorLabel = buildLocatorLabel2(metadata, source, title);
+  const provenanceLabel = buildProvenanceLabel2(metadata);
+  if (!contextLabel && !locatorLabel && !provenanceLabel) {
+    return;
+  }
+  return {
+    contextLabel,
+    locatorLabel,
+    provenanceLabel
+  };
+};
+var buildRAGChunkStructure = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.filter((value) => typeof value === "string" && value.trim().length > 0) : undefined;
+  const sectionKind = metadata.sectionKind === "markdown_heading" || metadata.sectionKind === "html_heading" || metadata.sectionKind === "office_heading" || metadata.sectionKind === "office_block" || metadata.sectionKind === "pdf_block" || metadata.sectionKind === "spreadsheet_rows" || metadata.sectionKind === "presentation_slide" ? metadata.sectionKind : undefined;
+  const section = {
+    depth: getContextNumber2(metadata.sectionDepth),
+    kind: sectionKind,
+    path: sectionPath && sectionPath.length > 0 ? sectionPath : undefined,
+    title: getContextString2(metadata.sectionTitle)
+  };
+  const sequence = {
+    nextChunkId: getContextString2(metadata.nextChunkId),
+    previousChunkId: getContextString2(metadata.previousChunkId),
+    sectionChunkCount: getContextNumber2(metadata.sectionChunkCount),
+    sectionChunkId: getContextString2(metadata.sectionChunkId),
+    sectionChunkIndex: getContextNumber2(metadata.sectionChunkIndex)
+  };
+  if (!section.title && (!section.path || section.path.length === 0) && typeof section.depth !== "number" && !section.kind && !sequence.nextChunkId && !sequence.previousChunkId && typeof sequence.sectionChunkCount !== "number" && !sequence.sectionChunkId && typeof sequence.sectionChunkIndex !== "number") {
+    return;
+  }
+  return {
+    section: section.title || section.path && section.path.length > 0 || typeof section.depth === "number" || section.kind ? section : undefined,
+    sequence: sequence.nextChunkId || sequence.previousChunkId || typeof sequence.sectionChunkCount === "number" || sequence.sectionChunkId || typeof sequence.sectionChunkIndex === "number" ? sequence : undefined
+  };
+};
+var buildExcerpt2 = (text, maxLength = 160) => {
+  const normalized = text.replaceAll(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}\u2026`;
+};
+var buildRAGChunkExcerpts = (chunks, activeChunkId) => {
+  if (chunks.length === 0) {
+    return;
+  }
+  const graph = buildRAGChunkGraph(chunks.map((chunk) => ({
+    chunkId: chunk.chunkId,
+    metadata: chunk.metadata,
+    structure: chunk.structure
+  })));
+  const navigation = buildRAGChunkGraphNavigation(graph, activeChunkId);
+  const activeChunk = chunks.find((chunk) => chunk.chunkId === navigation.activeChunkId) ?? chunks[0];
+  if (!activeChunk) {
+    return;
+  }
+  const chunkMap = new Map(chunks.map((chunk) => [chunk.chunkId, chunk]));
+  const orderedSectionIds = navigation.sectionNodes.length > 0 ? navigation.sectionNodes.map((node) => node.chunkId) : [activeChunk.chunkId];
+  const orderedWindowIds = navigation.sectionNodes.length > 0 ? (() => {
+    const activeIndex = navigation.sectionNodes.findIndex((node) => node.chunkId === activeChunk.chunkId);
+    const startIndex = Math.max(0, activeIndex - 2);
+    const endIndex = Math.min(navigation.sectionNodes.length, activeIndex + 3);
+    return navigation.sectionNodes.slice(startIndex, endIndex).map((node) => node.chunkId);
+  })() : [
+    navigation.previousNode?.chunkId,
+    activeChunk.chunkId,
+    navigation.nextNode?.chunkId
+  ].filter((chunkId, index, ids) => Boolean(chunkId) && ids.indexOf(chunkId) === index);
+  const collectText = (chunkIds) => chunkIds.map((chunkId) => chunkMap.get(chunkId)?.text).filter((text) => typeof text === "string").join(`
+
+`);
+  return {
+    chunkExcerpt: buildExcerpt2(activeChunk.text, 160),
+    sectionExcerpt: buildExcerpt2(collectText(orderedSectionIds), 320),
+    windowExcerpt: buildExcerpt2(collectText(orderedWindowIds), 240)
+  };
+};
+var buildRAGExcerptSelection = (excerpts, structure) => {
+  if (!excerpts) {
+    return {
+      excerpt: "",
+      mode: "chunk",
+      reason: "single_chunk"
+    };
+  }
+  const chunkLength = excerpts.chunkExcerpt.trim().length;
+  const sectionChunkCount = structure?.sequence?.sectionChunkCount ?? 1;
+  if (sectionChunkCount > 1 && chunkLength > 0 && chunkLength < 72) {
+    if (sectionChunkCount <= 3 && excerpts.sectionExcerpt.trim().length > 0) {
+      return {
+        excerpt: excerpts.sectionExcerpt,
+        mode: "section",
+        reason: "section_small_enough"
+      };
+    }
+    if (excerpts.windowExcerpt.trim().length > 0) {
+      return {
+        excerpt: excerpts.windowExcerpt,
+        mode: "window",
+        reason: "section_too_large_use_window"
+      };
+    }
+    return {
+      excerpt: excerpts.chunkExcerpt,
+      mode: "chunk",
+      reason: "chunk_too_narrow"
+    };
+  }
+  return {
+    excerpt: excerpts.chunkExcerpt,
+    mode: "chunk",
+    reason: sectionChunkCount > 1 ? "chunk_too_narrow" : "single_chunk"
+  };
+};
+var buildRAGExcerptModeCounts = (selections) => selections.reduce((counts, selection) => {
+  if (selection) {
+    counts[selection.mode] += 1;
+  }
+  return counts;
+}, { chunk: 0, section: 0, window: 0 });
+var buildRAGChunkGraph = (chunks) => {
+  const nodes = [];
+  const edges = [];
+  const edgeKeys = new Set;
+  const sections = new Map;
+  for (const chunk of chunks) {
+    const labels = chunk.labels ?? buildRAGSourceLabels({
+      metadata: chunk.metadata,
+      source: chunk.source,
+      title: chunk.title
+    });
+    const structure = chunk.structure ?? buildRAGChunkStructure(chunk.metadata);
+    nodes.push({
+      chunkId: chunk.chunkId,
+      contextLabel: labels?.contextLabel,
+      label: chunk.source ?? chunk.title ?? chunk.chunkId,
+      locatorLabel: labels?.locatorLabel,
+      provenanceLabel: labels?.provenanceLabel,
+      score: chunk.score,
+      source: chunk.source,
+      structure,
+      title: chunk.title
+    });
+    const previousChunkId = structure?.sequence?.previousChunkId;
+    if (previousChunkId) {
+      const key = `previous:${previousChunkId}:${chunk.chunkId}`;
+      if (!edgeKeys.has(key)) {
+        edgeKeys.add(key);
+        edges.push({
+          fromChunkId: previousChunkId,
+          relation: "previous",
+          toChunkId: chunk.chunkId
+        });
+      }
+    }
+    const nextChunkId = structure?.sequence?.nextChunkId;
+    if (nextChunkId) {
+      const key = `next:${chunk.chunkId}:${nextChunkId}`;
+      if (!edgeKeys.has(key)) {
+        edgeKeys.add(key);
+        edges.push({
+          fromChunkId: chunk.chunkId,
+          relation: "next",
+          toChunkId: nextChunkId
+        });
+      }
+    }
+    const sectionId = structure?.sequence?.sectionChunkId;
+    if (sectionId) {
+      const existing = sections.get(sectionId);
+      if (!existing) {
+        sections.set(sectionId, {
+          childSectionIds: [],
+          chunkCount: structure.sequence?.sectionChunkCount ?? 1,
+          chunkIds: [chunk.chunkId],
+          depth: structure.section?.depth,
+          id: sectionId,
+          kind: structure.section?.kind,
+          leadChunkId: chunk.chunkId,
+          path: structure.section?.path,
+          title: structure.section?.title
+        });
+        continue;
+      }
+      if (!existing.chunkIds.includes(chunk.chunkId)) {
+        existing.chunkIds.push(chunk.chunkId);
+      }
+      existing.chunkCount = Math.max(existing.chunkCount, structure.sequence?.sectionChunkCount ?? existing.chunkCount);
+    }
+  }
+  for (const section of sections.values()) {
+    section.chunkIds.sort((left, right) => {
+      const leftNode = nodes.find((node) => node.chunkId === left);
+      const rightNode = nodes.find((node) => node.chunkId === right);
+      const leftIndex = leftNode?.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+      const rightIndex = rightNode?.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+      if (leftIndex !== rightIndex) {
+        return leftIndex - rightIndex;
+      }
+      return left.localeCompare(right);
+    });
+    section.leadChunkId = section.chunkIds[0];
+  }
+  const sectionPathIndex = new Map;
+  for (const section of sections.values()) {
+    const path = section.path && section.path.length > 0 ? section.path : section.title ? [section.title] : undefined;
+    if (path && path.length > 0) {
+      sectionPathIndex.set(path.join("\x00"), section);
+    }
+  }
+  for (const section of sections.values()) {
+    const path = section.path && section.path.length > 0 ? section.path : section.title ? [section.title] : undefined;
+    if (!path || path.length < 2) {
+      continue;
+    }
+    const parent = sectionPathIndex.get(path.slice(0, -1).join("\x00"));
+    if (!parent || parent.id === section.id) {
+      continue;
+    }
+    section.parentSectionId = parent.id;
+    if (!parent.childSectionIds.includes(section.id)) {
+      parent.childSectionIds.push(section.id);
+    }
+    if (parent.leadChunkId && section.leadChunkId) {
+      const parentKey = `section_parent:${section.leadChunkId}:${parent.leadChunkId}`;
+      if (!edgeKeys.has(parentKey)) {
+        edgeKeys.add(parentKey);
+        edges.push({
+          fromChunkId: section.leadChunkId,
+          relation: "section_parent",
+          toChunkId: parent.leadChunkId
+        });
+      }
+      const childKey = `section_child:${parent.leadChunkId}:${section.leadChunkId}`;
+      if (!edgeKeys.has(childKey)) {
+        edgeKeys.add(childKey);
+        edges.push({
+          fromChunkId: parent.leadChunkId,
+          relation: "section_child",
+          toChunkId: section.leadChunkId
+        });
+      }
+    }
+  }
+  nodes.sort((left, right) => {
+    const leftSection = left.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+    const rightSection = right.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+    if (leftSection !== rightSection) {
+      return leftSection - rightSection;
+    }
+    const leftScore = left.score ?? Number.NEGATIVE_INFINITY;
+    const rightScore = right.score ?? Number.NEGATIVE_INFINITY;
+    if (leftScore !== rightScore) {
+      return rightScore - leftScore;
+    }
+    return left.label.localeCompare(right.label);
+  });
+  return {
+    edges,
+    nodes,
+    sections: [...sections.values()].sort((left, right) => (left.title ?? left.id).localeCompare(right.title ?? right.id))
+  };
+};
+var buildRAGChunkPreviewGraph = (preview) => buildRAGChunkGraph(preview.chunks.map((chunk) => ({
+  chunkId: chunk.chunkId,
+  labels: chunk.labels,
+  metadata: chunk.metadata,
+  source: chunk.source ?? preview.document.source,
+  structure: chunk.structure,
+  title: chunk.title ?? preview.document.title
+})));
+var buildRAGChunkPreviewNavigation = (preview, activeChunkId) => buildRAGChunkGraphNavigation(buildRAGChunkPreviewGraph(preview), activeChunkId);
+var buildRAGChunkGraphNavigation = (graph, activeChunkId) => {
+  if (graph.nodes.length === 0) {
+    return {
+      activeChunkId,
+      childSections: [],
+      siblingSections: [],
+      sectionNodes: []
+    };
+  }
+  const activeNode = (activeChunkId ? graph.nodes.find((node) => node.chunkId === activeChunkId) : undefined) ?? graph.nodes[0];
+  const resolvedActiveChunkId = activeNode?.chunkId;
+  const previousNode = activeNode?.structure?.sequence?.previousChunkId ? graph.nodes.find((node) => node.chunkId === activeNode.structure?.sequence?.previousChunkId) : undefined;
+  const nextNode = activeNode?.structure?.sequence?.nextChunkId ? graph.nodes.find((node) => node.chunkId === activeNode.structure?.sequence?.nextChunkId) : undefined;
+  const section = activeNode?.structure?.sequence?.sectionChunkId ? graph.sections.find((entry) => entry.id === activeNode.structure?.sequence?.sectionChunkId) : undefined;
+  const parentSection = section?.parentSectionId ? graph.sections.find((entry) => entry.id === section.parentSectionId) : undefined;
+  const childSections = section ? section.childSectionIds.map((sectionId) => graph.sections.find((entry) => entry.id === sectionId)).filter((entry) => Boolean(entry)) : [];
+  const siblingSections = section?.parentSectionId ? graph.sections.filter((entry) => entry.parentSectionId === section.parentSectionId && entry.id !== section.id) : [];
+  const sectionNodes = section ? section.chunkIds.map((chunkId) => graph.nodes.find((node) => node.chunkId === chunkId)).filter((node) => Boolean(node)) : activeNode ? [activeNode] : [];
+  return {
+    activeChunkId: resolvedActiveChunkId,
+    activeNode,
+    childSections,
+    nextNode,
+    parentSection,
+    previousNode,
+    section,
+    siblingSections,
+    sectionNodes
+  };
+};
+var buildRAGRetrievedState = (messages) => {
+  const message = getLatestRetrievedMessage(messages);
+  if (!message) {
+    return null;
+  }
+  const sources = message.sources ?? [];
+  const citations = buildRAGCitations(sources);
+  const sectionDiagnostics = buildRAGSectionRetrievalDiagnostics(sources, isRAGRetrievalTrace(message.retrievalTrace) ? message.retrievalTrace : undefined);
+  const sourceSummaries = buildRAGSourceSummaries(sources);
+  const groundedAnswer = buildRAGGroundedAnswer(message.content, sources);
+  return {
+    citationReferenceMap: buildRAGCitationReferenceMap(citations),
+    citations,
+    conversationId: message.conversationId,
+    excerptModeCounts: buildRAGExcerptModeCounts([
+      ...citations.map((citation) => citation.excerptSelection),
+      ...sourceSummaries.map((summary) => summary.excerptSelection)
+    ]),
+    groundedAnswer,
+    messageId: message.id,
+    retrievalDurationMs: message.retrievalDurationMs,
+    retrievalStartedAt: message.retrievalStartedAt,
+    retrievedAt: message.retrievedAt,
+    trace: isRAGRetrievalTrace(message.retrievalTrace) ? message.retrievalTrace : undefined,
+    sectionDiagnostics,
+    sourceGroups: buildRAGSourceGroups(sources),
+    sourceSummaries,
+    sources
+  };
+};
+var buildRAGSourceSummaries = (sources) => {
+  const sourceGroups = buildRAGSourceGroups(sources);
+  const citations = buildRAGCitations(sources);
+  const citationReferenceMap = buildRAGCitationReferenceMap(citations);
+  return sourceGroups.map((group) => {
+    const groupCitations = citations.filter((citation) => group.chunks.some((chunk) => chunk.chunkId === citation.chunkId));
+    const leadChunk = getPreferredSourceLeadChunk(group.chunks);
+    const excerpts = leadChunk ? buildRAGChunkExcerpts(group.chunks, leadChunk.chunkId) : undefined;
+    const structure = leadChunk?.structure ?? buildRAGChunkStructure(leadChunk?.metadata);
+    const excerptSelection = buildRAGExcerptSelection(excerpts, structure);
+    return {
+      bestScore: group.bestScore,
+      citationNumbers: groupCitations.map((citation) => citationReferenceMap[citation.chunkId] ?? 0),
+      citations: groupCitations,
+      chunkIds: group.chunks.map((chunk) => chunk.chunkId),
+      contextLabel: leadChunk?.labels?.contextLabel ?? buildContextLabel2(leadChunk?.metadata),
+      count: group.count,
+      excerpt: excerptSelection.excerpt || buildExcerpt2(leadChunk?.text ?? ""),
+      excerpts,
+      excerptSelection,
+      key: group.key,
+      label: group.label,
+      locatorLabel: leadChunk?.labels?.locatorLabel ?? buildLocatorLabel2(leadChunk?.metadata, leadChunk?.source, leadChunk?.title),
+      provenanceLabel: leadChunk?.labels?.provenanceLabel ?? buildProvenanceLabel2(leadChunk?.metadata),
+      structure,
+      source: group.source,
+      title: group.title
+    };
+  });
+};
+var getSectionPathFromSource = (source) => {
+  const path = source.structure?.section?.path ?? (Array.isArray(source.metadata?.sectionPath) ? source.metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : []);
+  return path.length > 0 ? path : undefined;
+};
+var isBlockAwareContextLabel = (value) => typeof value === "string" && (value.startsWith("PDF ") || value.startsWith("Office ") || value.startsWith("Slide "));
+var getStructuredSectionScoreWeight = (metadata) => {
+  if (!metadata) {
+    return 1;
+  }
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const officeBlockKind = getContextString2(metadata.officeBlockKind);
+  const sectionKind = getContextString2(metadata.sectionKind);
+  const slideTitle = getContextString2(metadata.slideTitle);
+  const slideNotesText = getContextString2(metadata.slideNotesText);
+  if (pdfTextKind === "table_like") {
+    return 1.28;
+  }
+  if (officeBlockKind === "table" || officeBlockKind === "list") {
+    return 1.24;
+  }
+  if (sectionKind === "pdf_block" || sectionKind === "office_block" || officeBlockKind === "paragraph" || pdfTextKind === "paragraph") {
+    return 1.12;
+  }
+  if (sectionKind === "presentation_slide" && slideNotesText) {
+    return 1.2;
+  }
+  if (sectionKind === "presentation_slide" && slideTitle) {
+    return 1.14;
+  }
+  return 1;
+};
+var getStructuredSourceLeadScore = (source) => source.score * getStructuredSectionScoreWeight(source.metadata);
+var getPreferredSourceLeadChunk = (chunks) => chunks.slice().sort((left, right) => {
+  const leftWeightedScore = getStructuredSourceLeadScore(left);
+  const rightWeightedScore = getStructuredSourceLeadScore(right);
+  if (rightWeightedScore !== leftWeightedScore) {
+    return rightWeightedScore - leftWeightedScore;
+  }
+  if (right.score !== left.score) {
+    return right.score - left.score;
+  }
+  return left.chunkId.localeCompare(right.chunkId);
+})[0];
+var buildRAGSectionRetrievalDiagnostics = (sources, trace) => {
+  const totalScore = sources.reduce((sum, source) => sum + source.score * getStructuredSectionScoreWeight(source.metadata), 0);
+  if (sources.length === 0 || totalScore <= 0) {
+    return [];
+  }
+  const sections = new Map;
+  for (const source of sources) {
+    const structuredScore = source.score * getStructuredSectionScoreWeight(source.metadata);
+    const path = getSectionPathFromSource(source);
+    if (!path) {
+      continue;
+    }
+    const key = path.join(" > ");
+    const label = path.at(-1) ?? key;
+    const parentLabel = path.length > 1 ? path.slice(0, -1).join(" > ") : undefined;
+    const existing = sections.get(key);
+    const channels = Array.isArray(source.metadata?.retrievalChannels) ? source.metadata.retrievalChannels.filter((value) => value === "vector" || value === "lexical") : [];
+    const isHybrid = channels.includes("vector") && channels.includes("lexical");
+    const vectorHits = channels.includes("vector") ? 1 : 0;
+    const lexicalHits = channels.includes("lexical") ? 1 : 0;
+    const hybridHits = isHybrid ? 1 : 0;
+    const queryOrigins = Array.isArray(source.metadata?.retrievalQueryOrigins) ? source.metadata.retrievalQueryOrigins.filter((value) => value === "primary" || value === "transformed" || value === "variant") : source.metadata?.retrievalQueryOrigin === "primary" || source.metadata?.retrievalQueryOrigin === "transformed" || source.metadata?.retrievalQueryOrigin === "variant" ? [source.metadata.retrievalQueryOrigin] : [];
+    const primaryHits = queryOrigins.includes("primary") ? 1 : 0;
+    const transformedHits = queryOrigins.includes("transformed") ? 1 : 0;
+    const variantHits = queryOrigins.includes("variant") ? 1 : 0;
+    if (!existing) {
+      sections.set(key, {
+        bestScore: source.score,
+        count: 1,
+        hybridHits,
+        key,
+        label,
+        lexicalHits,
+        parentLabel,
+        path,
+        primaryHits,
+        sourceSet: new Set(source.source ? [source.source] : []),
+        topChunkId: source.chunkId,
+        topSource: source.source,
+        totalScore: structuredScore,
+        transformedHits,
+        variantHits,
+        vectorHits
+      });
+      continue;
+    }
+    existing.count += 1;
+    existing.totalScore += structuredScore;
+    if (source.source) {
+      existing.sourceSet.add(source.source);
+    }
+    existing.vectorHits += vectorHits;
+    existing.lexicalHits += lexicalHits;
+    existing.hybridHits += hybridHits;
+    existing.primaryHits += primaryHits;
+    existing.transformedHits += transformedHits;
+    existing.variantHits += variantHits;
+    if (source.score > existing.bestScore) {
+      existing.bestScore = source.score;
+      existing.topChunkId = source.chunkId;
+      existing.topSource = source.source;
+    }
+  }
+  const diagnostics = [...sections.values()];
+  const strongestBestHit = diagnostics.reduce((highest, section) => Math.max(highest, section.bestScore), 0);
+  const parentLabelByKey = new Map(diagnostics.map((section) => [section.key, section.parentLabel]));
+  const stageSectionCounts = new Map((trace?.steps ?? []).filter((step) => Array.isArray(step.sectionCounts) && step.sectionCounts.length > 0).map((step) => [step.stage, step.sectionCounts ?? []]));
+  const stageSectionScores = new Map((trace?.steps ?? []).filter((step) => Array.isArray(step.sectionScores) && step.sectionScores.length > 0).map((step) => [step.stage, step.sectionScores ?? []]));
+  return diagnostics.map((section) => {
+    const siblingPool = diagnostics.filter((entry) => entry.parentLabel === section.parentLabel);
+    const siblings = siblingPool.filter((entry) => entry.key !== section.key);
+    const strongestSibling = siblings.slice().sort((left, right) => right.totalScore - left.totalScore)[0];
+    const parentTotal = siblingPool.reduce((sum, entry) => sum + entry.totalScore, 0);
+    const scoreShare = section.totalScore / totalScore;
+    const parentShare = parentTotal > 0 ? section.totalScore / parentTotal : undefined;
+    const topChunk = sources.find((source) => source.chunkId === section.topChunkId);
+    const topContextLabel = topChunk?.labels?.contextLabel ?? buildContextLabel2(topChunk?.metadata);
+    const topLocatorLabel = topChunk?.labels?.locatorLabel ?? buildLocatorLabel2(topChunk?.metadata, topChunk?.source, topChunk?.title);
+    const sourceAwareChunkReason = formatSourceAwareChunkReason(topChunk?.metadata?.sourceAwareChunkReason);
+    const sourceAwareUnitScopeLabel = buildSourceAwareUnitScopeLabel(topChunk?.metadata);
+    const parentDistribution = parentTotal > 0 ? siblingPool.map((entry) => ({
+      count: entry.count,
+      isActive: entry.key === section.key,
+      key: entry.key,
+      label: entry.label,
+      parentShare: entry.totalScore / parentTotal,
+      totalScore: entry.totalScore
+    })).sort((left, right) => right.totalScore - left.totalScore) : [];
+    const reasons = [];
+    const stageCounts = trace?.steps.map((step) => ({
+      count: step.sectionCounts?.find((entry) => entry.key === section.key)?.count ?? 0,
+      stage: step.stage
+    })).filter((entry) => entry.count > 0) ?? [];
+    const stageWeights = stageCounts.map((entry) => {
+      const previousStageEntry = stageCounts[stageCounts.findIndex((candidate) => candidate.stage === entry.stage) - 1];
+      const stageEntries = stageSectionCounts.get(entry.stage)?.filter((candidate) => candidate.count > 0) ?? [];
+      const stageScoreEntries = stageSectionScores.get(entry.stage)?.filter((candidate) => candidate.totalScore > 0) ?? [];
+      const stageTotal = stageEntries.reduce((sum, candidate) => sum + candidate.count, 0);
+      const stageScoreTotal = stageScoreEntries.reduce((sum, candidate) => sum + candidate.totalScore, 0);
+      const siblingStageEntries = stageEntries.filter((candidate) => candidate.key !== section.key && parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const parentStageEntries = stageEntries.filter((candidate) => parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const siblingStageScoreEntries = stageScoreEntries.filter((candidate) => candidate.key !== section.key && parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const parentStageScoreEntries = stageScoreEntries.filter((candidate) => parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const strongestStageSibling = siblingStageEntries.slice().sort((left, right) => right.count - left.count)[0];
+      const parentStageTotal = parentStageEntries.reduce((sum, candidate) => sum + candidate.count, 0);
+      const activeStageScore = stageScoreEntries.find((candidate) => candidate.key === section.key)?.totalScore;
+      const strongestStageScoreSibling = siblingStageScoreEntries.slice().sort((left, right) => right.totalScore - left.totalScore)[0];
+      const parentStageScoreTotal = parentStageScoreEntries.reduce((sum, candidate) => sum + candidate.totalScore, 0);
+      const stageShare = stageTotal > 0 ? entry.count / stageTotal : 0;
+      const retentionRate = typeof previousStageEntry?.count === "number" && previousStageEntry.count > 0 ? entry.count / previousStageEntry.count : undefined;
+      const countDelta = typeof previousStageEntry?.count === "number" ? entry.count - previousStageEntry.count : undefined;
+      const parentStageShare = parentStageTotal > 0 ? entry.count / parentStageTotal : undefined;
+      const stageScoreShare = typeof activeStageScore === "number" && stageScoreTotal > 0 ? activeStageScore / stageScoreTotal : undefined;
+      const parentStageScoreShare = typeof activeStageScore === "number" && parentStageScoreTotal > 0 ? activeStageScore / parentStageScoreTotal : undefined;
+      const stageShareGap = stageTotal > 0 && strongestStageSibling ? entry.count / stageTotal - strongestStageSibling.count / stageTotal : undefined;
+      const parentStageShareGap = parentStageTotal > 0 && strongestStageSibling ? entry.count / parentStageTotal - strongestStageSibling.count / parentStageTotal : undefined;
+      const stageScoreShareGap = typeof activeStageScore === "number" && stageScoreTotal > 0 && strongestStageScoreSibling ? activeStageScore / stageScoreTotal - strongestStageScoreSibling.totalScore / stageScoreTotal : undefined;
+      const parentStageScoreShareGap = typeof activeStageScore === "number" && parentStageScoreTotal > 0 && strongestStageScoreSibling ? activeStageScore / parentStageScoreTotal - strongestStageScoreSibling.totalScore / parentStageScoreTotal : undefined;
+      const reasons2 = [];
+      if (entry.stage === "rerank" && stageShare > 0.5 && (typeof stageShareGap !== "number" || stageShareGap > 0)) {
+        reasons2.push("rerank_preserved_lead");
+      }
+      if (entry.stage === "finalize" && stageShare >= 0.5) {
+        reasons2.push("final_stage_concentration");
+      }
+      if (entry.stage === "finalize" && typeof parentStageShare === "number" && parentStageShare >= 0.6 && (typeof parentStageShareGap !== "number" || parentStageShareGap > 0)) {
+        reasons2.push("final_stage_dominant_within_parent");
+      }
+      if (strongestStageSibling && (typeof stageShareGap === "number" && stageShareGap <= 0.1 || typeof parentStageShareGap === "number" && parentStageShareGap <= 0.1)) {
+        reasons2.push("stage_runner_up_pressure");
+      }
+      if (typeof countDelta === "number") {
+        if (countDelta > 0) {
+          reasons2.push("stage_expanded");
+        } else if (countDelta < 0) {
+          reasons2.push("stage_narrowed");
+        } else {
+          reasons2.push("stage_held");
+        }
+      }
+      return {
+        count: entry.count,
+        countDelta,
+        parentStageScoreShare,
+        parentStageShare,
+        parentStageShareGap,
+        previousCount: previousStageEntry?.count,
+        previousStage: previousStageEntry?.stage,
+        reasons: reasons2,
+        retentionRate,
+        stage: entry.stage,
+        stageScoreShare,
+        stageScoreShareGap,
+        stageShare,
+        stageShareGap,
+        totalScore: activeStageScore,
+        strongestSiblingCount: strongestStageSibling?.count,
+        strongestSiblingLabel: strongestStageSibling ? diagnostics.find((candidate) => candidate.key === strongestStageSibling.key)?.label ?? strongestStageSibling.key : undefined
+      };
+    });
+    const firstSeenStage = stageCounts[0]?.stage;
+    const lastSeenStage = stageCounts.at(-1)?.stage;
+    const peakStageEntry = stageCounts.reduce((highest, entry) => !highest || entry.count > highest.count ? entry : highest, undefined);
+    const finalStageEntry = stageCounts.at(-1);
+    const peakCount = peakStageEntry?.count ?? section.count;
+    const finalCount = finalStageEntry?.count;
+    const finalRetentionRate = typeof finalCount === "number" && peakCount > 0 ? finalCount / peakCount : undefined;
+    const dropFromPeak = typeof finalCount === "number" ? peakCount - finalCount : undefined;
+    const queryAttributionReasons = [];
+    const queryAttributionMode = section.primaryHits > 0 && section.transformedHits === 0 && section.variantHits === 0 ? "primary" : section.transformedHits > 0 && section.primaryHits === 0 && section.variantHits === 0 ? "transformed" : section.variantHits > 0 && section.primaryHits === 0 && section.transformedHits === 0 ? "variant" : "mixed";
+    if (queryAttributionMode === "primary") {
+      queryAttributionReasons.push("base_query_only");
+    }
+    if (queryAttributionMode === "transformed") {
+      queryAttributionReasons.push("transformed_query_only");
+      queryAttributionReasons.push("transform_introduced");
+    }
+    if (queryAttributionMode === "variant") {
+      queryAttributionReasons.push("variant_only");
+      queryAttributionReasons.push("variant_supported");
+    }
+    if (queryAttributionMode === "mixed") {
+      queryAttributionReasons.push("mixed_query_sources");
+      if (section.variantHits > 0) {
+        queryAttributionReasons.push("variant_supported");
+      }
+      if (section.transformedHits > 0 && section.primaryHits === 0) {
+        queryAttributionReasons.push("transform_introduced");
+      }
+    }
+    if (section.bestScore >= strongestBestHit) {
+      reasons.push("best_hit");
+    }
+    if (section.count > 1) {
+      reasons.push("multi_hit_section");
+    }
+    if (siblings.length === 0) {
+      reasons.push("only_section_in_parent");
+    } else if (!strongestSibling || section.totalScore >= strongestSibling.totalScore) {
+      reasons.push("dominant_within_parent");
+    }
+    if (scoreShare >= 0.5 || (parentShare ?? 0) >= 0.6) {
+      reasons.push("concentrated_evidence");
+    }
+    const summaryParts = [
+      isBlockAwareContextLabel(topContextLabel) ? topContextLabel : "",
+      `${section.count} hit${section.count === 1 ? "" : "s"}`,
+      `${(scoreShare * 100).toFixed(0)}% score share`,
+      `vector ${section.vectorHits} \xB7 lexical ${section.lexicalHits} \xB7 hybrid ${section.hybridHits}`,
+      typeof parentShare === "number" ? `${(parentShare * 100).toFixed(0)}% of parent section set` : "",
+      sourceAwareChunkReason ? `boundary ${sourceAwareChunkReason}` : "",
+      sourceAwareUnitScopeLabel ? `scope ${sourceAwareUnitScopeLabel}` : "",
+      strongestSibling ? `ahead of ${strongestSibling.label} by ${(section.totalScore - strongestSibling.totalScore).toFixed(2)}` : "no sibling competition"
+    ].filter(Boolean);
+    return {
+      averageScore: section.totalScore / section.count,
+      bestScore: section.bestScore,
+      count: section.count,
+      key: section.key,
+      label: section.label,
+      parentLabel: section.parentLabel,
+      parentDistribution,
+      parentShare,
+      parentShareGap: typeof parentShare === "number" && strongestSibling && parentTotal > 0 ? parentShare - strongestSibling.totalScore / parentTotal : undefined,
+      path: section.path,
+      firstSeenStage,
+      finalCount,
+      finalRetentionRate,
+      lastSeenStage,
+      dropFromPeak,
+      peakCount,
+      peakStage: peakStageEntry?.stage,
+      queryAttribution: {
+        mode: queryAttributionMode,
+        primaryHits: section.primaryHits,
+        reasons: queryAttributionReasons,
+        transformedHits: section.transformedHits,
+        variantHits: section.variantHits
+      },
+      requestedMode: trace?.requestedMode,
+      retrievalMode: trace?.mode,
+      routingLabel: trace?.routingLabel,
+      routingProvider: trace?.routingProvider,
+      routingReason: trace?.routingReason,
+      queryTransformLabel: trace?.queryTransformLabel,
+      queryTransformProvider: trace?.queryTransformProvider,
+      queryTransformReason: trace?.queryTransformReason,
+      reasons,
+      rerankApplied: trace?.steps.some((step) => step.stage === "rerank" && step.metadata?.applied === true),
+      scoreShare,
+      scoreThresholdApplied: trace?.steps.some((step) => step.stage === "score_filter"),
+      stageCounts,
+      stageWeights,
+      siblingCount: siblings.length,
+      siblingScoreGap: strongestSibling ? section.totalScore - strongestSibling.totalScore : undefined,
+      sourceCount: section.sourceSet.size,
+      sourceAwareChunkReasonLabel: sourceAwareChunkReason,
+      sourceAwareUnitScopeLabel,
+      topContextLabel,
+      topLocatorLabel,
+      sourceBalanceApplied: trace?.steps.some((step) => step.stage === "source_balance"),
+      strongestSiblingLabel: strongestSibling?.label,
+      strongestSiblingScore: strongestSibling?.totalScore,
+      summary: summaryParts.join(" \xB7 "),
+      topChunkId: section.topChunkId,
+      topSource: section.topSource,
+      totalScore: section.totalScore,
+      hybridHits: section.hybridHits,
+      lexicalHits: section.lexicalHits,
+      vectorHits: section.vectorHits
+    };
+  }).sort((left, right) => {
+    if (right.totalScore !== left.totalScore) {
+      return right.totalScore - left.totalScore;
+    }
+    if (right.bestScore !== left.bestScore) {
+      return right.bestScore - left.bestScore;
+    }
+    return left.label.localeCompare(right.label);
+  });
+};
+var buildStreamProgressState = (messages) => {
+  const latestMessage = getLatestAssistantMessage(messages);
+  const retrieved = latestMessage ? buildRAGRetrievedState(messages) : undefined;
+  return {
+    conversationId: latestMessage?.conversationId,
+    latestMessage,
+    messageId: latestMessage?.id,
+    retrieved,
+    sourceCount: retrieved?.sources.length ?? latestMessage?.sources?.length ?? 0
+  };
+};
+var buildRAGStreamProgress = ({
+  error,
+  isStreaming,
+  messages
+}) => {
+  const stage = resolveRAGStreamStage({
+    error,
+    isStreaming,
+    messages
+  });
+  const state = buildStreamProgressState(messages);
+  const hasSources = state.sourceCount > 0;
+  const hasRetrieved = stage === "retrieved" || state.retrieved !== undefined || state.latestMessage?.retrievedAt !== undefined;
+  const hasThinking = typeof state.latestMessage?.thinking === "string" && state.latestMessage.thinking.length > 0;
+  const hasToolCalls = (state.latestMessage?.toolCalls?.length ?? 0) > 0;
+  return {
+    conversationId: state.conversationId,
+    hasContent: typeof state.latestMessage?.content === "string" && state.latestMessage.content.length > 0,
+    hasRetrieved,
+    hasSources,
+    hasThinking,
+    hasToolCalls,
+    isComplete: stage === "complete",
+    isError: stage === "error",
+    isIdle: stage === "idle",
+    isRetrieved: stage === "retrieved",
+    isRetrieving: stage === "submitting" || stage === "retrieving",
+    isStreaming: stage === "streaming",
+    isSubmitting: stage === "submitting",
+    latestMessage: state.latestMessage,
+    messageId: state.messageId,
+    retrievalDurationMs: state.retrieved?.retrievalDurationMs,
+    retrievalStartedAt: state.retrieved?.retrievalStartedAt,
+    retrievedAt: state.retrieved?.retrievedAt,
+    sourceCount: state.sourceCount,
+    stage
+  };
+};
+var buildRAGAnswerWorkflowState = ({
+  error,
+  isStreaming,
+  messages
+}) => {
+  const latestAssistantMessage = getLatestAssistantMessage(messages);
+  const sources = getLatestRAGSources(messages);
+  const sourceGroups = buildRAGSourceGroups(sources);
+  const citations = buildRAGCitations(sources);
+  const citationReferenceMap = buildRAGCitationReferenceMap(citations);
+  const sourceSummaries = buildRAGSourceSummaries(sources);
+  const groundingReferences = buildRAGGroundingReferences(sources);
+  const groundedAnswer = buildRAGGroundedAnswer(latestAssistantMessage?.content ?? "", sources);
+  const retrieval = buildRAGRetrievedState(messages);
+  const sectionDiagnostics = buildRAGSectionRetrievalDiagnostics(sources, retrieval?.trace);
+  const progress = buildRAGStreamProgress({
+    error,
+    isStreaming,
+    messages
+  });
+  return {
+    excerptModeCounts: buildRAGExcerptModeCounts([
+      ...citations.map((citation) => citation.excerptSelection),
+      ...sourceSummaries.map((summary) => summary.excerptSelection),
+      ...groundingReferences.map((reference) => reference.excerptSelection),
+      ...groundedAnswer.sectionSummaries.map((summary) => summary.excerptSelection)
+    ]),
+    citationReferenceMap,
+    citations,
+    coverage: groundedAnswer.coverage,
+    error,
+    groundedAnswer,
+    groundingReferences,
+    hasCitations: groundedAnswer.hasCitations,
+    hasGrounding: groundingReferences.length > 0,
+    hasRetrieved: progress.hasRetrieved,
+    hasSources: sources.length > 0,
+    isAnswerStreaming: progress.isStreaming,
+    isComplete: progress.isComplete,
+    isError: progress.isError,
+    isIdle: progress.isIdle,
+    isRetrieved: progress.isRetrieved,
+    isRetrieving: progress.isRetrieving,
+    isRunning: progress.isSubmitting || progress.isRetrieving || progress.isStreaming,
+    isSubmitting: progress.isSubmitting,
+    latestAssistantMessage,
+    messages,
+    retrieval,
+    retrievalDurationMs: retrieval?.retrievalDurationMs,
+    retrievalStartedAt: retrieval?.retrievalStartedAt,
+    retrievedAt: retrieval?.retrievedAt,
+    sectionDiagnostics,
+    sourceGroups,
+    sourceSummaries,
+    sources,
+    stage: progress.stage,
+    ungroundedReferenceNumbers: groundedAnswer.ungroundedReferenceNumbers
+  };
+};
+var buildRAGSourceGroups = (sources) => {
+  const groups = new Map;
+  for (const source of sources) {
+    updateSourceGroup(groups, source);
+  }
+  return [...groups.values()].sort((left, right) => {
+    if (right.bestScore !== left.bestScore) {
+      return right.bestScore - left.bestScore;
+    }
+    return left.label.localeCompare(right.label);
+  });
+};
+var buildSourceGroup = (source, key) => ({
+  bestScore: source.score,
+  chunks: [source],
+  count: 1,
+  key,
+  label: buildSourceLabel2(source),
+  labels: source.labels ?? buildRAGSourceLabels({
+    metadata: source.metadata,
+    source: source.source,
+    title: source.title
+  }),
+  structure: source.structure ?? buildRAGChunkStructure(source.metadata),
+  source: source.source,
+  title: source.title
+});
+var updateSourceGroup = (groups, source) => {
+  const key = buildSourceGroupKey(source);
+  const existing = groups.get(key);
+  if (!existing) {
+    groups.set(key, buildSourceGroup(source, key));
+    return;
+  }
+  existing.bestScore = Math.max(existing.bestScore, source.score);
+  existing.count += 1;
+  existing.chunks.push(source);
+  const leadChunk = getPreferredSourceLeadChunk(existing.chunks);
+  if (leadChunk) {
+    existing.label = buildSourceLabel2(leadChunk);
+    existing.labels = leadChunk.labels ?? buildRAGSourceLabels({
+      metadata: leadChunk.metadata,
+      source: leadChunk.source,
+      title: leadChunk.title
+    });
+    existing.structure = leadChunk.structure ?? buildRAGChunkStructure(leadChunk.metadata);
+    existing.source = leadChunk.source;
+    existing.title = leadChunk.title;
+  }
+};
+var getLatestAssistantMessage = (messages) => {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant") {
+      return message;
+    }
+  }
+  return;
+};
+var getLatestRAGSources = (messages) => getLatestAssistantMessage(messages)?.sources ?? [];
+var getLatestRetrievedMessage = (messages) => {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant" && (typeof message.retrievedAt === "number" || (message.sources?.length ?? 0) > 0)) {
+      return message;
+    }
+  }
+  return;
+};
+var resolveRAGStreamStage = ({
+  error,
+  isStreaming,
+  messages
+}) => {
+  if (error) {
+    return "error";
+  }
+  const assistantMessage = getLatestAssistantMessage(messages);
+  if (!assistantMessage) {
+    return isStreaming ? "submitting" : "idle";
+  }
+  const isRetrieving = typeof assistantMessage.retrievalStartedAt === "number" && typeof assistantMessage.retrievedAt !== "number";
+  if (isRetrieving) {
+    return "retrieving";
+  }
+  if (!isStreaming) {
+    return "complete";
+  }
+  const hasRetrieved = typeof assistantMessage.retrievedAt === "number";
+  const hasContent = assistantMessage.content.trim().length > 0 || assistantMessage.thinking?.trim().length || (assistantMessage.toolCalls?.length ?? 0) > 0 || (assistantMessage.images?.length ?? 0) > 0;
+  if (hasRetrieved && !hasContent) {
+    return "retrieved";
+  }
+  return "streaming";
+};
+var formatSignedDelta = (value, decimals = 0, suffix = "") => `${value >= 0 ? "+" : ""}${value.toFixed(decimals)}${suffix}`;
+var formatEvaluationPassingRate = (value) => `${value.toFixed(1)}%`;
+var formatEvaluationSummary = (response) => `${response.summary.totalCases} total \xB7 f1 ${response.summary.averageF1.toFixed(3)} \xB7 latency ${response.summary.averageLatencyMs.toFixed(1)}ms`;
+var formatGroundingHistorySummaryValue = (response) => `${response.summary.passedCases}/${response.summary.totalCases} pass \xB7 grounded ${response.summary.groundedCases} \xB7 partial ${response.summary.partialCases} \xB7 ungrounded ${response.summary.ungroundedCases} \xB7 resolved citations ${(response.summary.averageResolvedCitationRate * 100).toFixed(1)}% \xB7 citation f1 ${response.summary.averageCitationF1.toFixed(3)}`;
+var formatHistoryCaseLabels = (cases) => cases.length > 0 ? cases.map((entry) => entry.label ?? entry.caseId).join(", ") : "none";
+var buildComparisonCaseLeadLabel = (snapshot) => snapshot?.topLocatorLabel ?? snapshot?.topContextLabel ?? snapshot?.sourceAwareUnitScopeLabel ?? snapshot?.sourceAwareChunkReasonLabel;
+var formatComparisonLeadCueSummary = (entry) => {
+  const labels = Array.from(new Set((entry.caseTraceSnapshots ?? []).map((snapshot) => buildComparisonCaseLeadLabel(snapshot)).filter((value) => typeof value === "string"))).slice(0, 3);
+  return labels.length > 0 ? labels.join(" \xB7 ") : "none";
+};
+var formatComparisonLeadMediaCueSummary = (entry) => {
+  const labels = Array.from(new Set((entry.caseTraceSnapshots ?? []).map((snapshot) => formatLeadMediaCueSummary({
+    leadSpeakerCue: snapshot.leadSpeakerCue,
+    leadSpeakerAttributionCue: snapshot.leadSpeakerAttributionCue,
+    leadChannelCue: snapshot.leadChannelCue,
+    leadChannelAttributionCue: snapshot.leadChannelAttributionCue,
+    leadContinuityCue: snapshot.leadContinuityCue
+  })).filter((value) => typeof value === "string" && value !== "none"))).slice(0, 3);
+  return labels.length > 0 ? labels.join(" \xB7 ") : "none";
+};
+var formatSQLitePlannerCueSummary = (input) => {
+  const parts = [
+    input?.sqliteQueryMode ? `mode ${input.sqliteQueryMode}` : undefined,
+    typeof input?.sqliteQueryPushdownApplied === "boolean" ? input.sqliteQueryPushdownApplied ? "pushdown applied" : "pushdown skipped" : undefined,
+    typeof input?.sqliteQueryPushdownClauseCount === "number" ? `clauses ${input.sqliteQueryPushdownClauseCount}` : undefined,
+    typeof input?.sqliteQueryFilteredCandidates === "number" ? `filtered ${input.sqliteQueryFilteredCandidates}` : undefined,
+    typeof input?.sqliteQueryInitialSearchK === "number" && typeof input?.sqliteQueryFinalSearchK === "number" ? `searchK ${input.sqliteQueryInitialSearchK}->${input.sqliteQueryFinalSearchK}` : typeof input?.sqliteQueryFinalSearchK === "number" ? `searchK ${input.sqliteQueryFinalSearchK}` : undefined,
+    typeof input?.sqliteQueryBackfillCount === "number" ? `backfill ${input.sqliteQueryBackfillCount}` : undefined
+  ].filter((value) => typeof value === "string");
+  return parts.length > 0 ? parts.join(" \xB7 ") : "none";
+};
+var formatComparisonSQLitePlannerCueSummary = (entry) => {
+  const labels = Array.from(new Set((entry.caseTraceSnapshots ?? []).map((snapshot) => formatSQLitePlannerCueSummary({
+    sqliteQueryBackfillCount: snapshot.sqliteQueryBackfillCount,
+    sqliteQueryFilteredCandidates: snapshot.sqliteQueryFilteredCandidates,
+    sqliteQueryFinalSearchK: snapshot.sqliteQueryFinalSearchK,
+    sqliteQueryInitialSearchK: snapshot.sqliteQueryInitialSearchK,
+    sqliteQueryMode: snapshot.sqliteQueryMode,
+    sqliteQueryPushdownApplied: snapshot.sqliteQueryPushdownApplied,
+    sqliteQueryPushdownClauseCount: snapshot.sqliteQueryPushdownClauseCount
+  })).filter((value) => typeof value === "string" && value !== "none"))).slice(0, 3);
+  return labels.length > 0 ? labels.join(" \xB7 ") : "none";
+};
+var formatComparisonLeadDrift = (entry, leader) => {
+  if (!leader?.caseTraceSnapshots?.length || !entry.caseTraceSnapshots?.length) {
+    return "none";
+  }
+  const leaderCases = new Map(leader.caseTraceSnapshots.map((snapshot) => [snapshot.caseId, snapshot]));
+  const drift = entry.caseTraceSnapshots.map((snapshot) => {
+    const leaderSnapshot = leaderCases.get(snapshot.caseId);
+    const currentLead = buildComparisonCaseLeadLabel(snapshot);
+    const leaderLead = buildComparisonCaseLeadLabel(leaderSnapshot);
+    if (!currentLead || !leaderLead || currentLead === leaderLead) {
+      return;
+    }
+    return `${snapshot.label ?? snapshot.caseId} ${leaderLead}\u2192${currentLead}`;
+  }).filter((value) => typeof value === "string").slice(0, 3);
+  return drift.length > 0 ? drift.join(" \xB7 ") : "none";
+};
+var formatComparisonLeadMediaDrift = (entry, leader) => {
+  if (!leader?.caseTraceSnapshots?.length || !entry.caseTraceSnapshots?.length) {
+    return "none";
+  }
+  const leaderCases = new Map(leader.caseTraceSnapshots.map((snapshot) => [snapshot.caseId, snapshot]));
+  const drift = entry.caseTraceSnapshots.map((snapshot) => {
+    const leaderSnapshot = leaderCases.get(snapshot.caseId);
+    const currentMediaCues = formatLeadMediaCueSummary({
+      leadSpeakerCue: snapshot.leadSpeakerCue,
+      leadSpeakerAttributionCue: snapshot.leadSpeakerAttributionCue,
+      leadChannelCue: snapshot.leadChannelCue,
+      leadChannelAttributionCue: snapshot.leadChannelAttributionCue,
+      leadContinuityCue: snapshot.leadContinuityCue
+    });
+    const leaderMediaCues = formatLeadMediaCueSummary({
+      leadSpeakerCue: leaderSnapshot?.leadSpeakerCue,
+      leadSpeakerAttributionCue: leaderSnapshot?.leadSpeakerAttributionCue,
+      leadChannelCue: leaderSnapshot?.leadChannelCue,
+      leadChannelAttributionCue: leaderSnapshot?.leadChannelAttributionCue,
+      leadContinuityCue: leaderSnapshot?.leadContinuityCue
+    });
+    if (currentMediaCues === "none" || leaderMediaCues === "none" || currentMediaCues === leaderMediaCues) {
+      return;
+    }
+    return `${snapshot.label ?? snapshot.caseId} ${leaderMediaCues}\u2192${currentMediaCues}`;
+  }).filter((value) => typeof value === "string").slice(0, 3);
+  return drift.length > 0 ? drift.join(" \xB7 ") : "none";
+};
+var formatComparisonSQLitePlannerDrift = (entry, leader) => {
+  if (!leader?.caseTraceSnapshots?.length || !entry.caseTraceSnapshots?.length) {
+    return "none";
+  }
+  const leaderCases = new Map(leader.caseTraceSnapshots.map((snapshot) => [snapshot.caseId, snapshot]));
+  const drift = entry.caseTraceSnapshots.map((snapshot) => {
+    const leaderSnapshot = leaderCases.get(snapshot.caseId);
+    const currentPlanner = formatSQLitePlannerCueSummary(snapshot);
+    const leaderPlanner = formatSQLitePlannerCueSummary(leaderSnapshot);
+    if (currentPlanner === "none" || leaderPlanner === "none" || currentPlanner === leaderPlanner) {
+      return;
+    }
+    return `${snapshot.label ?? snapshot.caseId} ${leaderPlanner}\u2192${currentPlanner}`;
+  }).filter((value) => typeof value === "string").slice(0, 3);
+  return drift.length > 0 ? drift.join(" \xB7 ") : "none";
+};
+var formatComparisonRoutingCueSummary = (entry) => {
+  const trace = entry.traceSummary;
+  if (!trace) {
+    return "none";
+  }
+  const parts = [
+    `modes ${formatTraceModes(trace.modes)}`,
+    `balance ${formatSourceBalanceStrategies(trace.sourceBalanceStrategies)}`,
+    `rewrites ${formatTraceRatio(trace.transformedCases, trace.totalCases)}`,
+    `variants ${formatTraceRatio(trace.variantCases, trace.totalCases)}`
+  ].filter((value) => !value.endsWith("n/a"));
+  return parts.length > 0 ? parts.join(" \xB7 ") : "none";
+};
+var formatComparisonRoutingDrift = (entry, leader) => {
+  const trace = entry.traceSummary;
+  const leaderTrace = leader?.traceSummary;
+  if (!trace || !leaderTrace || entry === leader) {
+    return "none";
+  }
+  const deltas = [];
+  const currentModes = formatTraceModes(trace.modes);
+  const previousModes = formatTraceModes(leaderTrace.modes);
+  if (currentModes !== previousModes) {
+    deltas.push(`modes ${previousModes}\u2192${currentModes}`);
+  }
+  const currentBalance = formatSourceBalanceStrategies(trace.sourceBalanceStrategies);
+  const previousBalance = formatSourceBalanceStrategies(leaderTrace.sourceBalanceStrategies);
+  if (currentBalance !== previousBalance) {
+    deltas.push(`balance ${previousBalance}\u2192${currentBalance}`);
+  }
+  const transformedDelta = trace.transformedCases - leaderTrace.transformedCases;
+  if (transformedDelta !== 0) {
+    deltas.push(`rewrites ${formatTraceCountDelta(transformedDelta)}`);
+  }
+  const variantDelta = trace.variantCases - leaderTrace.variantCases;
+  if (variantDelta !== 0) {
+    deltas.push(`variants ${formatTraceCountDelta(variantDelta)}`);
+  }
+  return deltas.length > 0 ? deltas.slice(0, 3).join(" \xB7 ") : "none";
+};
+var formatHistoryRoutingShift = (history) => {
+  const delta = history?.diff?.traceSummaryDelta;
+  if (!delta) {
+    return "none";
+  }
+  const shifts = [];
+  if (delta.modesChanged) {
+    shifts.push("modes changed");
+  }
+  if (delta.sourceBalanceStrategiesChanged) {
+    shifts.push("balance changed");
+  }
+  if (delta.transformedCases !== 0) {
+    shifts.push(`rewrites ${formatTraceCountDelta(delta.transformedCases)}`);
+  }
+  if (delta.variantCases !== 0) {
+    shifts.push(`variants ${formatTraceCountDelta(delta.variantCases)}`);
+  }
+  return shifts.length > 0 ? shifts.join(" \xB7 ") : "none";
+};
+var formatHistorySQLitePlannerShift = (history) => {
+  if (!history?.caseTraceSnapshots.length) {
+    return "none";
+  }
+  const shifts = history.caseTraceSnapshots.map((entry) => {
+    const previousPlanner = formatSQLitePlannerCueSummary({
+      sqliteQueryBackfillCount: entry.previousSqliteQueryBackfillCount,
+      sqliteQueryFilteredCandidates: entry.previousSqliteQueryFilteredCandidates,
+      sqliteQueryFinalSearchK: entry.previousSqliteQueryFinalSearchK,
+      sqliteQueryInitialSearchK: entry.previousSqliteQueryInitialSearchK,
+      sqliteQueryMode: entry.previousSqliteQueryMode,
+      sqliteQueryPushdownApplied: entry.previousSqliteQueryPushdownApplied,
+      sqliteQueryPushdownClauseCount: entry.previousSqliteQueryPushdownClauseCount
+    });
+    const currentPlanner = formatSQLitePlannerCueSummary(entry);
+    if (previousPlanner === "none" || currentPlanner === "none" || previousPlanner === currentPlanner) {
+      return;
+    }
+    return `${entry.label ?? entry.caseId} ${previousPlanner}\u2192${currentPlanner}`;
+  }).filter((value) => typeof value === "string").slice(0, 3);
+  return shifts.length > 0 ? shifts.join(" \xB7 ") : "none";
+};
+var formatTraceLeadChanges = (changes) => changes && changes.length > 0 ? changes.slice(0, 3).map((entry) => {
+  const label = entry.label ?? entry.caseId;
+  const previousLead = entry.previousLead ?? "n/a";
+  return `${label} ${previousLead}\u2192${entry.currentLead}`;
+}).join(" \xB7 ") : "none";
+var formatGroundingHistoryCaseLabels = (cases) => cases.length > 0 ? cases.map((entry) => entry.label ?? entry.caseId).join(", ") : "none";
+var formatRerankerComparisonHeadline = (entry) => [
+  entry.label,
+  `passing ${formatEvaluationPassingRate(entry.response.passingRate)}`,
+  `f1 ${entry.response.summary.averageF1.toFixed(3)}`,
+  `latency ${entry.response.summary.averageLatencyMs.toFixed(1)}ms`
+].join(" \xB7 ");
+var formatRetrievalComparisonHeadline = (entry) => [
+  entry.label,
+  `mode ${entry.retrievalMode}`,
+  `passing ${formatEvaluationPassingRate(entry.response.passingRate)}`,
+  `f1 ${entry.response.summary.averageF1.toFixed(3)}`,
+  `latency ${entry.response.summary.averageLatencyMs.toFixed(1)}ms`
+].join(" \xB7 ");
+var formatTraceModes = (modes) => modes.length > 0 ? modes.join(" / ") : "n/a";
+var formatSourceBalanceStrategies = (strategies) => strategies.length > 0 ? strategies.join(" / ") : "n/a";
+var formatTraceStageSummary = (stageCounts) => {
+  const topStages = Object.entries(stageCounts).sort((left, right) => right[1] - left[1]).slice(0, 3);
+  return topStages.length > 0 ? topStages.map(([stage, count]) => `${stage} ${count}`).join(" \xB7 ") : "n/a";
+};
+var formatTraceRatio = (count, total) => `${count}/${total}`;
+var formatTraceCountDelta = (value) => `${value >= 0 ? "+" : ""}${value}`;
+var buildComparisonOverviewPresentation = (input) => {
+  const winnerLabel = input.resolveLabel(input.summary.bestByPassingRate);
+  const winnerEntry = input.resolveEntry(input.summary.bestByPassingRate);
+  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)
+      }
+    ],
+    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"
+  };
+};
+var buildRAGComparisonTraceSummaryRows = (entry) => {
+  const trace = entry.traceSummary;
+  const rows = [
+    {
+      label: "Lead cues",
+      value: formatComparisonLeadCueSummary(entry)
+    },
+    {
+      label: "Lead media cues",
+      value: formatComparisonLeadMediaCueSummary(entry)
+    },
+    {
+      label: "SQLite planner cues",
+      value: formatComparisonSQLitePlannerCueSummary(entry)
+    },
+    {
+      label: "Routing cues",
+      value: formatComparisonRoutingCueSummary(entry)
+    }
+  ];
+  if (!trace) {
+    rows.unshift({ label: "Trace", value: "Unavailable" });
+    return rows;
+  }
+  rows.push({ label: "Modes", value: formatTraceModes(trace.modes) }, {
+    label: "Balance",
+    value: formatSourceBalanceStrategies(trace.sourceBalanceStrategies)
+  }, { label: "Avg final", value: trace.averageFinalCount.toFixed(1) }, { label: "Avg vector", value: trace.averageVectorCount.toFixed(1) }, { label: "Avg lexical", value: trace.averageLexicalCount.toFixed(1) }, {
+    label: "Balanced",
+    value: formatTraceRatio(trace.balancedCases, trace.totalCases)
+  }, {
+    label: "Round robin",
+    value: formatTraceRatio(trace.roundRobinCases, trace.totalCases)
+  }, {
+    label: "Transforms",
+    value: formatTraceRatio(trace.transformedCases, trace.totalCases)
+  }, {
+    label: "Variants",
+    value: formatTraceRatio(trace.variantCases, trace.totalCases)
+  }, {
+    label: "TopK",
+    value: `${trace.averageCandidateTopK.toFixed(1)} / ${trace.averageLexicalTopK.toFixed(1)}`
+  }, {
+    label: "Stages",
+    value: formatTraceStageSummary(trace.stageCounts)
+  });
+  return rows;
+};
+var buildRAGComparisonTraceDiffRows = (entry, leader) => {
+  const trace = entry.traceSummary;
+  const leadDriftRow = {
+    label: "Lead drift vs leader",
+    value: formatComparisonLeadDrift(entry, leader)
+  };
+  const leadMediaDriftRow = {
+    label: "Lead media shift vs leader",
+    value: formatComparisonLeadMediaDrift(entry, leader)
+  };
+  const sqlitePlannerDriftRow = {
+    label: "SQLite planner shift vs leader",
+    value: formatComparisonSQLitePlannerDrift(entry, leader)
+  };
+  const routingDriftRow = {
+    label: "Routing shift vs leader",
+    value: formatComparisonRoutingDrift(entry, leader)
+  };
+  if (!trace) {
+    return [
+      { label: "Trace", value: "Unavailable for comparison" },
+      leadDriftRow,
+      leadMediaDriftRow,
+      sqlitePlannerDriftRow,
+      routingDriftRow
+    ];
+  }
+  const leaderTrace = leader?.traceSummary;
+  if (!leaderTrace) {
+    return [
+      { label: "Baseline", value: "Leader trace unavailable" },
+      leadDriftRow,
+      leadMediaDriftRow,
+      sqlitePlannerDriftRow,
+      routingDriftRow
+    ];
+  }
+  if (entry === leader) {
+    return [
+      { label: "Baseline", value: "Leader strategy" },
+      leadDriftRow,
+      leadMediaDriftRow,
+      sqlitePlannerDriftRow,
+      routingDriftRow
+    ];
+  }
+  const stageDelta = Object.keys({
+    ...leaderTrace.stageCounts,
+    ...trace.stageCounts
+  }).map((stage) => {
+    const typedStage = stage;
+    const delta = (trace.stageCounts[typedStage] ?? 0) - (leaderTrace.stageCounts[typedStage] ?? 0);
+    return delta === 0 ? null : `${typedStage} ${formatTraceCountDelta(delta)}`;
+  }).filter((value) => Boolean(value)).slice(0, 3).join(" \xB7 ");
+  const rows = [
+    { label: "Baseline", value: leader.label }
+  ];
+  if (formatTraceModes(trace.modes) !== formatTraceModes(leaderTrace.modes)) {
+    rows.push({
+      label: "Modes vs leader",
+      value: `${formatTraceModes(trace.modes)} vs ${formatTraceModes(leaderTrace.modes)}`
+    });
+  }
+  if (formatSourceBalanceStrategies(trace.sourceBalanceStrategies) !== formatSourceBalanceStrategies(leaderTrace.sourceBalanceStrategies)) {
+    rows.push({
+      label: "Balance vs leader",
+      value: `${formatSourceBalanceStrategies(trace.sourceBalanceStrategies)} vs ${formatSourceBalanceStrategies(leaderTrace.sourceBalanceStrategies)}`
+    });
+  }
+  rows.push(leadDriftRow, leadMediaDriftRow, sqlitePlannerDriftRow, routingDriftRow);
+  rows.push({
+    label: "Final delta",
+    value: formatSignedDelta(trace.averageFinalCount - leaderTrace.averageFinalCount, 1)
+  }, {
+    label: "Vector delta",
+    value: formatSignedDelta(trace.averageVectorCount - leaderTrace.averageVectorCount, 1)
+  }, {
+    label: "Lexical delta",
+    value: formatSignedDelta(trace.averageLexicalCount - leaderTrace.averageLexicalCount, 1)
+  }, {
+    label: "Transform delta",
+    value: formatTraceCountDelta(trace.transformedCases - leaderTrace.transformedCases)
+  }, {
+    label: "Balanced delta",
+    value: formatTraceCountDelta(trace.balancedCases - leaderTrace.balancedCases)
+  }, {
+    label: "Round robin delta",
+    value: formatTraceCountDelta(trace.roundRobinCases - leaderTrace.roundRobinCases)
+  });
+  if (stageDelta) {
+    rows.push({ label: "Stage delta", value: stageDelta });
+  }
+  return rows;
+};
+var buildRAGRetrievalComparisonPresentations = (comparison) => {
+  const leader = comparison.entries[0];
+  return comparison.entries.map((entry) => ({
+    diffLabel: leader?.label ?? "Leader",
+    diffRows: buildRAGComparisonTraceDiffRows(entry, leader),
+    summary: formatRetrievalComparisonHeadline(entry),
+    id: entry.retrievalId,
+    label: entry.label,
+    traceSummaryRows: buildRAGComparisonTraceSummaryRows(entry)
+  }));
+};
+var buildRAGRetrievalComparisonOverviewPresentation = (comparison) => buildComparisonOverviewPresentation({
+  entries: comparison.entries,
+  resolveEntry: (id) => comparison.entries.find((entry) => entry.retrievalId === id),
+  resolveLabel: (id) => comparison.entries.find((entry) => entry.retrievalId === id)?.label ?? id ?? "n/a",
+  summary: comparison.summary
+});
+var buildRAGRerankerComparisonPresentations = (comparison) => {
+  const leader = comparison.entries[0];
+  return comparison.entries.map((entry) => ({
+    diffLabel: leader?.label ?? "Leader",
+    diffRows: buildRAGComparisonTraceDiffRows(entry, leader),
+    summary: formatRerankerComparisonHeadline(entry),
+    id: entry.rerankerId,
+    label: entry.label,
+    traceSummaryRows: buildRAGComparisonTraceSummaryRows(entry)
+  }));
+};
+var buildRAGRerankerComparisonOverviewPresentation = (comparison) => buildComparisonOverviewPresentation({
+  entries: comparison.entries,
+  resolveEntry: (id) => comparison.entries.find((entry) => entry.rerankerId === id),
+  resolveLabel: (id) => comparison.entries.find((entry) => entry.rerankerId === id)?.label ?? id ?? "n/a",
+  summary: comparison.summary
+});
+var buildRAGGroundingProviderPresentations = (entries) => entries.map((entry) => ({
+  summary: [
+    entry.label,
+    `passing ${formatEvaluationPassingRate(entry.response.passingRate)}`,
+    `citation f1 ${entry.response.summary.averageCitationF1.toFixed(3)}`,
+    `resolved ${formatEvaluationPassingRate(entry.response.summary.averageResolvedCitationRate)}`,
+    `latency ${entry.elapsedMs.toFixed(1)}ms`
+  ].join(" \xB7 "),
+  id: entry.providerKey,
+  label: entry.label
+}));
+var buildRAGGroundingProviderOverviewPresentation = (input) => {
+  const resolveLabel = (key) => input.entries.find((entry) => entry.providerKey === key)?.label ?? key ?? "n/a";
+  const winnerLabel = resolveLabel(input.summary.bestByPassingRate);
+  const winnerEntry = input.entries.find((entry) => entry.providerKey === input.summary.bestByPassingRate);
+  return {
+    rows: [
+      {
+        label: "Best passing rate",
+        value: resolveLabel(input.summary.bestByPassingRate)
+      },
+      {
+        label: "Best citation F1",
+        value: resolveLabel(input.summary.bestByAverageCitationF1)
+      },
+      {
+        label: "Best resolved citations",
+        value: resolveLabel(input.summary.bestByResolvedCitationRate)
+      },
+      {
+        label: "Fastest",
+        value: resolveLabel(input.summary.fastest)
+      }
+    ],
+    winnerLabel,
+    summary: winnerEntry ? `passing ${formatEvaluationPassingRate(winnerEntry.response.passingRate)} \xB7 citation f1 ${winnerEntry.response.summary.averageCitationF1.toFixed(3)} \xB7 resolved ${formatEvaluationPassingRate(winnerEntry.response.summary.averageResolvedCitationRate)}` : "Stored workflow evaluation"
+  };
+};
+var buildRAGRetrievalOverviewPresentation = (comparison) => ({
+  rows: buildRAGRetrievalComparisonOverviewPresentation(comparison).rows
+});
+var buildRAGRerankerOverviewPresentation = (comparison) => ({
+  rows: buildRAGRerankerComparisonOverviewPresentation(comparison).rows
+});
+var buildRAGGroundingOverviewPresentation = (input) => ({
+  rows: [
+    {
+      label: "Grounding",
+      value: formatGroundingHistorySummaryValue(input.groundingEvaluation)
+    },
+    ...input.groundingProviderOverview?.rows ?? [
+      {
+        label: "Grounding providers",
+        value: "Configure an AI provider to compare grounded answers."
+      }
+    ]
+  ]
+});
+var buildRAGQualityOverviewPresentation = (input) => ({
+  rows: [
+    ...buildRAGRetrievalOverviewPresentation(input.retrievalComparison).rows,
+    ...buildRAGRerankerOverviewPresentation(input.rerankerComparison).rows,
+    ...buildRAGGroundingOverviewPresentation({
+      groundingEvaluation: input.groundingEvaluation,
+      groundingProviderOverview: input.groundingProviderOverview
+    }).rows
+  ]
+});
+var buildRAGGroundingProviderCaseComparisonPresentations = (comparisons) => comparisons.map((comparison) => {
+  const resolveLabel = (key) => comparison.entries.find((entry) => entry.providerKey === key)?.label ?? key ?? "n/a";
+  return {
+    caseId: comparison.caseId,
+    label: comparison.label,
+    rows: [
+      {
+        label: "Best grounded",
+        value: resolveLabel(comparison.summary.bestByStatus)
+      },
+      {
+        label: "Best citation F1",
+        value: resolveLabel(comparison.summary.bestByCitationF1)
+      },
+      {
+        label: "Best resolved citations",
+        value: resolveLabel(comparison.summary.bestByResolvedCitationRate)
+      },
+      ...comparison.entries.map((entry) => ({
+        label: entry.label,
+        value: [
+          entry.status.toUpperCase(),
+          `coverage ${entry.coverage}`,
+          `f1 ${entry.citationF1.toFixed(3)}`,
+          `resolved ${formatEvaluationPassingRate(entry.resolvedCitationRate)}`,
+          `matched ${entry.matchedIds.join(", ") || "none"}`,
+          `missing ${entry.missingIds.join(", ") || "none"}`,
+          `extra ${entry.extraIds.join(", ") || "none"}`,
+          `answer ${entry.answerExcerpt || "n/a"}`
+        ].join(" \xB7 ")
+      }))
+    ],
+    summary: [
+      `Best grounded: ${resolveLabel(comparison.summary.bestByStatus)}`,
+      `Best citation F1: ${resolveLabel(comparison.summary.bestByCitationF1)}`,
+      `Best resolved citations: ${resolveLabel(comparison.summary.bestByResolvedCitationRate)}`
+    ].join(" \xB7 ")
+  };
+});
+var buildRAGEvaluationHistoryRows = (history) => {
+  if (!history?.latestRun) {
+    return [
+      { label: "History", value: "No persisted benchmark runs yet." }
+    ];
+  }
+  const rows = [
+    { label: "Runs recorded", value: String(history.runs.length) },
+    {
+      label: "Latest",
+      value: `${history.latestRun.label} \xB7 ${formatEvaluationSummary(history.latestRun.response)}`
+    }
+  ];
+  if (history.latestRun.traceSummary) {
+    rows.push({
+      label: "Latest trace",
+      value: `${formatTraceModes(history.latestRun.traceSummary.modes)} \xB7 balance ${formatSourceBalanceStrategies(history.latestRun.traceSummary.sourceBalanceStrategies)} \xB7 final ${history.latestRun.traceSummary.averageFinalCount.toFixed(1)} \xB7 vector ${history.latestRun.traceSummary.averageVectorCount.toFixed(1)} \xB7 lexical ${history.latestRun.traceSummary.averageLexicalCount.toFixed(1)}`
+    });
+  }
+  if (history.previousRun) {
+    rows.push({
+      label: "Previous",
+      value: `${history.previousRun.label} \xB7 ${formatEvaluationSummary(history.previousRun.response)}`
+    });
+  }
+  if (!history.diff) {
+    rows.push({
+      label: "History diff",
+      value: "Run the benchmark again to diff regressions over time."
+    });
+    return rows;
+  }
+  rows.push({
+    label: "Passing delta",
+    value: formatSignedDelta(history.diff.summaryDelta.passingRate, 1, "%")
+  }, {
+    label: "Average F1 delta",
+    value: formatSignedDelta(history.diff.summaryDelta.averageF1, 3)
+  }, {
+    label: "Latency delta",
+    value: formatSignedDelta(history.diff.summaryDelta.averageLatencyMs, 1, "ms")
+  }, {
+    label: "Improved",
+    value: formatHistoryCaseLabels(history.diff.improvedCases)
+  }, {
+    label: "Regressed",
+    value: formatHistoryCaseLabels(history.diff.regressedCases)
+  }, {
+    label: "Lead drift",
+    value: formatTraceLeadChanges(history.diff.traceLeadChanges)
+  }, {
+    label: "SQLite planner shift",
+    value: formatHistorySQLitePlannerShift(history)
+  }, {
+    label: "Trace routing shift",
+    value: formatHistoryRoutingShift(history)
+  });
+  if (history.previousRun) {
+    const currentEntityView = buildRAGEvaluationEntityQualityView(history.latestRun.response);
+    const previousEntityView = buildRAGEvaluationEntityQualityView(history.previousRun.response);
+    rows.push({
+      label: "Source regression hotspots",
+      value: formatEntityRegressionHotspots(currentEntityView.bySource, previousEntityView.bySource, (entry) => entry.averageF1, "f1")
+    }, {
+      label: "Document regression hotspots",
+      value: formatEntityRegressionHotspots(currentEntityView.byDocument, previousEntityView.byDocument, (entry) => entry.averageF1, "f1")
+    });
+  }
+  if (history.diff.traceSummaryDelta) {
+    rows.push({
+      label: "Trace mode shift",
+      value: history.diff.traceSummaryDelta.modesChanged ? "changed" : "stable"
+    }, {
+      label: "Trace balance shift",
+      value: history.diff.traceSummaryDelta.sourceBalanceStrategiesChanged ? "changed" : "stable"
+    }, {
+      label: "Trace final delta",
+      value: formatSignedDelta(history.diff.traceSummaryDelta.averageFinalCount, 1)
+    }, {
+      label: "Trace vector delta",
+      value: formatSignedDelta(history.diff.traceSummaryDelta.averageVectorCount, 1)
+    }, {
+      label: "Trace lexical delta",
+      value: formatSignedDelta(history.diff.traceSummaryDelta.averageLexicalCount, 1)
+    }, {
+      label: "Trace balanced delta",
+      value: formatTraceCountDelta(history.diff.traceSummaryDelta.balancedCases)
+    }, {
+      label: "Trace round robin delta",
+      value: formatTraceCountDelta(history.diff.traceSummaryDelta.roundRobinCases)
+    }, {
+      label: "Trace transform delta",
+      value: formatTraceCountDelta(history.diff.traceSummaryDelta.transformedCases)
+    }, {
+      label: "Trace variant delta",
+      value: formatTraceCountDelta(history.diff.traceSummaryDelta.variantCases)
+    });
+    const stageDelta = Object.entries(history.diff.traceSummaryDelta.stageCounts ?? {}).map(([stage, count]) => `${stage} ${formatTraceCountDelta(count)}`).join(", ");
+    if (stageDelta) {
+      rows.push({ label: "Trace stage delta", value: stageDelta });
+    }
+  }
+  if (history.caseTraceSnapshots.length > 0) {
+    const changedCases = history.caseTraceSnapshots.filter((entry) => entry.traceChange === "changed");
+    rows.push({
+      label: "Trace drift cases",
+      value: changedCases.length > 0 ? changedCases.map((entry) => entry.label ?? entry.caseId).slice(0, 4).join(", ") : "none"
+    });
+    rows.push({
+      label: "Lead media cues",
+      value: Array.from(new Set(history.caseTraceSnapshots.map((entry) => formatLeadMediaCueSummary({
+        leadChannelAttributionCue: entry.leadChannelAttributionCue,
+        leadChannelCue: entry.leadChannelCue,
+        leadContinuityCue: entry.leadContinuityCue,
+        leadSpeakerAttributionCue: entry.leadSpeakerAttributionCue,
+        leadSpeakerCue: entry.leadSpeakerCue
+      })).filter((value) => value !== "none"))).slice(0, 3).join(" \xB7 ") || "none"
+    });
+  }
+  return rows;
+};
+var buildRAGEvaluationCaseTracePresentations = (history) => {
+  if (!history?.caseTraceSnapshots.length) {
+    return [];
+  }
+  return history.caseTraceSnapshots.map((entry) => {
+    const label = entry.label ?? entry.caseId;
+    const currentMode = entry.traceMode ?? "no-trace";
+    const previousMode = entry.previousTraceMode ?? "n/a";
+    const currentBalance = entry.sourceBalanceStrategy ?? "cap";
+    const previousBalance = entry.previousSourceBalanceStrategy ?? "n/a";
+    const currentVariants = entry.variantQueries.length > 0 ? entry.variantQueries.join(", ") : "none";
+    const previousVariants = entry.previousVariantQueries.length > 0 ? entry.previousVariantQueries.join(", ") : "none";
+    const currentStages = Object.keys(entry.stageCounts).length > 0 ? Object.entries(entry.stageCounts).map(([stage, count]) => `${stage} ${count}`).join(", ") : "none";
+    const previousStages = Object.keys(entry.previousStageCounts).length > 0 ? Object.entries(entry.previousStageCounts).map(([stage, count]) => `${stage} ${count}`).join(", ") : "none";
+    const currentLeadContext = entry.topContextLabel ?? "n/a";
+    const previousLeadContext = entry.previousTopContextLabel ?? "n/a";
+    const currentLeadLocation = entry.topLocatorLabel ?? "n/a";
+    const previousLeadLocation = entry.previousTopLocatorLabel ?? "n/a";
+    const currentBoundary = entry.sourceAwareChunkReasonLabel ?? "n/a";
+    const previousBoundary = entry.previousSourceAwareChunkReasonLabel ?? "n/a";
+    const currentScope = entry.sourceAwareUnitScopeLabel ?? "n/a";
+    const previousScope = entry.previousSourceAwareUnitScopeLabel ?? "n/a";
+    const currentMediaCues = formatLeadMediaCueSummary({
+      leadChannelAttributionCue: entry.leadChannelAttributionCue,
+      leadChannelCue: entry.leadChannelCue,
+      leadContinuityCue: entry.leadContinuityCue,
+      leadSpeakerAttributionCue: entry.leadSpeakerAttributionCue,
+      leadSpeakerCue: entry.leadSpeakerCue
+    });
+    const previousMediaCues = formatLeadMediaCueSummary({
+      leadChannelAttributionCue: entry.previousLeadChannelAttributionCue,
+      leadChannelCue: entry.previousLeadChannelCue,
+      leadContinuityCue: entry.previousLeadContinuityCue,
+      leadSpeakerAttributionCue: entry.previousLeadSpeakerAttributionCue,
+      leadSpeakerCue: entry.previousLeadSpeakerCue
+    });
+    const leadSummary = entry.topLocatorLabel ?? entry.topContextLabel ?? entry.sourceAwareUnitScopeLabel ?? "n/a";
+    const previousLeadSummary = entry.previousTopLocatorLabel ?? entry.previousTopContextLabel ?? entry.previousSourceAwareUnitScopeLabel ?? "n/a";
+    return {
+      caseId: entry.caseId,
+      label,
+      summary: `${entry.traceChange} \xB7 ${previousMode}\u2192${currentMode} \xB7 ${previousBalance}\u2192${currentBalance} \xB7 lead ${previousLeadSummary}\u2192${leadSummary} \xB7 final ${entry.previousFinalCount ?? 0}\u2192${entry.finalCount}`,
+      traceChange: entry.traceChange,
+      rows: [
+        { label: "Query", value: entry.query },
+        { label: "Trace change", value: entry.traceChange },
+        { label: "Mode", value: `${previousMode}\u2192${currentMode}` },
+        {
+          label: "Balance",
+          value: `${previousBalance}\u2192${currentBalance}`
+        },
+        {
+          label: "Transformed query",
+          value: `${entry.previousTransformedQuery?.trim() || "n/a"}\u2192${entry.transformedQuery?.trim() || "n/a"}`
+        },
+        {
+          label: "Final",
+          value: `${entry.previousFinalCount ?? 0}\u2192${entry.finalCount}`
+        },
+        {
+          label: "Vector",
+          value: `${entry.previousVectorCount ?? 0}\u2192${entry.vectorCount}`
+        },
+        {
+          label: "Lexical",
+          value: `${entry.previousLexicalCount ?? 0}\u2192${entry.lexicalCount}`
+        },
+        {
+          label: "Candidate topK",
+          value: `${entry.previousCandidateTopK ?? 0}\u2192${entry.candidateTopK}`
+        },
+        {
+          label: "Lexical topK",
+          value: `${entry.previousLexicalTopK ?? 0}\u2192${entry.lexicalTopK}`
+        },
+        {
+          label: "Variants",
+          value: `${previousVariants}\u2192${currentVariants}`
+        },
+        {
+          label: "Lead context",
+          value: `${previousLeadContext}\u2192${currentLeadContext}`
+        },
+        {
+          label: "Lead location",
+          value: `${previousLeadLocation}\u2192${currentLeadLocation}`
+        },
+        {
+          label: "Chunk boundary",
+          value: `${previousBoundary}\u2192${currentBoundary}`
+        },
+        {
+          label: "Source-aware scope",
+          value: `${previousScope}\u2192${currentScope}`
+        },
+        {
+          label: "Lead media cues",
+          value: `${previousMediaCues}\u2192${currentMediaCues}`
+        },
+        {
+          label: "Stages",
+          value: `${previousStages}\u2192${currentStages}`
+        },
+        { label: "Status", value: entry.status }
+      ]
+    };
+  });
+};
+var buildRAGEvaluationHistoryPresentation = (history) => ({
+  caseTraces: buildRAGEvaluationCaseTracePresentations(history),
+  rows: buildRAGEvaluationHistoryRows(history),
+  summary: history?.latestRun ? history.latestRun.label : "No persisted benchmark runs yet."
+});
+var buildRAGEvaluationSuiteSnapshotRows = (history) => {
+  if (!history?.latestSnapshot) {
+    return [
+      { label: "Suite snapshots", value: "No saved suite snapshots yet." }
+    ];
+  }
+  const rows = [
+    {
+      label: "Snapshots recorded",
+      value: String(history.snapshots.length)
+    },
+    {
+      label: "Latest snapshot",
+      value: `v${history.latestSnapshot.version} \xB7 ${history.latestSnapshot.caseCount} cases`
+    }
+  ];
+  if (history.previousSnapshot) {
+    rows.push({
+      label: "Previous snapshot",
+      value: `v${history.previousSnapshot.version} \xB7 ${history.previousSnapshot.caseCount} cases`
+    });
+  }
+  if (!history.diff) {
+    rows.push({
+      label: "Snapshot diff",
+      value: "Save another suite snapshot to compare dataset changes."
+    });
+    return rows;
+  }
+  rows.push({
+    label: "Case count change",
+    value: formatSignedDelta(history.diff.caseCountDelta)
+  }, {
+    label: "Added cases",
+    value: history.diff.addedCaseIds.length > 0 ? history.diff.addedCaseIds.join(", ") : "none"
+  }, {
+    label: "Removed cases",
+    value: history.diff.removedCaseIds.length > 0 ? history.diff.removedCaseIds.join(", ") : "none"
+  }, {
+    label: "Changed cases",
+    value: history.diff.changedCaseIds.length > 0 ? history.diff.changedCaseIds.join(", ") : "none"
+  }, {
+    label: "Order changed",
+    value: history.diff.orderChanged ? "changed" : "stable"
+  });
+  return rows;
+};
+var buildRAGEvaluationSuiteSnapshotPresentations = (history) => (history?.snapshots ?? []).map((snapshot) => ({
+  id: snapshot.id,
+  label: snapshot.label ?? snapshot.suiteId,
+  rows: [
+    { label: "Version", value: `v${snapshot.version}` },
+    { label: "Created", value: formatDateLabel(snapshot.createdAt) },
+    { label: "Cases", value: String(snapshot.caseCount) },
+    {
+      label: "Case ids",
+      value: snapshot.suite.input.cases.map((entry) => entry.id).join(", ") || "none"
+    }
+  ],
+  summary: `v${snapshot.version} \xB7 ${snapshot.caseCount} cases`,
+  version: snapshot.version
+}));
+var buildRAGEvaluationSuiteSnapshotHistoryPresentation = (history) => ({
+  rows: buildRAGEvaluationSuiteSnapshotRows(history),
+  snapshots: buildRAGEvaluationSuiteSnapshotPresentations(history),
+  summary: history?.latestSnapshot ? `v${history.latestSnapshot.version}` : "No saved suite snapshots yet."
+});
+var buildRAGAnswerGroundingCaseSnapshotPresentations = (history) => {
+  if (!history?.caseSnapshots.length) {
+    return [];
+  }
+  return history.caseSnapshots.map((entry) => {
+    const label = entry.label ?? entry.caseId;
+    return {
+      answerChange: entry.answerChange,
+      caseId: entry.caseId,
+      label,
+      rows: [
+        {
+          label: "Query",
+          value: entry.query?.trim().length ? entry.query : "n/a"
+        },
+        { label: "Answer change", value: entry.answerChange },
+        { label: "Coverage", value: entry.coverage },
+        {
+          label: "Resolved citations",
+          value: `${entry.resolvedCitationCount}/${entry.citationCount}`
+        },
+        {
+          label: "Resolved citation rate",
+          value: entry.resolvedCitationRate.toFixed(3)
+        },
+        { label: "Citation F1", value: entry.citationF1.toFixed(3) },
+        {
+          label: "Reference count",
+          value: String(entry.referenceCount)
+        },
+        {
+          label: "Cited IDs",
+          value: entry.citedIds.length > 0 ? entry.citedIds.join(", ") : "none"
+        },
+        {
+          label: "Matched IDs",
+          value: entry.matchedIds.length > 0 ? entry.matchedIds.join(", ") : "none"
+        },
+        {
+          label: "Missing IDs",
+          value: entry.missingIds.length > 0 ? entry.missingIds.join(", ") : "none"
+        },
+        {
+          label: "Extra IDs",
+          value: entry.extraIds.length > 0 ? entry.extraIds.join(", ") : "none"
+        },
+        {
+          label: "Unresolved refs",
+          value: entry.ungroundedReferenceNumbers.length > 0 ? entry.ungroundedReferenceNumbers.join(", ") : "none"
+        },
+        {
+          label: "Answer",
+          value: entry.answer.trim().length > 0 ? entry.answer : "n/a"
+        },
+        {
+          label: "Previous answer",
+          value: entry.previousAnswer && entry.previousAnswer.trim().length > 0 ? entry.previousAnswer : "n/a"
+        }
+      ],
+      summary: `${entry.answerChange} \xB7 ${entry.coverage} \xB7 resolved ${entry.resolvedCitationCount}/${entry.citationCount} \xB7 refs ${entry.referenceCount}`
+    };
+  });
+};
+var buildRAGAnswerGroundingHistoryRows = (history) => {
+  if (!history?.latestRun) {
+    return [{ label: "History", value: "No persisted provider runs yet." }];
+  }
+  const rows = [
+    { label: "Runs recorded", value: String(history.runs.length) },
+    {
+      label: "Latest",
+      value: `${history.latestRun.label} \xB7 ${formatGroundingHistorySummaryValue(history.latestRun.response)}`
+    }
+  ];
+  if (history.previousRun) {
+    rows.push({
+      label: "Previous",
+      value: `${history.previousRun.label} \xB7 ${formatGroundingHistorySummaryValue(history.previousRun.response)}`
+    });
+  }
+  if (history.leaderboard[0]) {
+    rows.push({
+      label: "Best recorded",
+      value: `#${history.leaderboard[0].rank} \xB7 ${history.leaderboard[0].label} \xB7 passing ${formatEvaluationPassingRate(history.leaderboard[0].passingRate)} \xB7 citation f1 ${history.leaderboard[0].averageCitationF1.toFixed(3)} \xB7 resolved ${formatEvaluationPassingRate(history.leaderboard[0].averageResolvedCitationRate)}`
+    });
+  }
+  if (history.caseSnapshots.length > 0) {
+    const changedAnswers = history.caseSnapshots.filter((entry) => entry.answerChange === "changed").length;
+    rows.push({
+      label: "Answer drift",
+      value: `${changedAnswers}/${history.caseSnapshots.length} changed`
+    });
+  }
+  if (!history.diff) {
+    rows.push({
+      label: "History diff",
+      value: "Run the provider comparison again to diff grounding regressions over time."
+    });
+    return rows;
+  }
+  rows.push({
+    label: "Passing delta",
+    value: formatSignedDelta(history.diff.summaryDelta.passingRate, 1, "%")
+  }, {
+    label: "Citation F1 delta",
+    value: formatSignedDelta(history.diff.summaryDelta.averageCitationF1, 3)
+  }, {
+    label: "Resolved citation delta",
+    value: formatSignedDelta(history.diff.summaryDelta.averageResolvedCitationRate * 100, 1, "%")
+  }, {
+    label: "Improved",
+    value: formatGroundingHistoryCaseLabels(history.diff.improvedCases)
+  }, {
+    label: "Regressed",
+    value: formatGroundingHistoryCaseLabels(history.diff.regressedCases)
+  });
+  if (history.previousRun) {
+    const currentEntityView = buildRAGAnswerGroundingEntityQualityView(history.latestRun.response);
+    const previousEntityView = buildRAGAnswerGroundingEntityQualityView(history.previousRun.response);
+    rows.push({
+      label: "Source regression hotspots",
+      value: formatEntityRegressionHotspots(currentEntityView.bySource, previousEntityView.bySource, (entry) => entry.averageCitationF1, "citation f1")
+    }, {
+      label: "Document regression hotspots",
+      value: formatEntityRegressionHotspots(currentEntityView.byDocument, previousEntityView.byDocument, (entry) => entry.averageCitationF1, "citation f1")
+    });
+  }
+  return rows;
+};
+var buildRAGAnswerGroundingHistoryPresentation = (history) => ({
+  caseSnapshots: buildRAGAnswerGroundingCaseSnapshotPresentations(history),
+  rows: buildRAGAnswerGroundingHistoryRows(history),
+  summary: history?.latestRun ? history.latestRun.label : "No persisted provider runs yet."
+});
+var formatFailureCounts = (failureCounts) => {
+  const entries = Object.entries(failureCounts).sort((left, right) => {
+    if (right[1] !== left[1]) {
+      return right[1] - left[1];
+    }
+    return left[0].localeCompare(right[0]);
+  });
+  return entries.length > 0 ? entries.map(([key, count]) => `${key} ${count}`).join(" \xB7 ") : "none";
+};
+var formatFailureCountDelta = (current, previous) => {
+  const deltas = Object.keys({ ...current, ...previous }).map((key) => ({
+    delta: (current[key] ?? 0) - (previous[key] ?? 0),
+    key
+  })).filter((entry) => entry.delta > 0).sort((left, right) => {
+    if (right.delta !== left.delta) {
+      return right.delta - left.delta;
+    }
+    return left.key.localeCompare(right.key);
+  });
+  return deltas.length > 0 ? deltas.slice(0, 3).map((entry) => `${entry.key} +${entry.delta}`).join(" \xB7 ") : "stable";
+};
+var formatEntityRegressionHotspots = (currentEntries, previousEntries, metricSelector, metricLabel) => {
+  const previousMap = new Map(previousEntries.map((entry) => [entry.key, entry]));
+  const regressions = currentEntries.map((entry) => {
+    const previous = previousMap.get(entry.key);
+    const passDelta = entry.passingRate - (previous?.passingRate ?? 0);
+    const metricDelta = metricSelector(entry) - (previous ? metricSelector(previous) : 0);
+    const failureDelta = formatFailureCountDelta(entry.failureCounts, previous?.failureCounts ?? {});
+    return {
+      entry,
+      failureDelta,
+      metricDelta,
+      passDelta
+    };
+  }).filter((entry) => entry.passDelta < 0 || entry.metricDelta < 0 || entry.failureDelta !== "stable").sort((left, right) => {
+    if (left.passDelta !== right.passDelta) {
+      return left.passDelta - right.passDelta;
+    }
+    if (left.metricDelta !== right.metricDelta) {
+      return left.metricDelta - right.metricDelta;
+    }
+    return left.entry.label.localeCompare(right.entry.label);
+  });
+  return regressions.length > 0 ? regressions.slice(0, 3).map(({ entry, failureDelta, metricDelta, passDelta }) => `${entry.label} pass ${formatSignedDelta(passDelta, 1, "%")} \xB7 ${metricLabel} ${formatSignedDelta(metricDelta, 3)} \xB7 ${failureDelta}`).join(" | ") : "none";
+};
+var buildEvaluationEntityPresentation = (entry) => ({
+  key: entry.key,
+  label: entry.label,
+  rows: [
+    { label: "Entity type", value: entry.entityType },
+    { label: "Cases", value: String(entry.totalCases) },
+    {
+      label: "Status mix",
+      value: `${entry.passedCases} pass \xB7 ${entry.partialCases} partial \xB7 ${entry.failedCases} fail`
+    },
+    {
+      label: "Passing rate",
+      value: formatEvaluationPassingRate(entry.passingRate)
+    },
+    { label: "Average F1", value: entry.averageF1.toFixed(3) },
+    {
+      label: "Failure classes",
+      value: formatFailureCounts(entry.failureCounts)
+    },
+    {
+      label: "Cases",
+      value: entry.caseIds.length > 0 ? entry.caseIds.join(", ") : "none"
+    }
+  ],
+  summary: `${entry.entityType} \xB7 passing ${formatEvaluationPassingRate(entry.passingRate)} \xB7 f1 ${entry.averageF1.toFixed(3)} \xB7 failures ${formatFailureCounts(entry.failureCounts)}`
+});
+var buildGroundingEntityPresentation = (entry) => ({
+  key: entry.key,
+  label: entry.label,
+  rows: [
+    { label: "Entity type", value: entry.entityType },
+    { label: "Cases", value: String(entry.totalCases) },
+    {
+      label: "Status mix",
+      value: `${entry.passedCases} pass \xB7 ${entry.partialCases} partial \xB7 ${entry.failedCases} fail`
+    },
+    {
+      label: "Passing rate",
+      value: formatEvaluationPassingRate(entry.passingRate)
+    },
+    {
+      label: "Average citation F1",
+      value: entry.averageCitationF1.toFixed(3)
+    },
+    {
+      label: "Average resolved citation rate",
+      value: formatEvaluationPassingRate(entry.averageResolvedCitationRate * 100)
+    },
+    {
+      label: "Failure classes",
+      value: formatFailureCounts(entry.failureCounts)
+    },
+    {
+      label: "Cases",
+      value: entry.caseIds.length > 0 ? entry.caseIds.join(", ") : "none"
+    }
+  ],
+  summary: `${entry.entityType} \xB7 passing ${formatEvaluationPassingRate(entry.passingRate)} \xB7 citation f1 ${entry.averageCitationF1.toFixed(3)} \xB7 failures ${formatFailureCounts(entry.failureCounts)}`
+});
+var buildRAGEvaluationEntityQualityPresentation = (view, entityType) => {
+  const entities = entityType === "source" ? view.bySource.map(buildEvaluationEntityPresentation) : view.byDocument.map(buildEvaluationEntityPresentation);
+  return {
+    entities,
+    rows: [
+      { label: "Entity type", value: entityType },
+      { label: "Entities tracked", value: String(entities.length) },
+      {
+        label: "Best coverage",
+        value: entities[0]?.summary ?? "No entity quality data yet."
+      }
+    ],
+    summary: entities[0]?.label ?? `No ${entityType === "source" ? "source" : "document"} quality data yet.`
+  };
+};
+var buildRAGAnswerGroundingEntityQualityPresentation = (view, entityType) => {
+  const entities = entityType === "source" ? view.bySource.map(buildGroundingEntityPresentation) : view.byDocument.map(buildGroundingEntityPresentation);
+  return {
+    entities,
+    rows: [
+      { label: "Entity type", value: entityType },
+      { label: "Entities tracked", value: String(entities.length) },
+      {
+        label: "Best coverage",
+        value: entities[0]?.summary ?? "No entity quality data yet."
+      }
+    ],
+    summary: entities[0]?.label ?? `No ${entityType === "source" ? "source" : "document"} quality data yet.`
+  };
+};
+
 // src/ai/rag/quality.ts
 var DEFAULT_TOP_K = 6;
 var DEFAULT_HISTORY_LIMIT = 20;
 var DEFAULT_SEARCH_TRACE_TABLE_NAME = "rag_search_traces";
+var getTraceLabelString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+var getTraceLabelNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var formatTraceSpreadsheetTableLabel = (tableIndex, tableCount) => {
+  if (typeof tableIndex !== "number" || !Number.isFinite(tableIndex) || tableIndex < 1) {
+    return;
+  }
+  if (typeof tableCount === "number" && Number.isFinite(tableCount) && tableCount >= tableIndex) {
+    return `Table ${tableIndex} of ${tableCount}`;
+  }
+  return `Table ${tableIndex}`;
+};
+var formatTraceSourceAwareChunkReason = (value) => {
+  const reason = getTraceLabelString(value);
+  if (reason === "section_boundary") {
+    return "Chunk boundary section";
+  }
+  if (reason === "size_limit") {
+    return "Chunk boundary size limit";
+  }
+  if (reason === "source_native_unit") {
+    return "Chunk boundary source-native unit";
+  }
+  return;
+};
+var buildTraceSourceAwareUnitScopeLabel = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const sectionKind = getTraceLabelString(metadata.sectionKind);
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getTraceLabelString(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getTraceLabelString(metadata.sectionTitle) ?? sectionPath.at(-1);
+  const pdfTextKind = getTraceLabelString(metadata.pdfTextKind);
+  const officeBlockKind = getTraceLabelString(metadata.officeBlockKind);
+  const sheetName = getTraceLabelString(metadata.sheetName);
+  const spreadsheetTableLabel = formatTraceSpreadsheetTableLabel(getTraceLabelNumber(metadata.spreadsheetTableIndex), getTraceLabelNumber(metadata.spreadsheetTableCount));
+  const slideTitle = getTraceLabelString(metadata.slideTitle);
+  const slideNumber = getTraceLabelNumber(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : undefined);
+  if (sectionPath.length > 0 && (sectionKind === "markdown_heading" || sectionKind === "html_heading" || sectionKind === "office_heading" || sectionKind === undefined)) {
+    return `Source-aware section ${sectionPath.join(" > ")}`;
+  }
+  if (sectionKind === "pdf_block") {
+    if (pdfTextKind === "table_like" && sectionTitle) {
+      return `Source-aware PDF table block ${sectionTitle}`;
+    }
+    if (sectionTitle) {
+      return `Source-aware PDF block ${sectionTitle}`;
+    }
+    return "Source-aware PDF block";
+  }
+  if (sectionKind === "office_block") {
+    if (officeBlockKind && sectionTitle) {
+      return `Source-aware office ${officeBlockKind} block ${sectionTitle}`;
+    }
+    if (sectionTitle) {
+      return `Source-aware office block ${sectionTitle}`;
+    }
+    return "Source-aware office block";
+  }
+  if (sectionKind === "spreadsheet_rows" || sectionKind === undefined && (sheetName || spreadsheetTableLabel || getTraceLabelNumber(metadata.spreadsheetRowStart) !== undefined || getTraceLabelNumber(metadata.spreadsheetRowEnd) !== undefined)) {
+    if (sheetName && spreadsheetTableLabel) {
+      return `Source-aware spreadsheet ${sheetName} ${spreadsheetTableLabel}`;
+    }
+    if (sheetName) {
+      return `Source-aware spreadsheet ${sheetName}`;
+    }
+    return "Source-aware spreadsheet";
+  }
+  if (sectionKind === "presentation_slide") {
+    if (slideNumber && slideTitle) {
+      return `Source-aware slide ${slideNumber} ${slideTitle}`;
+    }
+    if (slideTitle) {
+      return `Source-aware slide ${slideTitle}`;
+    }
+    if (slideNumber) {
+      return `Source-aware slide ${slideNumber}`;
+    }
+    return "Source-aware slide";
+  }
+  return;
+};
+var buildEvaluationLeadSnapshot = (input) => {
+  const labels = buildRAGSourceLabels({
+    metadata: input?.metadata,
+    source: input?.source,
+    title: input?.title
+  });
+  return {
+    sourceAwareChunkReasonLabel: formatTraceSourceAwareChunkReason(input?.metadata?.sourceAwareChunkReason),
+    sourceAwareUnitScopeLabel: buildTraceSourceAwareUnitScopeLabel(input?.metadata),
+    topContextLabel: labels?.contextLabel,
+    topLocatorLabel: labels?.locatorLabel
+  };
+};
+var buildEvaluationLeadMediaCueSnapshot = (trace) => {
+  const rerankStep = trace?.steps.find((step) => step.stage === "rerank");
+  const metadata = rerankStep?.metadata ?? {};
+  return {
+    leadChannelAttributionCue: typeof metadata.leadChannelAttributionCue === "string" ? metadata.leadChannelAttributionCue : undefined,
+    leadChannelCue: typeof metadata.leadChannelCue === "string" ? metadata.leadChannelCue : undefined,
+    leadContinuityCue: typeof metadata.leadContinuityCue === "string" ? metadata.leadContinuityCue : undefined,
+    leadSpeakerAttributionCue: typeof metadata.leadSpeakerAttributionCue === "string" ? metadata.leadSpeakerAttributionCue : undefined,
+    leadSpeakerCue: typeof metadata.leadSpeakerCue === "string" ? metadata.leadSpeakerCue : undefined
+  };
+};
+var buildEvaluationSQLiteQueryPlanSnapshot = (trace) => {
+  const vectorStep = trace?.steps.find((step) => step.stage === "vector_search");
+  const metadata = vectorStep?.metadata ?? {};
+  return {
+    sqliteQueryBackfillCount: typeof metadata.sqliteQueryBackfillCount === "number" ? metadata.sqliteQueryBackfillCount : undefined,
+    sqliteQueryFilteredCandidates: typeof metadata.sqliteQueryFilteredCandidates === "number" ? metadata.sqliteQueryFilteredCandidates : undefined,
+    sqliteQueryFinalSearchK: typeof metadata.sqliteQueryFinalSearchK === "number" ? metadata.sqliteQueryFinalSearchK : undefined,
+    sqliteQueryInitialSearchK: typeof metadata.sqliteQueryInitialSearchK === "number" ? metadata.sqliteQueryInitialSearchK : undefined,
+    sqliteQueryMode: metadata.sqliteQueryMode === "json_fallback" || metadata.sqliteQueryMode === "native_vec0" ? metadata.sqliteQueryMode : undefined,
+    sqliteQueryPushdownApplied: typeof metadata.sqliteQueryPushdownApplied === "boolean" ? metadata.sqliteQueryPushdownApplied : undefined,
+    sqliteQueryPushdownClauseCount: typeof metadata.sqliteQueryPushdownClauseCount === "number" ? metadata.sqliteQueryPushdownClauseCount : undefined
+  };
+};
 var DEFAULT_RETRIEVAL_COMPARISON_HISTORY_TABLE_NAME = "rag_retrieval_comparison_history";
 var DEFAULT_RETRIEVAL_RELEASE_DECISION_TABLE_NAME = "rag_retrieval_release_decisions";
 var DEFAULT_RETRIEVAL_BASELINE_TABLE_NAME = "rag_retrieval_baselines";
@@ -804,6 +3840,151 @@ var parseJSONArray = (value, fallback) => {
   }
 };
 var normalizeExpectedIds = (input) => Array.from(new Set(input.map((item) => item.trim()).filter(Boolean)));
+var hasSourceExtension = (value, extensions) => {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return extensions.some((extension) => normalized.endsWith(extension));
+};
+var hasMetadataNumber = (metadata, key) => typeof metadata?.[key] === "number";
+var hasMetadataString = (metadata, key) => typeof metadata?.[key] === "string" && metadata[key] !== "";
+var hasMetadataArray = (metadata, key) => Array.isArray(metadata?.[key]) && metadata[key].length > 0;
+var detectSectionEvidence = (ids, sources = []) => sources.some((source) => hasMetadataArray(source.metadata, "sectionPath") || hasMetadataString(source.metadata, "sectionTitle") || hasMetadataString(source.metadata, "sectionKind"));
+var detectSectionGraphEvidence = (sources = []) => sources.some((source) => hasMetadataString(source.metadata, "sectionChunkId") || hasMetadataNumber(source.metadata, "sectionChunkIndex") || hasMetadataNumber(source.metadata, "sectionChunkCount") && Number(source.metadata?.sectionChunkCount) > 1);
+var detectSectionHierarchyEvidence = (sources = []) => sources.some((source) => {
+  const path = Array.isArray(source.metadata?.sectionPath) ? source.metadata.sectionPath.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+  return path.length > 1;
+});
+var detectSpreadsheetEvidence = (ids, sources = []) => ids.some((id) => hasSourceExtension(id, [".xlsx", ".xls", ".csv", ".ods", ".tsv"])) || sources.some((source) => hasSourceExtension(source.source, [
+  ".xlsx",
+  ".xls",
+  ".csv",
+  ".ods",
+  ".tsv"
+]) || hasMetadataString(source.metadata, "sheetName") || hasMetadataNumber(source.metadata, "spreadsheetRowStart") || hasMetadataNumber(source.metadata, "spreadsheetTableIndex"));
+var detectMediaEvidence = (ids, sources = []) => ids.some((id) => hasSourceExtension(id, [
+  ".mp3",
+  ".wav",
+  ".m4a",
+  ".aac",
+  ".ogg",
+  ".flac",
+  ".mp4",
+  ".mov",
+  ".mkv",
+  ".webm"
+])) || sources.some((source) => hasSourceExtension(source.source, [
+  ".mp3",
+  ".wav",
+  ".m4a",
+  ".aac",
+  ".ogg",
+  ".flac",
+  ".mp4",
+  ".mov",
+  ".mkv",
+  ".webm"
+]) || hasMetadataString(source.metadata, "mediaKind") || hasMetadataString(source.metadata, "speaker") || hasMetadataNumber(source.metadata, "startMs"));
+var detectOCREvidence = (ids, sources = []) => ids.some((id) => hasSourceExtension(id, [".png", ".jpg", ".jpeg", ".webp"])) || sources.some((source) => hasSourceExtension(source.source, [
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".webp"
+]) || hasMetadataNumber(source.metadata, "ocrConfidence") || hasMetadataNumber(source.metadata, "ocrRegionConfidence") || hasMetadataString(source.metadata, "ocrEngine") || source.metadata?.pdfTextMode === "ocr");
+var getRetrievalTrace = (trace) => trace && ("trace" in trace) ? trace.trace : trace;
+var classifyRAGEvaluationFailure = (input) => {
+  const classes = [];
+  if (input.expectedCount === 0) {
+    classes.push("no_expected_targets");
+  }
+  if (input.retrievedCount === 0) {
+    classes.push("no_results");
+  }
+  if (input.expectedCount > 0 && input.matchedCount === 0) {
+    classes.push("no_match");
+  }
+  if (input.expectedCount > 0 && input.matchedCount > 0 && input.matchedCount < input.expectedCount) {
+    classes.push("partial_recall");
+  }
+  if (input.retrievedIds.length > input.matchedCount) {
+    classes.push("extra_noise");
+  }
+  const sourceSignals = input.retrievedSources ?? [];
+  const relevantIds = [...input.missingIds, ...input.retrievedIds];
+  if ((input.missingIds.length > 0 || input.matchedCount === 0) && detectSectionEvidence(relevantIds, sourceSignals)) {
+    classes.push("section_evidence_miss");
+    if (detectSectionGraphEvidence(sourceSignals)) {
+      classes.push("section_graph_miss");
+    }
+    if (detectSectionHierarchyEvidence(sourceSignals)) {
+      classes.push("section_hierarchy_miss");
+    }
+  }
+  if ((input.missingIds.length > 0 || input.matchedCount === 0) && detectSpreadsheetEvidence(relevantIds, sourceSignals)) {
+    classes.push("spreadsheet_evidence_miss");
+  }
+  if ((input.missingIds.length > 0 || input.matchedCount === 0) && detectMediaEvidence(relevantIds, sourceSignals)) {
+    classes.push("media_evidence_miss");
+  }
+  if ((input.missingIds.length > 0 || input.matchedCount === 0) && detectOCREvidence(relevantIds, sourceSignals)) {
+    classes.push("ocr_evidence_miss");
+  }
+  const retrievalTrace = getRetrievalTrace(input.trace);
+  if ((input.retrievedCount === 0 || input.matchedCount === 0) && (retrievalTrace?.routingLabel || retrievalTrace?.routingReason)) {
+    classes.push("routing_miss");
+  }
+  return classes;
+};
+var classifyRAGGroundingFailure = (input) => {
+  const classes = [];
+  if (input.expectedCount === 0) {
+    classes.push("no_expected_targets");
+  }
+  if (input.citationCount === 0) {
+    classes.push("no_citations");
+  }
+  if (input.unresolvedCitationCount > 0) {
+    classes.push("unresolved_citations");
+  }
+  if (input.missingIds.length > 0 || input.matchedCount < input.expectedCount) {
+    classes.push("missing_expected_sources");
+  }
+  if (input.extraIds.length > 0) {
+    classes.push("extra_citations");
+  }
+  const sourceSignals = input.availableSources ?? [];
+  const relevantIds = [...input.missingIds, ...input.extraIds];
+  if ((input.missingIds.length > 0 || input.citationCount === 0) && detectSectionEvidence(relevantIds, sourceSignals)) {
+    classes.push("section_source_miss");
+    if (detectSectionGraphEvidence(sourceSignals)) {
+      classes.push("section_graph_source_miss");
+    }
+    if (detectSectionHierarchyEvidence(sourceSignals)) {
+      classes.push("section_hierarchy_source_miss");
+    }
+  }
+  if ((input.missingIds.length > 0 || input.citationCount === 0) && detectSpreadsheetEvidence(relevantIds, sourceSignals)) {
+    classes.push("spreadsheet_source_miss");
+  }
+  if ((input.missingIds.length > 0 || input.citationCount === 0) && detectMediaEvidence(relevantIds, sourceSignals)) {
+    classes.push("media_source_miss");
+  }
+  if ((input.missingIds.length > 0 || input.citationCount === 0) && detectOCREvidence(relevantIds, sourceSignals)) {
+    classes.push("ocr_source_miss");
+  }
+  return classes;
+};
+var normalizeSyntheticText = (value) => value.replace(/^#+\s*/gm, "").replace(/`+/g, "").replace(/\[(.*?)\]\((.*?)\)/g, "$1").replace(/\s+/g, " ").trim();
+var buildSyntheticEvaluationQuery = (document) => {
+  const title = normalizeSyntheticText(document.title);
+  const sourceTail = normalizeSyntheticText(document.source.split("/").at(-1) ?? document.source);
+  const text = normalizeSyntheticText(document.text ?? "");
+  const firstSentence = text.split(/(?<=[.!?])\s+/).map((entry) => entry.trim()).find((entry) => entry.length >= 24) ?? text.split(/\n+/).map((entry) => entry.trim()).find((entry) => entry.length >= 24) ?? title ?? sourceTail;
+  const prefixedSentence = title.length > 0 && firstSentence.toLowerCase().startsWith(title.toLowerCase()) ? firstSentence : [title, firstSentence].filter(Boolean).join(" ");
+  const queryTerms = normalizeSyntheticText(prefixedSentence).split(/\s+/).slice(0, 12).join(" ");
+  return queryTerms.length > 0 ? queryTerms : sourceTail;
+};
 var resolveEvaluationMode = (caseInput) => {
   if (normalizeStringArray(caseInput.expectedChunkIds).length > 0) {
     return "chunkId";
@@ -1279,6 +4460,7 @@ var evaluateRAGCollectionCases = async ({
       caseResult,
       filter: typeof input.cases?.[caseIndex]?.filter === "object" ? input.cases[caseIndex]?.filter : input.filter,
       retrieval: input.cases?.[caseIndex]?.retrieval ?? input.retrieval,
+      topResult: undefined,
       trace: undefined
     }));
   }
@@ -1315,11 +4497,14 @@ var evaluateRAGCollectionCases = async ({
         expectedIds,
         mode,
         query,
-        retrievedIds
+        retrievedIds,
+        retrievedSources: sources,
+        trace: searchOutcome.trace
       }),
       trace: searchOutcome.trace,
       filter: searchInput.filter,
-      retrieval: searchInput.retrieval
+      retrieval: searchInput.retrieval,
+      topResult: searchOutcome.results[0]
     };
   }));
 };
@@ -1507,6 +4692,44 @@ var normalizeHistoryRuns = (runs) => [...runs].sort(toHistorySortOrder);
 var normalizeRetrievalComparisonRuns = (runs) => [...runs].sort((left, right) => right.finishedAt - left.finishedAt);
 var toTraceSummaryRunSortOrder = (left, right) => right.finishedAt - left.finishedAt;
 var normalizeTraceSummaryRuns = (runs) => [...runs].sort(toTraceSummaryRunSortOrder);
+var applyRAGEvaluationHistoryPrunePolicy = ({
+  input,
+  runs,
+  sort
+}) => {
+  const sorted = sort(runs);
+  const targeted = sorted.filter((run) => !input?.suiteId || run.suiteId === input.suiteId);
+  const untouched = sorted.filter((run) => input?.suiteId && run.suiteId !== input.suiteId);
+  const now = input?.now ?? Date.now();
+  let kept = [...targeted];
+  if (typeof input?.maxAgeMs === "number" && Number.isFinite(input.maxAgeMs)) {
+    const cutoff = now - input.maxAgeMs;
+    kept = kept.filter((run) => {
+      const timestamp = run.finishedAt ?? run.createdAt ?? 0;
+      return timestamp >= cutoff;
+    });
+  }
+  if (typeof input?.maxRunsPerSuite === "number" && Number.isFinite(input.maxRunsPerSuite) && input.maxRunsPerSuite >= 0) {
+    const remainingBySuite = new Map;
+    kept = kept.filter((run) => {
+      const current = remainingBySuite.get(run.suiteId) ?? 0;
+      if (current >= input.maxRunsPerSuite) {
+        return false;
+      }
+      remainingBySuite.set(run.suiteId, current + 1);
+      return true;
+    });
+  }
+  const keptIds = new Set(kept.map((run) => run.id));
+  const removed = targeted.filter((run) => !keptIds.has(run.id));
+  const next = sort([...untouched, ...kept]);
+  return {
+    keptCount: next.length,
+    next,
+    removed,
+    removedCount: removed.length
+  };
+};
 var applyRAGSearchTracePrunePolicy = ({
   input,
   traces
@@ -1600,7 +4823,9 @@ var buildCaseDiff = (currentCase, previousCase) => ({
   previousMatchedIds: previousCase?.matchedIds ?? [],
   previousMissingIds: previousCase?.missingIds ?? [],
   previousStatus: previousCase?.status,
-  query: currentCase.query
+  previousFailureClasses: previousCase?.failureClasses ?? [],
+  query: currentCase.query,
+  currentFailureClasses: currentCase.failureClasses ?? []
 });
 var buildGroundingCaseDiff = (currentCase, previousCase) => ({
   answerChanged: typeof previousCase?.answer === "string" ? previousCase.answer !== currentCase.answer : true,
@@ -1623,6 +4848,7 @@ var buildGroundingCaseDiff = (currentCase, previousCase) => ({
   previousCitedIds: previousCase?.citedIds ?? [],
   previousCoverage: previousCase?.coverage,
   previousExtraIds: previousCase?.extraIds ?? [],
+  previousFailureClasses: previousCase?.failureClasses ?? [],
   previousMatchedIds: previousCase?.matchedIds ?? [],
   previousMissingIds: previousCase?.missingIds ?? [],
   previousReferenceCount: previousCase?.referenceCount,
@@ -1630,7 +4856,8 @@ var buildGroundingCaseDiff = (currentCase, previousCase) => ({
   previousStatus: previousCase?.status,
   previousUngroundedReferenceNumbers: previousCase?.groundedAnswer.ungroundedReferenceNumbers ?? [],
   previousUnresolvedCitationCount: previousCase?.unresolvedCitationCount,
-  query: currentCase.query
+  query: currentCase.query,
+  currentFailureClasses: currentCase.failureClasses ?? []
 });
 var buildGroundingCaseSnapshots = ({
   current,
@@ -1651,6 +4878,7 @@ var buildGroundingCaseSnapshots = ({
       citedIds: entry.citedIds,
       coverage: entry.coverage,
       extraIds: entry.extraIds,
+      failureClasses: entry.failureClasses,
       label: entry.label,
       matchedIds: entry.matchedIds,
       missingIds: entry.missingIds,
@@ -1682,15 +4910,40 @@ var buildEvaluationCaseTraceSnapshot = ({
   filter,
   retrieval,
   currentTrace,
-  previousTrace
+  previousTrace,
+  currentSnapshot,
+  topResult
 }) => {
   const stageCounts = currentTrace ? buildTraceStageCounts([currentTrace]) : {};
   const previousStageCounts = previousTrace?.stageCounts ?? {};
+  const currentLeadSnapshot = topResult || currentSnapshot ? buildEvaluationLeadSnapshot({
+    metadata: topResult?.metadata,
+    source: topResult?.source,
+    title: topResult?.title
+  }) : {};
+  const topContextLabel = currentLeadSnapshot.topContextLabel ?? currentSnapshot?.topContextLabel;
+  const topLocatorLabel = currentLeadSnapshot.topLocatorLabel ?? currentSnapshot?.topLocatorLabel;
+  const sourceAwareChunkReasonLabel = currentLeadSnapshot.sourceAwareChunkReasonLabel ?? currentSnapshot?.sourceAwareChunkReasonLabel;
+  const sourceAwareUnitScopeLabel = currentLeadSnapshot.sourceAwareUnitScopeLabel ?? currentSnapshot?.sourceAwareUnitScopeLabel;
+  const currentLeadMediaCueSnapshot = currentTrace ? buildEvaluationLeadMediaCueSnapshot(currentTrace) : {};
+  const currentSQLiteQueryPlanSnapshot = currentTrace ? buildEvaluationSQLiteQueryPlanSnapshot(currentTrace) : {};
+  const leadSpeakerCue = currentLeadMediaCueSnapshot.leadSpeakerCue ?? currentSnapshot?.leadSpeakerCue;
+  const leadSpeakerAttributionCue = currentLeadMediaCueSnapshot.leadSpeakerAttributionCue ?? currentSnapshot?.leadSpeakerAttributionCue;
+  const leadChannelCue = currentLeadMediaCueSnapshot.leadChannelCue ?? currentSnapshot?.leadChannelCue;
+  const leadChannelAttributionCue = currentLeadMediaCueSnapshot.leadChannelAttributionCue ?? currentSnapshot?.leadChannelAttributionCue;
+  const leadContinuityCue = currentLeadMediaCueSnapshot.leadContinuityCue ?? currentSnapshot?.leadContinuityCue;
+  const sqliteQueryMode = currentSQLiteQueryPlanSnapshot.sqliteQueryMode ?? currentSnapshot?.sqliteQueryMode;
+  const sqliteQueryPushdownApplied = currentSQLiteQueryPlanSnapshot.sqliteQueryPushdownApplied ?? currentSnapshot?.sqliteQueryPushdownApplied;
+  const sqliteQueryPushdownClauseCount = currentSQLiteQueryPlanSnapshot.sqliteQueryPushdownClauseCount ?? currentSnapshot?.sqliteQueryPushdownClauseCount;
+  const sqliteQueryFilteredCandidates = currentSQLiteQueryPlanSnapshot.sqliteQueryFilteredCandidates ?? currentSnapshot?.sqliteQueryFilteredCandidates;
+  const sqliteQueryInitialSearchK = currentSQLiteQueryPlanSnapshot.sqliteQueryInitialSearchK ?? currentSnapshot?.sqliteQueryInitialSearchK;
+  const sqliteQueryFinalSearchK = currentSQLiteQueryPlanSnapshot.sqliteQueryFinalSearchK ?? currentSnapshot?.sqliteQueryFinalSearchK;
+  const sqliteQueryBackfillCount = currentSQLiteQueryPlanSnapshot.sqliteQueryBackfillCount ?? currentSnapshot?.sqliteQueryBackfillCount;
   const currentFilterSignature = JSON.stringify(filter ?? undefined);
   const previousFilterSignature = JSON.stringify(previousTrace?.inputFilter ?? undefined);
   const currentRetrievalSignature = JSON.stringify(retrieval ?? undefined);
   const previousRetrievalSignature = JSON.stringify(previousTrace?.inputRetrieval ?? undefined);
-  const traceChange = !previousTrace ? currentTrace ? "new" : "unchanged" : previousTrace.traceMode !== currentTrace?.mode || previousFilterSignature !== currentFilterSignature || previousRetrievalSignature !== currentRetrievalSignature || previousTrace.sourceBalanceStrategy !== currentTrace?.sourceBalanceStrategy || previousTrace.transformedQuery !== (currentTrace?.transformedQuery || undefined) || previousTrace.variantQueries.join("|") !== (currentTrace?.variantQueries ?? []).join("|") || previousTrace.finalCount !== (currentTrace?.resultCounts.final ?? 0) || previousTrace.vectorCount !== (currentTrace?.resultCounts.vector ?? 0) || previousTrace.lexicalCount !== (currentTrace?.resultCounts.lexical ?? 0) || previousTrace.candidateTopK !== (currentTrace?.candidateTopK ?? 0) || previousTrace.lexicalTopK !== (currentTrace?.lexicalTopK ?? 0) || !areStageCountsEqual(previousStageCounts, stageCounts) ? "changed" : "unchanged";
+  const traceChange = !previousTrace ? currentTrace ? "new" : "unchanged" : previousTrace.traceMode !== currentTrace?.mode || previousFilterSignature !== currentFilterSignature || previousRetrievalSignature !== currentRetrievalSignature || previousTrace.sourceBalanceStrategy !== currentTrace?.sourceBalanceStrategy || previousTrace.transformedQuery !== (currentTrace?.transformedQuery || undefined) || previousTrace.variantQueries.join("|") !== (currentTrace?.variantQueries ?? []).join("|") || previousTrace.finalCount !== (currentTrace?.resultCounts.final ?? 0) || previousTrace.vectorCount !== (currentTrace?.resultCounts.vector ?? 0) || previousTrace.lexicalCount !== (currentTrace?.resultCounts.lexical ?? 0) || previousTrace.candidateTopK !== (currentTrace?.candidateTopK ?? 0) || previousTrace.lexicalTopK !== (currentTrace?.lexicalTopK ?? 0) || previousTrace.topContextLabel !== topContextLabel || previousTrace.topLocatorLabel !== topLocatorLabel || previousTrace.sourceAwareChunkReasonLabel !== sourceAwareChunkReasonLabel || previousTrace.sourceAwareUnitScopeLabel !== sourceAwareUnitScopeLabel || previousTrace.leadSpeakerCue !== leadSpeakerCue || previousTrace.leadSpeakerAttributionCue !== leadSpeakerAttributionCue || previousTrace.leadChannelCue !== leadChannelCue || previousTrace.leadChannelAttributionCue !== leadChannelAttributionCue || previousTrace.leadContinuityCue !== leadContinuityCue || previousTrace.sqliteQueryMode !== sqliteQueryMode || previousTrace.sqliteQueryPushdownApplied !== sqliteQueryPushdownApplied || previousTrace.sqliteQueryPushdownClauseCount !== sqliteQueryPushdownClauseCount || previousTrace.sqliteQueryFilteredCandidates !== sqliteQueryFilteredCandidates || previousTrace.sqliteQueryInitialSearchK !== sqliteQueryInitialSearchK || previousTrace.sqliteQueryFinalSearchK !== sqliteQueryFinalSearchK || previousTrace.sqliteQueryBackfillCount !== sqliteQueryBackfillCount || !areStageCountsEqual(previousStageCounts, stageCounts) ? "changed" : "unchanged";
   return {
     candidateTopK: currentTrace?.candidateTopK ?? 0,
     caseId: caseResult.caseId,
@@ -1707,16 +4960,48 @@ var buildEvaluationCaseTraceSnapshot = ({
     previousLexicalTopK: previousTrace?.lexicalTopK,
     previousInputFilter: previousTrace?.inputFilter,
     previousInputRetrieval: previousTrace?.inputRetrieval,
+    previousLeadChannelAttributionCue: previousTrace?.leadChannelAttributionCue,
+    previousLeadChannelCue: previousTrace?.leadChannelCue,
+    previousLeadContinuityCue: previousTrace?.leadContinuityCue,
+    previousLeadSpeakerAttributionCue: previousTrace?.leadSpeakerAttributionCue,
+    previousLeadSpeakerCue: previousTrace?.leadSpeakerCue,
+    previousSqliteQueryBackfillCount: previousTrace?.sqliteQueryBackfillCount,
+    previousSqliteQueryFilteredCandidates: previousTrace?.sqliteQueryFilteredCandidates,
+    previousSqliteQueryFinalSearchK: previousTrace?.sqliteQueryFinalSearchK,
+    previousSqliteQueryInitialSearchK: previousTrace?.sqliteQueryInitialSearchK,
+    previousSqliteQueryMode: previousTrace?.sqliteQueryMode,
+    previousSqliteQueryPushdownApplied: previousTrace?.sqliteQueryPushdownApplied,
+    previousSqliteQueryPushdownClauseCount: previousTrace?.sqliteQueryPushdownClauseCount,
     previousSourceBalanceStrategy: previousTrace?.sourceBalanceStrategy,
+    previousSourceAwareChunkReasonLabel: previousTrace?.sourceAwareChunkReasonLabel,
     previousStageCounts,
+    previousTopContextLabel: previousTrace?.topContextLabel,
+    previousTopLocatorLabel: previousTrace?.topLocatorLabel,
     previousTraceMode: previousTrace?.traceMode,
     previousTransformedQuery: previousTrace?.transformedQuery,
+    previousSourceAwareUnitScopeLabel: previousTrace?.sourceAwareUnitScopeLabel,
     previousVariantQueries: previousTrace?.variantQueries ?? [],
     previousVectorCount: previousTrace?.vectorCount,
     query: caseResult.query,
+    leadChannelAttributionCue,
+    leadChannelCue,
+    leadContinuityCue,
+    leadSpeakerAttributionCue,
+    leadSpeakerCue,
+    sqliteQueryBackfillCount,
+    sqliteQueryFilteredCandidates,
+    sqliteQueryFinalSearchK,
+    sqliteQueryInitialSearchK,
+    sqliteQueryMode,
+    sqliteQueryPushdownApplied,
+    sqliteQueryPushdownClauseCount,
+    sourceAwareChunkReasonLabel,
+    sourceAwareUnitScopeLabel,
     stageCounts,
     status: caseResult.status,
     sourceBalanceStrategy: currentTrace?.sourceBalanceStrategy,
+    topContextLabel,
+    topLocatorLabel,
     traceChange,
     traceMode: currentTrace?.mode,
     transformedQuery: currentTrace?.transformedQuery || undefined,
@@ -1724,11 +5009,12 @@ var buildEvaluationCaseTraceSnapshot = ({
     vectorCount: currentTrace?.resultCounts.vector ?? 0
   };
 };
-var buildEvaluationCaseTraceSnapshotsFromEvaluated = (evaluated) => evaluated.map(({ caseResult, filter, retrieval, trace }) => buildEvaluationCaseTraceSnapshot({
+var buildEvaluationCaseTraceSnapshotsFromEvaluated = (evaluated) => evaluated.map(({ caseResult, filter, retrieval, trace, topResult }) => buildEvaluationCaseTraceSnapshot({
   caseResult,
   filter,
   retrieval,
-  currentTrace: trace
+  currentTrace: trace,
+  topResult
 }));
 var buildEvaluationCaseTraceSnapshots = ({
   current,
@@ -1744,6 +5030,7 @@ var buildEvaluationCaseTraceSnapshots = ({
   ]));
   return current.response.cases.map((caseResult) => buildEvaluationCaseTraceSnapshot({
     caseResult,
+    currentSnapshot: currentTraces.get(caseResult.caseId),
     currentTrace: (() => {
       const currentSnapshot = currentTraces.get(caseResult.caseId);
       if (!currentSnapshot) {
@@ -1774,6 +5061,7 @@ var buildEvaluationCaseTraceSnapshots = ({
   }));
 };
 var getStatusRank = (status) => status === "pass" ? 2 : status === "partial" ? 1 : 0;
+var buildCaseTraceLeadLabel = (trace) => trace?.topLocatorLabel ?? trace?.topContextLabel ?? trace?.sourceAwareUnitScopeLabel ?? trace?.sourceAwareChunkReasonLabel;
 var buildRAGEvaluationRunDiff = ({
   current,
   previous
@@ -1783,12 +5071,31 @@ var buildRAGEvaluationRunDiff = ({
   const regressedCases = diffs.filter((entry) => getStatusRank(entry.currentStatus) < getStatusRank(entry.previousStatus ?? "fail"));
   const improvedCases = diffs.filter((entry) => getStatusRank(entry.currentStatus) > getStatusRank(entry.previousStatus ?? "fail"));
   const unchangedCases = diffs.filter((entry) => getStatusRank(entry.currentStatus) === getStatusRank(entry.previousStatus ?? "fail"));
+  const previousCaseTraces = new Map((previous?.caseTraceSnapshots ?? []).map((entry) => [
+    entry.caseId,
+    entry
+  ]));
+  const traceLeadChanges = (current.caseTraceSnapshots ?? []).map((entry) => {
+    const previousEntry = previousCaseTraces.get(entry.caseId);
+    const currentLead = buildCaseTraceLeadLabel(entry);
+    const previousLead = buildCaseTraceLeadLabel(previousEntry);
+    if (!currentLead || currentLead === previousLead) {
+      return;
+    }
+    return {
+      caseId: entry.caseId,
+      currentLead,
+      label: entry.label,
+      previousLead
+    };
+  }).filter((entry) => typeof entry !== "undefined");
   return {
     currentRunId: current.id,
     improvedCases,
     previousRunId: previous?.id,
     regressedCases,
     suiteId: current.suiteId,
+    traceLeadChanges: traceLeadChanges.length > 0 ? traceLeadChanges : undefined,
     summaryDelta: {
       averageF1: current.response.summary.averageF1 - (previous?.response.summary.averageF1 ?? 0),
       averageLatencyMs: current.response.summary.averageLatencyMs - (previous?.response.summary.averageLatencyMs ?? 0),
@@ -1881,6 +5188,101 @@ var createRAGFileEvaluationHistoryStore = (path) => ({
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, JSON.stringify(next, null, "\t") + `
 `, "utf8");
+  },
+  pruneRuns: async (input) => {
+    let existing = [];
+    try {
+      const content = await readFile(path, "utf8");
+      const value = JSON.parse(content);
+      existing = Array.isArray(value) ? value : [];
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const pruned = applyRAGEvaluationHistoryPrunePolicy({
+      input,
+      runs: existing,
+      sort: normalizeHistoryRuns
+    });
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(pruned.next, null, "\t") + `
+`, "utf8");
+    return {
+      keptCount: pruned.keptCount,
+      removedCount: pruned.removedCount
+    };
+  }
+});
+var normalizeEvaluationSuiteSnapshots = (snapshots) => [...snapshots].sort((left, right) => {
+  if (right.createdAt !== left.createdAt) {
+    return right.createdAt - left.createdAt;
+  }
+  if (right.version !== left.version) {
+    return right.version - left.version;
+  }
+  return right.id.localeCompare(left.id);
+});
+var createRAGFileEvaluationSuiteSnapshotHistoryStore = (path) => ({
+  listSnapshots: async ({ limit, suiteId } = {}) => {
+    let parsed = [];
+    try {
+      const content = await readFile(path, "utf8");
+      const value = JSON.parse(content);
+      parsed = Array.isArray(value) ? value : [];
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const filtered = parsed.filter((entry) => !suiteId || entry.suiteId === suiteId);
+    const sorted = normalizeEvaluationSuiteSnapshots(filtered);
+    return typeof limit === "number" ? sorted.slice(0, limit) : sorted;
+  },
+  saveSnapshot: async (snapshot) => {
+    const existing = await (async () => {
+      try {
+        const content = await readFile(path, "utf8");
+        const value = JSON.parse(content);
+        return Array.isArray(value) ? value : [];
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+        return [];
+      }
+    })();
+    const next = normalizeEvaluationSuiteSnapshots([
+      snapshot,
+      ...existing.filter((entry) => entry.id !== snapshot.id)
+    ]);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(next, null, "\t") + `
+`, "utf8");
+  },
+  pruneSnapshots: async (input) => {
+    let existing = [];
+    try {
+      const content = await readFile(path, "utf8");
+      const value = JSON.parse(content);
+      existing = Array.isArray(value) ? value : [];
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const pruned = applyRAGEvaluationHistoryPrunePolicy({
+      input,
+      runs: existing,
+      sort: normalizeEvaluationSuiteSnapshots
+    });
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(pruned.next, null, "\t") + `
+`, "utf8");
+    return {
+      keptCount: pruned.keptCount,
+      removedCount: pruned.removedCount
+    };
   }
 });
 var createRAGFileRetrievalComparisonHistoryStore = (path) => ({
@@ -2504,32 +5906,209 @@ var createRAGFileSearchTracePruneHistoryStore = (path) => ({
         throw error;
       }
     }
-    const filtered = parsed.filter((entry) => !input?.trigger || entry.trigger === input.trigger);
-    const sorted = normalizeSearchTracePruneRuns(filtered);
-    return typeof input?.limit === "number" ? sorted.slice(0, input.limit) : sorted;
-  },
-  saveRun: async (run) => {
-    const existing = await (async () => {
-      try {
-        const content = await readFile(path, "utf8");
-        const value = JSON.parse(content);
-        return Array.isArray(value) ? value : [];
-      } catch (error) {
-        if (error.code !== "ENOENT") {
-          throw error;
-        }
-        return [];
+    const filtered = parsed.filter((entry) => !input?.trigger || entry.trigger === input.trigger);
+    const sorted = normalizeSearchTracePruneRuns(filtered);
+    return typeof input?.limit === "number" ? sorted.slice(0, input.limit) : sorted;
+  },
+  saveRun: async (run) => {
+    const existing = await (async () => {
+      try {
+        const content = await readFile(path, "utf8");
+        const value = JSON.parse(content);
+        return Array.isArray(value) ? value : [];
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+        return [];
+      }
+    })();
+    const next = normalizeSearchTracePruneRuns([
+      run,
+      ...existing.filter((entry) => entry.id !== run.id)
+    ]);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify(next, null, "\t") + `
+`, "utf8");
+  }
+});
+var createRAGSQLiteEvaluationHistoryStore = (options) => {
+  const tableName = options.tableName ?? "rag_evaluation_history";
+  assertSupportedIdentifier(tableName);
+  const db = options.db ?? new (loadBunSQLiteModule()).Database(options.path ?? ":memory:");
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS ${tableName} (
+			id TEXT PRIMARY KEY,
+			suite_id TEXT NOT NULL,
+			finished_at INTEGER NOT NULL,
+			record_json TEXT NOT NULL
+		)
+	`);
+  db.exec(`CREATE INDEX IF NOT EXISTS ${tableName}_suite_finished_at_idx ON ${tableName} (suite_id, finished_at DESC)`);
+  const insert = db.prepare(`
+		INSERT INTO ${tableName} (
+			id,
+			suite_id,
+			finished_at,
+			record_json
+		) VALUES (?, ?, ?, ?)
+		ON CONFLICT(id) DO UPDATE SET
+			suite_id = excluded.suite_id,
+			finished_at = excluded.finished_at,
+			record_json = excluded.record_json
+	`);
+  return {
+    listRuns(input = {}) {
+      const where = [];
+      const params = [];
+      if (input.suiteId) {
+        where.push("suite_id = ?");
+        params.push(input.suiteId);
+      }
+      const sql = `SELECT record_json FROM ${tableName}` + `${where.length > 0 ? ` WHERE ${where.join(" AND ")}` : ""} ` + "ORDER BY finished_at DESC";
+      const rows = db.prepare(sql).all(...params);
+      const runs = normalizeHistoryRuns(rows.map((row) => JSON.parse(row.record_json)));
+      return typeof input.limit === "number" ? runs.slice(0, input.limit) : runs;
+    },
+    saveRun(run) {
+      insert.run(run.id, run.suiteId, run.finishedAt, JSON.stringify(run));
+    },
+    pruneRuns(input) {
+      const allRows = db.prepare(`SELECT record_json FROM ${tableName}`).all();
+      const pruned = applyRAGEvaluationHistoryPrunePolicy({
+        input,
+        runs: allRows.map((row) => JSON.parse(row.record_json)),
+        sort: normalizeHistoryRuns
+      });
+      for (const run of pruned.removed) {
+        db.prepare(`DELETE FROM ${tableName} WHERE id = ?`).run(run.id);
+      }
+      return {
+        keptCount: pruned.keptCount,
+        removedCount: pruned.removedCount
+      };
+    }
+  };
+};
+var createRAGSQLiteEvaluationSuiteSnapshotHistoryStore = (options) => {
+  const tableName = options.tableName ?? "rag_evaluation_suite_snapshot_history";
+  assertSupportedIdentifier(tableName);
+  const db = options.db ?? new (loadBunSQLiteModule()).Database(options.path ?? ":memory:");
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS ${tableName} (
+			id TEXT PRIMARY KEY,
+			suite_id TEXT NOT NULL,
+			version INTEGER NOT NULL,
+			created_at INTEGER NOT NULL,
+			record_json TEXT NOT NULL
+		)
+	`);
+  db.exec(`CREATE INDEX IF NOT EXISTS ${tableName}_suite_created_at_idx ON ${tableName} (suite_id, created_at DESC, version DESC)`);
+  const insert = db.prepare(`
+		INSERT INTO ${tableName} (
+			id,
+			suite_id,
+			version,
+			created_at,
+			record_json
+		) VALUES (?, ?, ?, ?, ?)
+		ON CONFLICT(id) DO UPDATE SET
+			suite_id = excluded.suite_id,
+			version = excluded.version,
+			created_at = excluded.created_at,
+			record_json = excluded.record_json
+	`);
+  return {
+    listSnapshots(input = {}) {
+      const where = [];
+      const params = [];
+      if (input.suiteId) {
+        where.push("suite_id = ?");
+        params.push(input.suiteId);
+      }
+      const sql = `SELECT record_json FROM ${tableName}` + `${where.length > 0 ? ` WHERE ${where.join(" AND ")}` : ""} ` + "ORDER BY created_at DESC, version DESC";
+      const rows = db.prepare(sql).all(...params);
+      const snapshots = normalizeEvaluationSuiteSnapshots(rows.map((row) => JSON.parse(row.record_json)));
+      return typeof input.limit === "number" ? snapshots.slice(0, input.limit) : snapshots;
+    },
+    saveSnapshot(snapshot) {
+      insert.run(snapshot.id, snapshot.suiteId, snapshot.version, snapshot.createdAt, JSON.stringify(snapshot));
+    },
+    pruneSnapshots(input) {
+      const allRows = db.prepare(`SELECT record_json FROM ${tableName}`).all();
+      const pruned = applyRAGEvaluationHistoryPrunePolicy({
+        input,
+        runs: allRows.map((row) => JSON.parse(row.record_json)),
+        sort: normalizeEvaluationSuiteSnapshots
+      });
+      for (const snapshot of pruned.removed) {
+        db.prepare(`DELETE FROM ${tableName} WHERE id = ?`).run(snapshot.id);
+      }
+      return {
+        keptCount: pruned.keptCount,
+        removedCount: pruned.removedCount
+      };
+    }
+  };
+};
+var createRAGSQLiteAnswerGroundingEvaluationHistoryStore = (options) => {
+  const tableName = options.tableName ?? "rag_answer_grounding_history";
+  assertSupportedIdentifier(tableName);
+  const db = options.db ?? new (loadBunSQLiteModule()).Database(options.path ?? ":memory:");
+  db.exec(`
+		CREATE TABLE IF NOT EXISTS ${tableName} (
+			id TEXT PRIMARY KEY,
+			suite_id TEXT NOT NULL,
+			finished_at INTEGER NOT NULL,
+			record_json TEXT NOT NULL
+		)
+	`);
+  db.exec(`CREATE INDEX IF NOT EXISTS ${tableName}_suite_finished_at_idx ON ${tableName} (suite_id, finished_at DESC)`);
+  const insert = db.prepare(`
+		INSERT INTO ${tableName} (
+			id,
+			suite_id,
+			finished_at,
+			record_json
+		) VALUES (?, ?, ?, ?)
+		ON CONFLICT(id) DO UPDATE SET
+			suite_id = excluded.suite_id,
+			finished_at = excluded.finished_at,
+			record_json = excluded.record_json
+	`);
+  return {
+    listRuns(input = {}) {
+      const where = [];
+      const params = [];
+      if (input.suiteId) {
+        where.push("suite_id = ?");
+        params.push(input.suiteId);
       }
-    })();
-    const next = normalizeSearchTracePruneRuns([
-      run,
-      ...existing.filter((entry) => entry.id !== run.id)
-    ]);
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, JSON.stringify(next, null, "\t") + `
-`, "utf8");
-  }
-});
+      const sql = `SELECT record_json FROM ${tableName}` + `${where.length > 0 ? ` WHERE ${where.join(" AND ")}` : ""} ` + "ORDER BY finished_at DESC";
+      const rows = db.prepare(sql).all(...params);
+      const runs = normalizeGroundingHistoryRuns(rows.map((row) => JSON.parse(row.record_json)));
+      return typeof input.limit === "number" ? runs.slice(0, input.limit) : runs;
+    },
+    saveRun(run) {
+      insert.run(run.id, run.suiteId, run.finishedAt, JSON.stringify(run));
+    },
+    pruneRuns(input) {
+      const allRows = db.prepare(`SELECT record_json FROM ${tableName}`).all();
+      const pruned = applyRAGEvaluationHistoryPrunePolicy({
+        input,
+        runs: allRows.map((row) => JSON.parse(row.record_json)),
+        sort: normalizeGroundingHistoryRuns
+      });
+      for (const run of pruned.removed) {
+        db.prepare(`DELETE FROM ${tableName} WHERE id = ?`).run(run.id);
+      }
+      return {
+        keptCount: pruned.keptCount,
+        removedCount: pruned.removedCount
+      };
+    }
+  };
+};
 var isSQLiteSearchTraceRow = (value) => isObjectRecord(value) && typeof value.id === "string" && typeof value.query === "string" && typeof value.label === "string" && (typeof value.group_key === "string" || value.group_key === null) && (typeof value.tags_json === "string" || value.tags_json === null) && typeof value.started_at === "number" && typeof value.finished_at === "number" && typeof value.elapsed_ms === "number" && typeof value.trace_json === "string" && typeof value.summary_json === "string" && typeof value.results_json === "string" && (typeof value.metadata_json === "string" || value.metadata_json === null);
 var isSQLiteSearchTracePruneHistoryRow = (value) => isObjectRecord(value) && typeof value.id === "string" && typeof value.trigger === "string" && typeof value.started_at === "number" && typeof value.finished_at === "number" && typeof value.elapsed_ms === "number" && typeof value.run_json === "string";
 var isSQLiteRetrievalComparisonHistoryRow = (value) => isObjectRecord(value) && typeof value.id === "string" && typeof value.suite_id === "string" && typeof value.suite_label === "string" && typeof value.label === "string" && (typeof value.corpus_group_key === "string" || value.corpus_group_key === null) && (typeof value.group_key === "string" || value.group_key === null) && (typeof value.tags_json === "string" || value.tags_json === null) && typeof value.started_at === "number" && typeof value.finished_at === "number" && typeof value.elapsed_ms === "number" && typeof value.comparison_json === "string" && (typeof value.decision_summary_json === "string" || value.decision_summary_json === null);
@@ -2560,6 +6139,57 @@ var ensureSQLiteColumns = (db, tableName, columns) => {
     db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${column.name} ${column.definition}`);
   }
 };
+var getMissingSQLiteColumns = (db, tableName, columns) => {
+  const pragma = db.prepare(`PRAGMA table_info(${tableName})`).all();
+  const existing = new Set(Array.isArray(pragma) ? pragma.filter((row) => isObjectRecord(row) && ("name" in row)).map((row) => typeof row.name === "string" ? row.name : undefined).filter((name) => typeof name === "string") : []);
+  return columns.filter((column) => !existing.has(column.name)).map((column) => ({
+    columnName: column.name,
+    definition: column.definition,
+    tableName
+  }));
+};
+var getDefaultSQLiteStoreMigrationDescriptors = () => [
+  {
+    tableName: DEFAULT_RETRIEVAL_COMPARISON_HISTORY_TABLE_NAME,
+    columns: [{ definition: "TEXT", name: "corpus_group_key" }]
+  },
+  {
+    tableName: DEFAULT_RETRIEVAL_RELEASE_DECISION_TABLE_NAME,
+    columns: [{ definition: "TEXT", name: "corpus_group_key" }]
+  },
+  {
+    tableName: DEFAULT_RETRIEVAL_BASELINE_TABLE_NAME,
+    columns: [
+      { definition: "TEXT", name: "group_key" },
+      { definition: "TEXT", name: "corpus_group_key" }
+    ]
+  }
+];
+var summarizeSQLiteStoreMigrationIssues = (issues) => issues.length > 0 ? `${issues.length} SQLite schema migration issue${issues.length === 1 ? "" : "s"} detected` : undefined;
+var inspectRAGSQLiteStoreMigrations = (options = {}) => {
+  const db = options.db ?? new (loadBunSQLiteModule()).Database(options.path ?? ":memory:");
+  const descriptors = options.descriptors ?? getDefaultSQLiteStoreMigrationDescriptors();
+  const issues = descriptors.flatMap((descriptor) => getMissingSQLiteColumns(db, descriptor.tableName, descriptor.columns));
+  return {
+    issues,
+    summary: summarizeSQLiteStoreMigrationIssues(issues)
+  };
+};
+var applyRAGSQLiteStoreMigrations = (options = {}) => {
+  const db = options.db ?? new (loadBunSQLiteModule()).Database(options.path ?? ":memory:");
+  const descriptors = options.descriptors ?? getDefaultSQLiteStoreMigrationDescriptors();
+  const inspection = inspectRAGSQLiteStoreMigrations({
+    db,
+    descriptors
+  });
+  for (const descriptor of descriptors) {
+    ensureSQLiteColumns(db, descriptor.tableName, descriptor.columns);
+  }
+  return {
+    ...inspection,
+    applied: inspection.issues
+  };
+};
 var mapSQLiteSearchTraceRow = (row) => ({
   elapsedMs: row.elapsed_ms,
   finishedAt: row.finished_at,
@@ -3930,6 +7560,31 @@ var createRAGFileAnswerGroundingEvaluationHistoryStore = (path) => ({
     await writeFile(path, JSON.stringify({
       runs: nextRuns
     }, null, 2));
+  },
+  async pruneRuns(input) {
+    let runs = [];
+    try {
+      const raw = await readFile(path, "utf8");
+      const data = JSON.parse(raw);
+      runs = Array.isArray(data.runs) ? data.runs : [];
+    } catch (error) {
+      if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const pruned = applyRAGEvaluationHistoryPrunePolicy({
+      input,
+      runs,
+      sort: normalizeGroundingHistoryRuns
+    });
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, JSON.stringify({
+      runs: pruned.next
+    }, null, 2));
+    return {
+      keptCount: pruned.keptCount,
+      removedCount: pruned.removedCount
+    };
   }
 });
 var createRAGFileAnswerGroundingCaseDifficultyHistoryStore = (path) => ({
@@ -3996,6 +7651,29 @@ var loadRAGEvaluationHistory = async ({
     suiteLabel: suite.label ?? suite.id
   };
 };
+var loadRAGEvaluationSuiteSnapshotHistory = async ({
+  store,
+  suite,
+  limit = DEFAULT_HISTORY_LIMIT
+}) => {
+  const snapshots = normalizeEvaluationSuiteSnapshots(await Promise.resolve(store.listSnapshots({
+    limit,
+    suiteId: suite.id
+  })));
+  const latestSnapshot = snapshots[0];
+  const previousSnapshot = snapshots[1];
+  return {
+    diff: latestSnapshot && previousSnapshot ? buildRAGEvaluationSuiteSnapshotDiff({
+      current: latestSnapshot,
+      previous: previousSnapshot
+    }) : undefined,
+    latestSnapshot,
+    previousSnapshot,
+    snapshots,
+    suiteId: suite.id,
+    suiteLabel: suite.label ?? suite.id
+  };
+};
 var loadRAGSearchTraceHistory = async ({
   store,
   query,
@@ -4626,6 +8304,118 @@ var buildRAGEvaluationResponse = (cases) => {
     totalCases
   };
 };
+var incrementFailureCounts = (target, failureClasses) => {
+  for (const failureClass of failureClasses ?? []) {
+    target[failureClass] = (target[failureClass] ?? 0) + 1;
+  }
+};
+var sortEntityQualitySummaries = (entries) => entries.sort((left, right) => {
+  if (right.passingRate !== left.passingRate) {
+    return right.passingRate - left.passingRate;
+  }
+  if (right.totalCases !== left.totalCases) {
+    return right.totalCases - left.totalCases;
+  }
+  return left.label.localeCompare(right.label);
+});
+var buildRAGEvaluationEntityQualityView = (response) => {
+  const bySource = new Map;
+  const byDocument = new Map;
+  for (const entry of response.cases) {
+    const targets = entry.mode === "source" ? entry.expectedIds : entry.mode === "documentId" ? entry.expectedIds : [];
+    const targetMap = entry.mode === "source" ? bySource : entry.mode === "documentId" ? byDocument : undefined;
+    if (!targetMap) {
+      continue;
+    }
+    for (const target of targets) {
+      const current = targetMap.get(target) ?? {
+        averageF1: 0,
+        caseIds: [],
+        entityType: entry.mode === "source" ? "source" : "document",
+        failedCases: 0,
+        failureCounts: {},
+        key: target,
+        label: target,
+        passedCases: 0,
+        passingRate: 0,
+        partialCases: 0,
+        totalCases: 0
+      };
+      current.totalCases += 1;
+      current.averageF1 += entry.f1;
+      current.caseIds.push(entry.caseId);
+      if (entry.status === "pass") {
+        current.passedCases += 1;
+      } else if (entry.status === "partial") {
+        current.partialCases += 1;
+      } else {
+        current.failedCases += 1;
+      }
+      incrementFailureCounts(current.failureCounts, entry.failureClasses);
+      targetMap.set(target, current);
+    }
+  }
+  for (const map of [bySource, byDocument]) {
+    for (const entry of map.values()) {
+      entry.averageF1 = entry.totalCases > 0 ? entry.averageF1 / entry.totalCases : 0;
+      entry.passingRate = entry.totalCases > 0 ? entry.passedCases / entry.totalCases * 100 : 0;
+    }
+  }
+  return {
+    byDocument: sortEntityQualitySummaries([...byDocument.values()]),
+    bySource: sortEntityQualitySummaries([...bySource.values()])
+  };
+};
+var buildRAGAnswerGroundingEntityQualityView = (response) => {
+  const bySource = new Map;
+  const byDocument = new Map;
+  for (const entry of response.cases) {
+    const targetMap = entry.mode === "source" ? bySource : entry.mode === "documentId" ? byDocument : undefined;
+    if (!targetMap) {
+      continue;
+    }
+    for (const target of entry.expectedIds) {
+      const current = targetMap.get(target) ?? {
+        averageCitationF1: 0,
+        averageResolvedCitationRate: 0,
+        caseIds: [],
+        entityType: entry.mode === "source" ? "source" : "document",
+        failedCases: 0,
+        failureCounts: {},
+        key: target,
+        label: target,
+        passedCases: 0,
+        passingRate: 0,
+        partialCases: 0,
+        totalCases: 0
+      };
+      current.totalCases += 1;
+      current.averageCitationF1 += entry.citationF1;
+      current.averageResolvedCitationRate += entry.resolvedCitationRate;
+      current.caseIds.push(entry.caseId);
+      if (entry.status === "pass") {
+        current.passedCases += 1;
+      } else if (entry.status === "partial") {
+        current.partialCases += 1;
+      } else {
+        current.failedCases += 1;
+      }
+      incrementFailureCounts(current.failureCounts, entry.failureClasses);
+      targetMap.set(target, current);
+    }
+  }
+  for (const map of [bySource, byDocument]) {
+    for (const entry of map.values()) {
+      entry.averageCitationF1 = entry.totalCases > 0 ? entry.averageCitationF1 / entry.totalCases : 0;
+      entry.averageResolvedCitationRate = entry.totalCases > 0 ? entry.averageResolvedCitationRate / entry.totalCases : 0;
+      entry.passingRate = entry.totalCases > 0 ? entry.passedCases / entry.totalCases * 100 : 0;
+    }
+  }
+  return {
+    byDocument: sortEntityQualitySummaries([...byDocument.values()]),
+    bySource: sortEntityQualitySummaries([...bySource.values()])
+  };
+};
 var evaluateRAGAnswerGroundingCase = ({
   caseIndex,
   caseInput
@@ -4667,6 +8457,15 @@ var evaluateRAGAnswerGroundingCase = ({
     label: caseInput.label,
     matchedCount,
     matchedIds,
+    failureClasses: classifyRAGGroundingFailure({
+      availableSources: caseInput.sources,
+      citationCount,
+      expectedCount,
+      extraIds,
+      matchedCount,
+      missingIds,
+      unresolvedCitationCount
+    }),
     metadata: caseInput.metadata,
     missingIds,
     mode,
@@ -4982,7 +8781,327 @@ var buildRAGRetrievalTraceHistoryTrend = ({
     latestToPrevious
   };
 };
-var createRAGEvaluationSuite = (suite) => suite;
+var createRAGEvaluationSuite = (suite) => {
+  const cases = suite.input.cases.map((entry) => ({
+    ...entry,
+    ...entry.goldenSet === true ? { goldenSet: true } : {},
+    ...entry.expectedChunkIds ? { expectedChunkIds: [...entry.expectedChunkIds] } : {},
+    ...entry.expectedSources ? { expectedSources: [...entry.expectedSources] } : {},
+    ...entry.expectedDocumentIds ? { expectedDocumentIds: [...entry.expectedDocumentIds] } : {},
+    ...entry.hardNegativeChunkIds ? {
+      hardNegativeChunkIds: normalizeExpectedIds(entry.hardNegativeChunkIds)
+    } : {},
+    ...entry.hardNegativeSources ? {
+      hardNegativeSources: normalizeExpectedIds(entry.hardNegativeSources)
+    } : {},
+    ...entry.hardNegativeDocumentIds ? {
+      hardNegativeDocumentIds: normalizeExpectedIds(entry.hardNegativeDocumentIds)
+    } : {},
+    ...entry.filter ? { filter: { ...entry.filter } } : {},
+    ...entry.metadata ? { metadata: { ...entry.metadata } } : {},
+    ...entry.retrieval ? { retrieval: entry.retrieval } : {}
+  }));
+  const duplicateCaseIds = Array.from(new Set(cases.map((entry) => entry.id).filter((id, index, ids) => typeof id === "string" && ids.indexOf(id) !== index)));
+  if (duplicateCaseIds.length > 0) {
+    throw new Error(`RAG evaluation suite contains duplicate case ids: ${duplicateCaseIds.join(", ")}`);
+  }
+  return {
+    ...suite,
+    input: {
+      ...suite.input,
+      cases,
+      ...suite.input.filter ? { filter: { ...suite.input.filter } } : {},
+      ...suite.input.retrieval ? { retrieval: suite.input.retrieval } : {}
+    },
+    ...suite.metadata ? { metadata: { ...suite.metadata } } : {}
+  };
+};
+var addRAGEvaluationSuiteCase = ({
+  suite,
+  caseInput,
+  index
+}) => {
+  const normalizedSuite = createRAGEvaluationSuite(suite);
+  if (normalizedSuite.input.cases.some((entry) => entry.id === caseInput.id)) {
+    throw new Error(`RAG evaluation suite already contains case id ${caseInput.id}`);
+  }
+  const nextCases = [...normalizedSuite.input.cases];
+  const insertAt = typeof index === "number" && Number.isFinite(index) ? Math.max(0, Math.min(nextCases.length, Math.trunc(index))) : nextCases.length;
+  nextCases.splice(insertAt, 0, caseInput);
+  return createRAGEvaluationSuite({
+    ...normalizedSuite,
+    input: {
+      ...normalizedSuite.input,
+      cases: nextCases
+    }
+  });
+};
+var updateRAGEvaluationSuiteCase = ({
+  suite,
+  caseId,
+  caseInput
+}) => {
+  const normalizedSuite = createRAGEvaluationSuite(suite);
+  const targetIndex = normalizedSuite.input.cases.findIndex((entry) => entry.id === caseId);
+  if (targetIndex < 0) {
+    throw new Error(`RAG evaluation suite does not contain case id ${caseId}`);
+  }
+  if (caseInput.id !== caseId && normalizedSuite.input.cases.some((entry) => entry.id === caseInput.id)) {
+    throw new Error(`RAG evaluation suite already contains case id ${caseInput.id}`);
+  }
+  const nextCases = [...normalizedSuite.input.cases];
+  nextCases[targetIndex] = caseInput;
+  return createRAGEvaluationSuite({
+    ...normalizedSuite,
+    input: {
+      ...normalizedSuite.input,
+      cases: nextCases
+    }
+  });
+};
+var removeRAGEvaluationSuiteCase = ({
+  suite,
+  caseId
+}) => {
+  const normalizedSuite = createRAGEvaluationSuite(suite);
+  const nextCases = normalizedSuite.input.cases.filter((entry) => entry.id !== caseId);
+  if (nextCases.length === normalizedSuite.input.cases.length) {
+    throw new Error(`RAG evaluation suite does not contain case id ${caseId}`);
+  }
+  return {
+    ...normalizedSuite,
+    input: {
+      ...normalizedSuite.input,
+      cases: nextCases
+    }
+  };
+};
+var reorderRAGEvaluationSuiteCases = ({
+  suite,
+  caseIds
+}) => {
+  const normalizedSuite = createRAGEvaluationSuite(suite);
+  const caseMap = new Map(normalizedSuite.input.cases.map((entry) => [entry.id, entry]));
+  if (caseIds.length !== normalizedSuite.input.cases.length) {
+    throw new Error("RAG evaluation suite reorder requires exactly one id per case");
+  }
+  const unknownCaseIds = caseIds.filter((id) => !caseMap.has(id));
+  if (unknownCaseIds.length > 0) {
+    throw new Error(`RAG evaluation suite reorder contains unknown case ids: ${unknownCaseIds.join(", ")}`);
+  }
+  if (new Set(caseIds).size !== caseIds.length) {
+    throw new Error("RAG evaluation suite reorder contains duplicate case ids");
+  }
+  return {
+    ...normalizedSuite,
+    input: {
+      ...normalizedSuite.input,
+      cases: caseIds.map((id) => caseMap.get(id))
+    }
+  };
+};
+var setRAGEvaluationSuiteCaseGoldenSet = ({
+  suite,
+  caseId,
+  goldenSet
+}) => {
+  const normalizedSuite = createRAGEvaluationSuite(suite);
+  const target = normalizedSuite.input.cases.find((entry) => entry.id === caseId);
+  if (!target) {
+    throw new Error(`RAG evaluation suite does not contain case id ${caseId}`);
+  }
+  return updateRAGEvaluationSuiteCase({
+    caseId,
+    caseInput: {
+      ...target,
+      ...goldenSet ? { goldenSet: true } : { goldenSet: undefined }
+    },
+    suite: normalizedSuite
+  });
+};
+var resolveHardNegativeCaseField = (kind) => kind === "chunkId" ? "hardNegativeChunkIds" : kind === "source" ? "hardNegativeSources" : "hardNegativeDocumentIds";
+var addRAGEvaluationSuiteCaseHardNegative = ({
+  suite,
+  caseId,
+  kind,
+  value
+}) => {
+  const normalizedSuite = createRAGEvaluationSuite(suite);
+  const target = normalizedSuite.input.cases.find((entry) => entry.id === caseId);
+  if (!target) {
+    throw new Error(`RAG evaluation suite does not contain case id ${caseId}`);
+  }
+  const field = resolveHardNegativeCaseField(kind);
+  const nextValues = normalizeExpectedIds([
+    ...normalizeStringArray(target[field]),
+    value
+  ]);
+  return updateRAGEvaluationSuiteCase({
+    caseId,
+    caseInput: {
+      ...target,
+      [field]: nextValues
+    },
+    suite: normalizedSuite
+  });
+};
+var removeRAGEvaluationSuiteCaseHardNegative = ({
+  suite,
+  caseId,
+  kind,
+  value
+}) => {
+  const normalizedSuite = createRAGEvaluationSuite(suite);
+  const target = normalizedSuite.input.cases.find((entry) => entry.id === caseId);
+  if (!target) {
+    throw new Error(`RAG evaluation suite does not contain case id ${caseId}`);
+  }
+  const field = resolveHardNegativeCaseField(kind);
+  const nextValues = normalizeStringArray(target[field]).filter((entry) => entry !== value.trim());
+  return updateRAGEvaluationSuiteCase({
+    caseId,
+    caseInput: {
+      ...target,
+      [field]: nextValues.length > 0 ? nextValues : undefined
+    },
+    suite: normalizedSuite
+  });
+};
+var summarizeRAGEvaluationSuiteDataset = ({
+  suite
+}) => {
+  const normalizedSuite = createRAGEvaluationSuite(suite);
+  const cases = normalizedSuite.input.cases;
+  return {
+    caseCount: cases.length,
+    goldenSetCount: cases.filter((entry) => entry.goldenSet === true).length,
+    hardNegativeCaseCount: cases.filter((entry) => normalizeStringArray(entry.hardNegativeChunkIds).length > 0 || normalizeStringArray(entry.hardNegativeSources).length > 0 || normalizeStringArray(entry.hardNegativeDocumentIds).length > 0).length,
+    hardNegativeChunkIdCount: cases.reduce((sum, entry) => sum + normalizeStringArray(entry.hardNegativeChunkIds).length, 0),
+    hardNegativeDocumentIdCount: cases.reduce((sum, entry) => sum + normalizeStringArray(entry.hardNegativeDocumentIds).length, 0),
+    hardNegativeSourceCount: cases.reduce((sum, entry) => sum + normalizeStringArray(entry.hardNegativeSources).length, 0),
+    suiteId: normalizedSuite.id
+  };
+};
+var generateRAGEvaluationSuiteFromDocuments = ({
+  suiteId,
+  documents,
+  label,
+  description,
+  maxCases = 20,
+  topK = 5,
+  scoreThreshold,
+  filter,
+  retrieval,
+  includeGoldenSet = true,
+  hardNegativePerCase = 1,
+  metadata
+}) => {
+  const normalizedDocuments = documents.filter((document) => typeof document.id === "string" && document.id.trim().length > 0 && typeof document.source === "string" && document.source.trim().length > 0 && typeof document.title === "string" && document.title.trim().length > 0).sort((left, right) => `${left.source}\x00${left.title}\x00${left.id}`.localeCompare(`${right.source}\x00${right.title}\x00${right.id}`)).slice(0, Math.max(0, Math.trunc(maxCases)));
+  const cases = normalizedDocuments.map((document, index) => {
+    const negativeCandidates = normalizedDocuments.slice(index + 1).concat(normalizedDocuments.slice(0, index)).filter((candidate) => candidate.id !== document.id);
+    const hardNegativeDocumentIds = negativeCandidates.slice(0, Math.max(0, Math.trunc(hardNegativePerCase))).map((candidate) => candidate.id);
+    const hardNegativeSources = negativeCandidates.slice(0, Math.max(0, Math.trunc(hardNegativePerCase))).map((candidate) => candidate.source);
+    return {
+      corpusKey: document.corpusKey,
+      expectedDocumentIds: [document.id],
+      expectedSources: [document.source],
+      ...includeGoldenSet ? { goldenSet: true } : {},
+      ...hardNegativeDocumentIds.length > 0 ? { hardNegativeDocumentIds } : {},
+      ...hardNegativeSources.length > 0 ? { hardNegativeSources } : {},
+      id: `synthetic-${document.id}`,
+      label: document.title,
+      query: buildSyntheticEvaluationQuery(document)
+    };
+  });
+  return createRAGEvaluationSuite({
+    description,
+    id: suiteId,
+    input: {
+      cases,
+      ...filter ? { filter: { ...filter } } : {},
+      ...typeof scoreThreshold === "number" ? { scoreThreshold } : {},
+      ...typeof topK === "number" ? { topK } : {},
+      ...retrieval ? { retrieval } : {}
+    },
+    label,
+    metadata
+  });
+};
+var createRAGEvaluationSuiteSnapshot = ({
+  suite,
+  id,
+  version = 1,
+  createdAt = Date.now(),
+  metadata
+}) => {
+  const normalizedSuite = createRAGEvaluationSuite(suite);
+  return {
+    caseCount: normalizedSuite.input.cases.length,
+    createdAt,
+    id: id ?? `${normalizedSuite.id}:snapshot:${String(version)}`,
+    label: normalizedSuite.label,
+    description: normalizedSuite.description,
+    metadata: metadata ? { ...metadata } : undefined,
+    suite: normalizedSuite,
+    suiteId: normalizedSuite.id,
+    version
+  };
+};
+var stableStringifyEvaluationCase = (entry) => JSON.stringify({
+  ...entry,
+  expectedChunkIds: entry.expectedChunkIds ?? [],
+  expectedDocumentIds: entry.expectedDocumentIds ?? [],
+  expectedSources: entry.expectedSources ?? [],
+  goldenSet: entry.goldenSet === true,
+  hardNegativeChunkIds: entry.hardNegativeChunkIds ?? [],
+  hardNegativeDocumentIds: entry.hardNegativeDocumentIds ?? [],
+  hardNegativeSources: entry.hardNegativeSources ?? [],
+  filter: entry.filter ?? {},
+  metadata: entry.metadata ?? {},
+  retrieval: entry.retrieval ?? null
+});
+var buildRAGEvaluationSuiteSnapshotDiff = ({
+  current,
+  previous
+}) => {
+  const currentCases = current.suite.input.cases;
+  const previousCases = previous?.suite.input.cases ?? [];
+  const currentMap = new Map(currentCases.map((entry) => [entry.id, entry]));
+  const previousMap = new Map(previousCases.map((entry) => [entry.id, entry]));
+  const currentIds = currentCases.map((entry) => entry.id);
+  const previousIds = previousCases.map((entry) => entry.id);
+  const addedCaseIds = currentIds.filter((id) => !previousMap.has(id));
+  const removedCaseIds = previousIds.filter((id) => !currentMap.has(id));
+  const changedCaseIds = currentIds.filter((id) => {
+    const currentCase = currentMap.get(id);
+    const previousCase = previousMap.get(id);
+    if (!currentCase || !previousCase) {
+      return false;
+    }
+    return stableStringifyEvaluationCase(currentCase) !== stableStringifyEvaluationCase(previousCase);
+  });
+  const unchangedCaseIds = currentIds.filter((id) => {
+    const currentCase = currentMap.get(id);
+    const previousCase = previousMap.get(id);
+    if (!currentCase || !previousCase) {
+      return false;
+    }
+    return stableStringifyEvaluationCase(currentCase) === stableStringifyEvaluationCase(previousCase);
+  });
+  const sharedIds = currentIds.filter((id) => previousMap.has(id));
+  const orderChanged = sharedIds.length > 0 && JSON.stringify(sharedIds) !== JSON.stringify(previousIds.filter((id) => currentMap.has(id)));
+  return {
+    addedCaseIds,
+    caseCountDelta: current.caseCount - (previous?.caseCount ?? 0),
+    changedCaseIds,
+    currentSnapshotId: current.id,
+    orderChanged,
+    previousSnapshotId: previous?.id,
+    removedCaseIds,
+    suiteId: current.suiteId,
+    unchangedCaseIds
+  };
+};
 var evaluateRAGCollection = async ({
   collection,
   input,
@@ -5007,6 +9126,13 @@ var executeDryRunRAGEvaluation = (input, defaultTopK = DEFAULT_TOP_K) => input.c
     elapsedMs: 0,
     expectedCount: expectedIds.length,
     expectedIds,
+    failureClasses: classifyRAGEvaluationFailure({
+      expectedCount: expectedIds.length,
+      matchedCount: 0,
+      missingIds: expectedIds,
+      retrievedCount: 0,
+      retrievedIds: []
+    }),
     f1: 0,
     label: caseInput.label,
     matchedCount: 0,
@@ -5055,7 +9181,9 @@ var summarizeRAGEvaluationCase = ({
   mode,
   retrievedIds,
   expectedIds,
-  elapsedMs
+  elapsedMs,
+  retrievedSources,
+  trace
 }) => {
   const expectedSet = new Set(expectedIds);
   const retrievedSet = new Set(retrievedIds);
@@ -5074,6 +9202,15 @@ var summarizeRAGEvaluationCase = ({
     elapsedMs,
     expectedCount,
     expectedIds,
+    failureClasses: classifyRAGEvaluationFailure({
+      expectedCount,
+      matchedCount,
+      missingIds,
+      retrievedCount,
+      retrievedIds,
+      retrievedSources,
+      trace
+    }),
     f1,
     label: caseInput.label,
     matchedCount,
@@ -5095,12 +9232,18 @@ var summarizeRAGRerankerComparison = (entries) => {
 };
 var summarizeRAGRetrievalComparison = (entries) => summarizeEvaluationResponseComparison(entries, "retrievalId");
 export {
+  updateRAGEvaluationSuiteCase,
   summarizeRAGSearchTraceStore,
   summarizeRAGRetrievalTraces,
   summarizeRAGRetrievalComparison,
   summarizeRAGRerankerComparison,
+  summarizeRAGEvaluationSuiteDataset,
   summarizeRAGEvaluationCase,
+  setRAGEvaluationSuiteCaseGoldenSet,
   runRAGEvaluationSuite,
+  reorderRAGEvaluationSuiteCases,
+  removeRAGEvaluationSuiteCaseHardNegative,
+  removeRAGEvaluationSuiteCase,
   pruneRAGSearchTraceStore,
   previewRAGSearchTraceStorePrune,
   persistRAGSearchTraceRecord,
@@ -5137,9 +9280,12 @@ export {
   loadRAGRetrievalComparisonHistory,
   loadRAGRetrievalBaselines,
   loadRAGRetrievalBaselineGatePolicyHistory,
+  loadRAGEvaluationSuiteSnapshotHistory,
   loadRAGEvaluationHistory,
   loadRAGAnswerGroundingEvaluationHistory,
   loadRAGAnswerGroundingCaseDifficultyHistory,
+  inspectRAGSQLiteStoreMigrations,
+  generateRAGEvaluationSuiteFromDocuments,
   executeDryRunRAGEvaluation,
   evaluateRAGCollection,
   evaluateRAGAnswerGroundingCase,
@@ -5160,6 +9306,9 @@ export {
   createRAGSQLiteRetrievalBaselineStore,
   createRAGSQLiteRetrievalBaselineGatePolicyHistoryStore,
   createRAGSQLiteGovernanceStores,
+  createRAGSQLiteEvaluationSuiteSnapshotHistoryStore,
+  createRAGSQLiteEvaluationHistoryStore,
+  createRAGSQLiteAnswerGroundingEvaluationHistoryStore,
   createRAGFileSearchTraceStore,
   createRAGFileSearchTracePruneHistoryStore,
   createRAGFileRetrievalReleaseLanePolicyHistoryStore,
@@ -5175,9 +9324,11 @@ export {
   createRAGFileRetrievalComparisonHistoryStore,
   createRAGFileRetrievalBaselineStore,
   createRAGFileRetrievalBaselineGatePolicyHistoryStore,
+  createRAGFileEvaluationSuiteSnapshotHistoryStore,
   createRAGFileEvaluationHistoryStore,
   createRAGFileAnswerGroundingEvaluationHistoryStore,
   createRAGFileAnswerGroundingCaseDifficultyHistoryStore,
+  createRAGEvaluationSuiteSnapshot,
   createRAGEvaluationSuite,
   compareRAGRetrievalTraceSummaries,
   compareRAGRetrievalStrategies,
@@ -5187,15 +9338,21 @@ export {
   buildRAGRetrievalTraceHistoryTrend,
   buildRAGRetrievalReleaseVerdict,
   buildRAGRetrievalComparisonDecisionSummary,
+  buildRAGEvaluationSuiteSnapshotDiff,
   buildRAGEvaluationRunDiff,
   buildRAGEvaluationResponse,
   buildRAGEvaluationLeaderboard,
+  buildRAGEvaluationEntityQualityView,
   buildRAGAnswerGroundingEvaluationRunDiff,
   buildRAGAnswerGroundingEvaluationResponse,
   buildRAGAnswerGroundingEvaluationLeaderboard,
+  buildRAGAnswerGroundingEntityQualityView,
   buildRAGAnswerGroundingCaseDifficultyRunDiff,
-  buildRAGAnswerGroundingCaseDifficultyLeaderboard
+  buildRAGAnswerGroundingCaseDifficultyLeaderboard,
+  applyRAGSQLiteStoreMigrations,
+  addRAGEvaluationSuiteCaseHardNegative,
+  addRAGEvaluationSuiteCase
 };
 
-//# debugId=4DF816F7AEC222B664756E2164756E21
+//# debugId=5E80012397BE4C1064756E2164756E21
 //# sourceMappingURL=quality.js.map