[FE/feat] Query Registry

TODOS.md

@@ -22,3 +22,26 @@
   (Eng Review Decisions → run-creation orchestration).
 - **Depends on / blocked by:** Backend team; relates to the FE evaluations migration
   landing first (FE rollback is the interim state).
+
+## Query Registry — fast-follows
+
+### Backend query-usage endpoint (enumerate referencing live evals)
+- **What:** Add `POST /queries/revisions/{id}/usage` (or `/queries/{id}/usage`) returning the evaluation-run ids that reference a given query revision.
+- **Why:** v1 ships a generic "this query may be in use by a live evaluation" confirm before archive, because there is no reverse-lookup today. This endpoint lets the manage drawer name the specific live evals before archiving — real safety instead of a generic warning.
+- **Pros:** Turns the safe-archive UX from 7/10 (generic) to 10/10 (enumerated); reuses data that already exists.
+- **Cons:** Backend work (new router/service/DAO); a reverse scan of eval-run references.
+- **Context:** The reference data exists, flattened, in the evaluations domain under `QUERY_REFERENCE_KEY = "query_revision"` (`api/oss/src/dbs/postgres/evaluations/utils.py`). Eval runs store `data.steps[].references["query_revision"]`. There is currently NO reverse-lookup endpoint and archive does not block in-use queries (`api/oss/src/core/queries/service.py:844` `archive_query_revision` has no reference check). Verified during the eng review of branch `claude/intelligent-bassi-ca4cc0`.
+- **Depends on / blocked by:** None. Independent of the FE registry; the FE swaps the generic confirm for enumeration when this lands.
+
+### (RESOLVED) Revision-history expand — no backend change needed
+- **What:** The Query Registry's version-history expand is implemented. Each query
+  (artifact) row expands to its earlier revisions, lazy-loaded on first expand.
+- **Resolution:** Revisions are queried by the **artifact ref** (`query_refs: [{id: queryId}]`),
+  not the variant ref — `QueryRevisionQueryRequest` accepts `query_refs`, and the
+  service maps `artifact_refs=query_refs`. Simple queries are single-variant, so this
+  returns the full version history. The earlier assumption that the list must return
+  `variant_id` was wrong; the list already returns the artifact `id` (= queryId), which
+  is all the expand needs.
+- **Nice-to-have (not blocking):** the simple-queries list could still surface
+  `revision_id` so the head row shows its version badge without a fetch, but the expand
+  works without it.

web/ee/src/pages/w/[workspace_id]/p/[project_id]/queries/archived/index.tsx

@@ -0,0 +1,3 @@
+import ArchivedQueriesPage from "@agenta/oss/src/pages/w/[workspace_id]/p/[project_id]/queries/archived"
+
+export default ArchivedQueriesPage

web/ee/src/pages/w/[workspace_id]/p/[project_id]/queries/index.tsx

@@ -0,0 +1,3 @@
+import QueriesPage from "@agenta/oss/src/pages/w/[workspace_id]/p/[project_id]/queries/index"
+
+export default QueriesPage

web/oss/src/components/Filters/types.d.ts

@@ -8,6 +8,11 @@ export interface Props {
     onApplyFilter: (filters: Filter[]) => void
     onClearFilter: (filters: Filter[]) => void
     buttonProps?: ButtonProps
+    /**
+     * Render the editor body inline (no popover/trigger button) — for surfaces
+     * where the filter IS the primary content, e.g. the Query Registry drawer.
+     */
+    inline?: boolean
     /**
      * Optional callback to derive a *display-only* view of the local filter
      * state. Called whenever the user changes a row in the dialog. The dialog

web/oss/src/components/Layout/Layout.tsx

@@ -55,6 +55,8 @@ const layoutRouteFlagsAtom = atom<LayoutRouteFlags>((get) => {
     const isAnnotations = pathname.includes("/annotations")
     const isRegistry = pathname.includes("/variants")
     const isObservability = pathname.includes("/observability") || pathname.includes("/traces")
+    // The Query Registry hosts a full-height InfiniteVirtualTable, like Observability.
+    const isQueries = pathname.includes("/queries")
     // The Audit Log settings tab hosts a full-height InfiniteVirtualTable.
     // Scoped to the `tab` query param so other settings tabs keep the default
     // (content-flow) layout.
@@ -78,6 +80,7 @@ const layoutRouteFlagsAtom = atom<LayoutRouteFlags>((get) => {
             isAnnotations ||
             isRegistry ||
             isObservability ||
+            isQueries ||
             isAuditLog,
     }
 })

web/oss/src/components/Playground/Components/PlaygroundHeader/index.tsx

@@ -2,6 +2,7 @@ import React, {useCallback, useMemo, useState} from "react"
 
 import type {PlaygroundNode} from "@agenta/entities/runnable"
 import {
+    activateEvaluatorEnrichmentAtom,
     deriveWorkflowTypeFromRevision,
     getWorkflowTypeColor,
     parseWorkflowKeyFromUri,
@@ -262,10 +263,21 @@ const PlaygroundHeader: React.FC<PlaygroundHeaderProps> = ({className, ...divPro
     // labels, and workflow metadata ("N versions · date") for the picker rows.
     // splitTypeTag renders the type tag in the row's suffix slot (vertically
     // centered) instead of trailing the name.
+    //
+    // `lazy`: the adapter + the `evaluatorWorkflowMetaMapAtom` read above sit
+    // behind the shared enrichment gate, so they resolve no per-evaluator
+    // revisions until the user reaches for this "Add evaluators" picker
+    // (`handleActivateEvaluatorPicker`, on pointer-enter/focus). Keeps a plain
+    // playground load from firing the batched revision fan-out.
     const evaluatorWorkflowAdapter = useEvaluatorOnlyAdapter(renderWorkflowRevisionLabel, {
         showWorkflowMeta: true,
         splitTypeTag: true,
+        lazy: true,
     })
+    const activateEvaluatorEnrichment = useSetAtom(activateEvaluatorEnrichmentAtom)
+    const handleActivateEvaluatorPicker = useCallback(() => {
+        activateEvaluatorEnrichment()
+    }, [activateEvaluatorEnrichment])
 
     // Controlled state for EvaluatorTemplateDropdown
     const [templateDropdownOpen, setTemplateDropdownOpen] = useState(false)
@@ -505,7 +517,11 @@ const PlaygroundHeader: React.FC<PlaygroundHeaderProps> = ({className, ...divPro
                      * playground doesn't make sense (would evaluate itself). */}
                     {currentWorkflowCtx.workflowKind !== "evaluator" && <RunEvaluationButton />}
                     <Divider orientation="vertical" className="!mx-0 h-5" />
-                    <span className="relative inline-flex">
+                    <span
+                        className="relative inline-flex"
+                        onPointerEnter={handleActivateEvaluatorPicker}
+                        onFocus={handleActivateEvaluatorPicker}
+                    >
                         <Tooltip title="Add evaluators to automatically score outputs in the playground.">
                             <span>
                                 <EntityPicker<WorkflowRevisionSelectionResult>

web/oss/src/components/Playground/Components/PlaygroundVariantConfig/assets/PlaygroundVariantConfigHeader.tsx

@@ -64,8 +64,14 @@ const PlaygroundVariantConfigHeader = ({
               (entityData as {flags?: {is_evaluator?: boolean} | null} | null)?.flags?.is_evaluator,
           )
 
-    // Browse adapters: evaluator-only or app-only (non-evaluator, non-human)
-    const evaluatorOnlyAdapter = useEnrichedEvaluatorOnlyAdapter()
+    // Browse adapters: evaluator-only or app-only (non-evaluator, non-human).
+    // The evaluator adapter is only USED when this is an evaluator entity (see
+    // `browseAdapter` below); on an app playground it's built but unused, so keep
+    // its evaluator-enrichment fan-out dormant (`lazy`) there. For evaluator
+    // entities it's needed, so activate eagerly.
+    const evaluatorOnlyAdapter = useEnrichedEvaluatorOnlyAdapter(undefined, {
+        lazy: !isEvaluatorEntity,
+    })
     const appOnlyAdapter = useMemo(
         () =>
             createWorkflowRevisionAdapter({

web/oss/src/components/Playground/Components/PlaygroundVariantConfig/index.tsx

@@ -4,7 +4,11 @@ import {memo, useCallback, useMemo, useState} from "react"
 
 import {testcaseMolecule} from "@agenta/entities/testcase"
 import {parseEvaluatorKeyFromUri, workflowMolecule} from "@agenta/entities/workflow"
-import {evaluatorTemplatesDataAtom, evaluatorPresetsAtomFamily} from "@agenta/entities/workflow"
+import {
+    evaluatorTemplatesDataAtom,
+    evaluatorPresetsAtomFamily,
+    type EvaluatorCatalogTemplate,
+} from "@agenta/entities/workflow"
 import {
     PlaygroundConfigSection,
     LoadEvaluatorPresetModal,
@@ -15,7 +19,7 @@ import {
 import {hasPendingHydrationAtomFamily} from "@agenta/playground"
 import {Select} from "antd"
 import clsx from "clsx"
-import {useAtomValue, useSetAtom} from "jotai"
+import {atom, useAtomValue, useSetAtom} from "jotai"
 import dynamic from "next/dynamic"
 
 import {extractJsonPaths, safeParseJson} from "@/oss/lib/helpers/extractJsonPaths"
@@ -27,6 +31,9 @@ import type {VariantConfigComponentProps} from "./types"
 
 const RefinePromptModal = dynamic(() => import("../Modals/RefinePromptModal"), {ssr: false})
 
+// Stable empty catalog read for non-evaluator workflows (avoids the templates fetch).
+const EMPTY_TEMPLATES_DATA_ATOM = atom<EvaluatorCatalogTemplate[]>([])
+
 /**
  * PlaygroundVariantConfig manages the configuration interface for a single variant.
  * All entity types (including ephemeral workflows from traces) go through PlaygroundConfigSection.
@@ -64,16 +71,21 @@ const PlaygroundVariantConfig: React.FC<
     const runnableData = useAtomValue(workflowMolecule.selectors.data(variantId))
     const dispatchUpdate = useSetAtom(workflowMolecule.actions.updateConfiguration)
 
-    // Read evaluator template definitions (workflow-based)
-    const evaluatorDefinitions = useAtomValue(evaluatorTemplatesDataAtom)
-
     // Determine if this is an evaluator workflow
     const evaluatorKey = useMemo(() => {
         const uri = runnableData?.data?.uri as string | undefined
         if (!uri || !uri.startsWith("agenta:builtin:")) return null
         return parseEvaluatorKeyFromUri(uri)
     }, [runnableData?.data?.uri])
 
+    // Read the evaluator template catalog only for evaluator workflows — apps
+    // never use it, and an unconditional read fetches GET /evaluators/catalog/
+    // templates on every playground load (mirrors the workflow molecule, which
+    // also reads the catalog only once an evaluatorKey is resolved).
+    const evaluatorDefinitions = useAtomValue(
+        evaluatorKey ? evaluatorTemplatesDataAtom : EMPTY_TEMPLATES_DATA_ATOM,
+    )
+
     const evaluatorDef = useMemo(() => {
         if (!evaluatorKey) return null
         return evaluatorDefinitions.find((e) => e.key === evaluatorKey) ?? null

web/oss/src/components/QueryRegistry/ArchivedQueriesPage.tsx

@@ -0,0 +1,5 @@
+import QueryRegistry from "."
+
+export default function ArchivedQueriesPage() {
+    return <QueryRegistry mode="archived" />
+}