claude-smart 0.2.48 → 0.2.50

package/plugin/vendor/reflexio/reflexio/server/services/unified_search_service.py

@@ -22,6 +22,7 @@ from typing import TYPE_CHECKING, Any, cast
 
 from reflexio.models.api_schema.retriever_schema import (
     ConversationTurn,
+    ReformulationResult,
     SearchAgentPlaybookRequest,
     SearchUserPlaybookRequest,
     SearchUserProfileRequest,
@@ -50,6 +51,15 @@ from reflexio.server.services.retrieval.recency import (
     multiplicative_factor,
 )
 from reflexio.server.services.retrieval.relevance_floor import apply_relevance_floors
+from reflexio.server.services.retrieval.session_dedup import (
+    EntityKey,
+    session_seen_cache,
+)
+from reflexio.server.services.retrieval.temporal import (
+    freshness_collapse,
+    sort_by_recency,
+    window_bounds,
+)
 from reflexio.server.services.storage.storage_base import BaseStorage
 from reflexio.server.tracing import profile_step, set_span_data
 
@@ -76,6 +86,20 @@ _SEARCH_FANOUT_EXECUTOR = ThreadPoolExecutor(
     thread_name_prefix="reflexio-search",
 )
 _ENV_SINGLE_RPC = "REFLEXIO_UNIFIED_SEARCH_SINGLE_RPC"
+# Working-pool floor for temporal reordering (freshness collapse / recency
+# sort): matches the RecencyConfig default pool so the fresh version of a
+# fact can be promoted even when it ranks below top_k on text relevance.
+_TEMPORAL_POOL_SIZE = 20
+# Session dedup widens the fetch pool so filtered-out (already served) items
+# can be backfilled, but never by more than this many extra candidates.
+_SESSION_DEDUP_FETCH_BUMP_CAP = 50
+# Singular dedup kinds (session_dedup EntityKey vocabulary) — deliberately
+# distinct from the plural request-level ``entity_types`` values.
+_ENTITY_ID_ATTRS = {
+    "profile": "profile_id",
+    "user_playbook": "user_playbook_id",
+    "agent_playbook": "agent_playbook_id",
+}
 _EMBEDDING_CACHE_TTL_SECONDS = max(
     0, int(os.getenv("REFLEXIO_QUERY_EMBEDDING_CACHE_TTL_SECONDS", "300") or "300")
 )
@@ -139,14 +163,9 @@ def run_unified_search(
     floor_cfg = retrieval_floor or RetrievalFloorConfig()
     floor_on = floor_cfg.enabled
     recency_on = bool(recency and recency.enabled)
-    fetch_k = max(
-        top_k,
-        floor_cfg.pool_size if floor_on else 0,
-        recency.pool_size if recency_on and recency is not None else 0,
-    )
 
-    # --- Phase A: query reformulation + embedding generation ---
-    reformulated_query, embedding = _run_phase_a(
+    # --- Phase A: query reformulation (+ temporal signals) + embedding ---
+    reformulation, embedding, embedding_failed = _run_phase_a(
         query=request.query,
         storage=storage,
         llm_client=llm_client,
@@ -157,6 +176,50 @@ def run_unified_search(
         pre_retrieval_model_name=pre_retrieval_model_name,
         search_mode=request.search_mode,
     )
+    reformulated_query = reformulation.standalone_query
+
+    # Degrade-to-FTS: when embedding GENERATION failed (distinct from the
+    # benign None cases), force the effective mode to FTS for the entire
+    # Phase B fan-out. Storage then takes the zero-placeholder branch and
+    # never re-embeds — closing the historical second-embed leak where a
+    # None embedding + a vector/hybrid mode caused the storage layer to retry
+    # the embed and raise unguarded. Benign None (FTS-only, unsupported)
+    # leaves the requested mode untouched.
+    effective_search_mode = request.search_mode
+    if embedding_failed:
+        effective_search_mode = SearchMode.FTS
+        logger.warning(
+            "event=search_degraded_to_fts reason=embedding_generation_failed "
+            "backend=%s requested_mode=%s",
+            _storage_backend_name(storage),
+            request.search_mode.value,
+        )
+    window_start, window_end = window_bounds(
+        reformulation.start_days_ago, reformulation.end_days_ago
+    )
+
+    # Temporal reordering (freshness collapse / recency sort) happens after
+    # relevance ranking, so it needs a wider working pool: the fresh version
+    # of a fact may rank below top_k on text relevance alone. When signals
+    # are present, fetch and rank a larger pool and cut to top_k only after
+    # the temporal pass.
+    temporal_reorder = reformulation.wants_current or reformulation.recency_dominant
+    fetch_k = max(
+        top_k,
+        floor_cfg.pool_size if floor_on else 0,
+        recency.pool_size if recency_on and recency is not None else 0,
+        _TEMPORAL_POOL_SIZE if temporal_reorder else 0,
+    )
+    result_cap = max(top_k, _TEMPORAL_POOL_SIZE) if temporal_reorder else top_k
+
+    # Session dedup: a request that carries a session_id skips items already
+    # served to that (org, session) and backfills from a widened pool.
+    session_id = (request.session_id or "").strip()
+    seen_keys = (
+        session_seen_cache.seen(org_id, session_id) if session_id else frozenset()
+    )
+    if seen_keys:
+        fetch_k += min(len(seen_keys), _SESSION_DEDUP_FETCH_BUMP_CAP)
 
     # --- Phase B: parallel searches across all entity types ---
     profiles, agent_playbooks, user_playbooks = _run_phase_b(
@@ -168,41 +231,65 @@ def run_unified_search(
         top_k=fetch_k,
         threshold=threshold,
         recency_on=recency_on,
+        start_time=window_start,
+        end_time=window_end,
+        search_mode=effective_search_mode,
     )
 
     if profiles is None:
         return UnifiedSearchResponse(success=False, msg="Search failed")
 
+    if seen_keys:
+        # Drop before the floors so seen items spend no cross-encoder budget.
+        profiles = _drop_seen_items(profiles or [], "profile", seen_keys)
+        agent_playbooks = _drop_seen_items(
+            agent_playbooks or [], "agent_playbook", seen_keys
+        )
+        user_playbooks = _drop_seen_items(
+            user_playbooks or [], "user_playbook", seen_keys
+        )
+
     if floor_on:
         profiles, agent_playbooks, user_playbooks = _apply_floors(
             query=reformulated_query,
             profiles=profiles,
             agent_playbooks=agent_playbooks,  # type: ignore[arg-type]
             user_playbooks=user_playbooks,  # type: ignore[arg-type]
-            top_k=top_k,
+            top_k=result_cap,
             cfg=floor_cfg,
             recency=recency if recency_on else None,
         )
     elif recency_on and recency is not None:
         profiles = _apply_combined_score_recency(
-            profiles or [], entity_type="profiles", top_k=top_k, cfg=recency
+            profiles or [], entity_type="profiles", top_k=result_cap, cfg=recency
         )
         agent_playbooks = _apply_combined_score_recency(
             agent_playbooks or [],
             entity_type="agent_playbooks",
-            top_k=top_k,
+            top_k=result_cap,
             cfg=recency,
         )
         user_playbooks = _apply_combined_score_recency(
             user_playbooks or [],
             entity_type="user_playbooks",
-            top_k=top_k,
+            top_k=result_cap,
             cfg=recency,
         )
     else:
-        profiles = _unwrap_items(profiles or [])[:top_k]
-        agent_playbooks = _unwrap_items(agent_playbooks or [])[:top_k]
-        user_playbooks = _unwrap_items(user_playbooks or [])[:top_k]
+        profiles = _unwrap_items(profiles or [])[:result_cap]
+        agent_playbooks = _unwrap_items(agent_playbooks or [])[:result_cap]
+        user_playbooks = _unwrap_items(user_playbooks or [])[:result_cap]
+
+    # --- Temporal post-processing from query-derived signals ---
+    if temporal_reorder:
+        arms = [profiles or [], agent_playbooks or [], user_playbooks or []]
+        if reformulation.wants_current:
+            arms = [freshness_collapse(arm) for arm in arms]
+        if reformulation.recency_dominant:
+            arms = [sort_by_recency(arm) for arm in arms]
+        # Final cut to top_k only after the temporal pass, so items promoted
+        # from the wider pool can take the top slots.
+        profiles, agent_playbooks, user_playbooks = (arm[:top_k] for arm in arms)
 
     user_playbooks = _suppress_source_user_playbooks(
         storage=storage,
@@ -218,7 +305,11 @@ def run_unified_search(
         reformulated_query=reformulated_query
         if reformulated_query != request.query
         else None,
+        degraded=embedding_failed,
+        search_mode_effective=effective_search_mode.value if embedding_failed else None,
     )
+    if session_id:
+        session_seen_cache.record(org_id, session_id, _served_entity_keys(response))
     _maybe_capture_final_response(
         request=request,
         response=response,
@@ -257,7 +348,7 @@ def _run_phase_a(
     enable_reformulation: bool = False,
     pre_retrieval_model_name: str | None = None,
     search_mode: SearchMode = SearchMode.HYBRID,
-) -> tuple[str, list[float] | None]:
+) -> tuple[ReformulationResult, list[float] | None, bool]:
     """Run query reformulation and embedding generation sequentially.
 
     Args:
@@ -273,7 +364,16 @@ def _run_phase_a(
         search_mode (SearchMode): Search mode; FTS-only mode skips embedding generation entirely
 
     Returns:
-        tuple[str, Optional[list[float]]]: (standalone_query, embedding_vector) — embedding is None when unsupported or on failure
+        tuple[ReformulationResult, Optional[list[float]], bool]: The
+            reformulation result (standalone query + temporal signals;
+            signal-free pass-through of the original query when reformulation
+            is disabled), the query embedding (None when unsupported, when the
+            mode is FTS-only, or when generation failed), and
+            ``embedding_failed`` — True *only* when an embedding attempt was
+            made and raised. The benign None cases (FTS-only mode,
+            ``supports_embedding`` False) leave ``embedding_failed`` False so
+            callers can distinguish a real failure from a mode that never
+            needed an embedding.
     """
     reformulator = QueryReformulator(
         llm_client=llm_client,
@@ -288,14 +388,14 @@ def _run_phase_a(
         has_conversation_history=bool(conversation_history),
     ):
         if enable_reformulation:
-            result = reformulator.rewrite(query, conversation_history)
-            standalone_query = result.standalone_query
+            reformulation = reformulator.rewrite(query, conversation_history)
         else:
-            standalone_query = query
+            reformulation = ReformulationResult(standalone_query=query)
 
     # Embedding generation (uses reformulated query for semantic accuracy).
     # FTS-only search has no use for an embedding, so skip the call entirely.
     embedding = None
+    embedding_failed = False
     if supports_embedding and search_mode != SearchMode.FTS:
         with profile_step(
             "search.embedding",
@@ -303,13 +403,24 @@ def _run_phase_a(
             purpose="query",
         ) as span:
             try:
-                embedding = _get_cached_query_embedding(storage, standalone_query)
+                embedding = _get_cached_query_embedding(
+                    storage, reformulation.standalone_query
+                )
+                # A falsy result (None or []) means the embedder produced no
+                # usable query vector — e.g. a storage backend that swallows
+                # EmbeddingUnavailableError and returns [] on a provider outage.
+                # Treat it the same as a raised failure: degrade to FTS rather
+                # than run a vector search with an empty embedding.
+                if not embedding:
+                    embedding = None
+                    embedding_failed = True
                 span.set_data("embedding_generated", embedding is not None)
             except Exception as e:
                 span.set_data("embedding_generated", False)
-                logger.error("Embedding generation failed: %s", e)
+                embedding_failed = True
+                logger.exception("Embedding generation failed: %s", e)
 
-    return standalone_query, embedding
+    return reformulation, embedding, embedding_failed
 
 
 def _run_phase_b(
@@ -321,6 +432,9 @@ def _run_phase_b(
     top_k: int,
     threshold: float,
     recency_on: bool = False,
+    start_time: datetime | None = None,
+    end_time: datetime | None = None,
+    search_mode: SearchMode = SearchMode.HYBRID,
 ) -> tuple[
     list[Any] | None,
     list[Any] | None,
@@ -336,11 +450,19 @@ def _run_phase_b(
         query (str): Query string (possibly rewritten) for FTS
         top_k (int): Maximum results per entity type
         threshold (float): Minimum match threshold
+        start_time (Optional[datetime]): Query-derived time-window lower bound
+            (from reformulation temporal signals); forces the per-arm fan-out
+            path since the combined single RPC has no time parameters.
+        end_time (Optional[datetime]): Query-derived time-window upper bound.
+        search_mode (SearchMode): The EFFECTIVE search mode for this fan-out —
+            equal to ``request.search_mode`` normally, but forced to FTS by the
+            caller when embedding generation failed (degrade-to-FTS). Threaded
+            into every arm so storage never re-embeds a failed query.
 
     Returns:
         tuple: (profiles, agent_playbooks, user_playbooks) — all None on timeout/failure
     """
-    options = SearchOptions(query_embedding=embedding, search_mode=request.search_mode)
+    options = SearchOptions(query_embedding=embedding, search_mode=search_mode)
 
     entity_types = set(request.entity_types or _DEFAULT_ENTITY_TYPES)
     allowed_agent_statuses = request.agent_playbook_status_filter
@@ -360,9 +482,16 @@ def _run_phase_b(
             wants_scored_single_rpc = recency_on and callable(
                 getattr(storage, "unified_hybrid_search_scored", None)
             )
-            if _unified_single_rpc_enabled() and (
-                getattr(storage, "supports_unified_hybrid_search", False)
-                or wants_scored_single_rpc
+            # A query-derived time window forces the per-arm fan-out: the
+            # combined single RPC has no time parameters.
+            has_time_window = start_time is not None or end_time is not None
+            if (
+                not has_time_window
+                and _unified_single_rpc_enabled()
+                and (
+                    getattr(storage, "supports_unified_hybrid_search", False)
+                    or wants_scored_single_rpc
+                )
             ):
                 combined = _run_phase_b_single_rpc(
                     request=request,
@@ -374,6 +503,7 @@ def _run_phase_b(
                     entity_types=entity_types,
                     allowed_agent_statuses=allowed_agent_statuses,
                     recency_on=recency_on,
+                    search_mode=search_mode,
                 )
                 if combined is not None:
                     profiles, agent_playbooks, user_playbooks = combined
@@ -398,7 +528,9 @@ def _run_phase_b(
                     threshold,
                     request.user_id,
                     embedding,
-                    request.search_mode,
+                    search_mode,
+                    start_time,
+                    end_time,
                 )
                 if "profiles" in entity_types
                 else None
@@ -415,6 +547,8 @@ def _run_phase_b(
                     request.playbook_name,
                     allowed_agent_statuses,
                     options,
+                    start_time,
+                    end_time,
                 )
                 if "agent_playbooks" in entity_types
                 else None
@@ -428,7 +562,9 @@ def _run_phase_b(
                     status_filter=None,
                     threshold=threshold,
                     top_k=top_k,
-                    search_mode=request.search_mode,
+                    search_mode=search_mode,
+                    start_time=start_time,
+                    end_time=end_time,
                 )
                 user_playbooks_future = _submit_with_current_context(
                     _SEARCH_FANOUT_EXECUTOR,
@@ -485,6 +621,7 @@ def _run_phase_b_single_rpc(
     entity_types: set[str],
     allowed_agent_statuses: list[PlaybookStatus] | None,
     recency_on: bool = False,
+    search_mode: SearchMode = SearchMode.HYBRID,
 ) -> tuple[list[Any], list[Any], list[Any]] | None:
     """Run all Phase B arms through one combined storage round trip.
 
@@ -529,7 +666,7 @@ def _run_phase_b_single_rpc(
         agent_version=request.agent_version,
         playbook_name=request.playbook_name,
         agent_playbook_statuses=statuses,
-        search_mode=request.search_mode,
+        search_mode=search_mode,
         include_profiles="profiles" in entity_types and bool(request.user_id),
         include_agent_playbooks="agent_playbooks" in entity_types,
         include_user_playbooks="user_playbooks" in entity_types,
@@ -664,6 +801,34 @@ def _unwrap_items(items: list[Any]) -> list[Any]:
     return [_unwrap_item(item) for item in items]
 
 
+def _entity_key(kind: str, item: Any) -> EntityKey | None:
+    """Return the session-dedup key for a (possibly score-wrapped) item."""
+    raw_id = getattr(_unwrap_item(item), _ENTITY_ID_ATTRS[kind], None)
+    if raw_id in (None, "", 0):
+        return None
+    return (kind, str(raw_id))
+
+
+def _drop_seen_items(
+    items: list[Any], kind: str, seen: frozenset[EntityKey]
+) -> list[Any]:
+    return [item for item in items if _entity_key(kind, item) not in seen]
+
+
+def _served_entity_keys(response: UnifiedSearchResponse) -> list[EntityKey]:
+    arms: tuple[tuple[str, list[Any]], ...] = (
+        ("profile", response.profiles or []),
+        ("user_playbook", response.user_playbooks or []),
+        ("agent_playbook", response.agent_playbooks or []),
+    )
+    return [
+        key
+        for kind, items in arms
+        for item in items
+        if (key := _entity_key(kind, item)) is not None
+    ]
+
+
 def _suppress_source_user_playbooks(
     *,
     storage: BaseStorage,
@@ -764,12 +929,17 @@ def _search_agent_playbooks_via_storage(
     playbook_name: str | None,
     allowed_statuses: list[PlaybookStatus] | None,
     options: SearchOptions,
+    start_time: datetime | None = None,
+    end_time: datetime | None = None,
 ) -> list[AgentPlaybook]:
     """Search agent playbooks, restricted to one or more approval statuses.
 
     When ``allowed_statuses`` is None or empty, falls back to
     ``_DEFAULT_AGENT_PLAYBOOK_STATUSES`` (APPROVED + PENDING). Callers that
     genuinely want REJECTED playbooks must opt in by passing the full list.
+    ``start_time``/``end_time`` bound ``created_at`` (query-derived time
+    windows from reformulation temporal signals; unset when the query names
+    no window).
     """
     with profile_step(
         "search.branch.agent_playbooks",
@@ -790,6 +960,8 @@ def _search_agent_playbooks_via_storage(
             threshold=threshold,
             top_k=top_k,
             search_mode=options.search_mode,
+            start_time=start_time,
+            end_time=end_time,
         )
         results: list[AgentPlaybook] = []
         seen_ids: set[str] = set()
@@ -812,6 +984,8 @@ def _search_profiles_via_storage(
     user_id: str | None,
     embedding: list[float] | None,
     search_mode: SearchMode,
+    start_time: datetime | None = None,
+    end_time: datetime | None = None,
 ) -> list[UserProfile]:
     """Search profiles via storage.search_user_profile, returning [] on error or missing user_id.
 
@@ -823,6 +997,10 @@ def _search_profiles_via_storage(
         user_id (Optional[str]): User ID filter (required for profile search)
         embedding (Optional[list[float]]): Pre-computed query embedding, or None for text-only search
         search_mode (SearchMode): Search mode (hybrid/vector/fts)
+        start_time (Optional[datetime]): Lower bound on last_modified_timestamp
+            (query-derived time window from reformulation temporal signals;
+            unset when the query names no window)
+        end_time (Optional[datetime]): Upper bound on last_modified_timestamp
 
     Returns:
         list[UserProfile]: Matching profiles, or [] on error/missing user_id
@@ -843,6 +1021,8 @@ def _search_profiles_via_storage(
                     top_k=top_k,
                     threshold=threshold,
                     search_mode=search_mode,
+                    start_time=start_time,
+                    end_time=end_time,
                 ),
                 status_filter=[None],
                 query_embedding=embedding,

package/plugin/vendor/reflexio/reflexio/server/usage_metrics.py

@@ -27,6 +27,7 @@ class UsageEvent:
     pipeline: str | None = None
     entity_type: str | None = None
     entity_id: str | None = None
+    event_key: str | None = None
     extractor_name: str | None = None
     playbook_name: str | None = None
     source: str | None = None
@@ -72,6 +73,7 @@ def record_usage_event(
     pipeline: str | None = None,
     entity_type: str | None = None,
     entity_id: str | None = None,
+    event_key: str | None = None,
     extractor_name: str | None = None,
     playbook_name: str | None = None,
     source: str | None = None,
@@ -109,6 +111,7 @@ def record_usage_event(
                 pipeline=pipeline,
                 entity_type=entity_type,
                 entity_id=entity_id,
+                event_key=event_key,
                 extractor_name=extractor_name,
                 playbook_name=playbook_name,
                 source=source,

package/plugin/vendor/reflexio/reflexio/test_support/llm_mock.py

@@ -34,6 +34,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 from collections.abc import Iterator
 from contextlib import contextmanager
 from typing import Any
@@ -42,6 +43,28 @@ from unittest.mock import MagicMock, patch
 from reflexio.models.structured_output import find_schema_keyword as _find_schema_key
 from reflexio.test_support.llm_model_registry import get_model_registry
 
+_LEARNING_REF_PATTERN = re.compile(r'"learning_ref":\s*"([^"]+)"')
+
+
+def _extract_learning_refs(prompt_content: str) -> list[str]:
+    """Extract unique learning_refs from a judge prompt, preserving order.
+
+    The retrieved-learning judges validate exact per-ref coverage, so the
+    mock must echo the refs actually listed in the prompt rather than a
+    static payload. Only the ``[Retrieved Learnings]`` payload section is
+    scanned — the prompt's ``[Output]`` example also contains a
+    ``"learning_ref"`` placeholder line that must not be echoed.
+    """
+    start = prompt_content.find("[Retrieved Learnings]")
+    if start != -1:
+        end = prompt_content.find("[Output]", start)
+        prompt_content = prompt_content[start : end if end != -1 else None]
+    seen: list[str] = []
+    for ref in _LEARNING_REF_PATTERN.findall(prompt_content):
+        if ref not in seen:
+            seen.append(ref)
+    return seen
+
 
 def _create_mock_completion(
     prompt_content: str, parse_structured_output: bool = False
@@ -55,6 +78,40 @@ def _create_mock_completion(
 
     if "Output just a boolean value" in prompt_content:
         content = str(registry["boolean_evaluation"].minimal_valid)
+    elif "[Retrieved Learning Relevance Evaluation]" in prompt_content:
+        # Echo the refs listed in the prompt — the judge validates exact
+        # coverage, so a static payload would always fail validation.
+        refs = _extract_learning_refs(prompt_content)
+        content = json.dumps(
+            {
+                "verdicts": [
+                    {
+                        "learning_ref": ref,
+                        "is_relevant": True,
+                        "relevance_reason": "Applies to the session task.",
+                    }
+                    for ref in refs
+                ]
+            }
+            if refs
+            else registry["retrieved_learning_relevance"].minimal_valid
+        )
+    elif "[Retrieved Learning Impact Evaluation]" in prompt_content:
+        refs = _extract_learning_refs(prompt_content)
+        content = json.dumps(
+            {
+                "verdicts": [
+                    {
+                        "learning_ref": ref,
+                        "impact": "positive",
+                        "impact_reason": "The response followed this learning.",
+                    }
+                    for ref in refs
+                ]
+            }
+            if refs
+            else registry["retrieved_learning_impact"].minimal_valid
+        )
     elif "policy consolidation" in prompt_content:
         content = json.dumps(registry["playbook_aggregation"].minimal_valid)
     elif (
@@ -72,6 +129,10 @@ def _create_mock_completion(
         content = json.dumps(registry["playbook_extraction"].minimal_valid)
     elif '"tags"' in prompt_content:
         content = json.dumps(registry["tagging"].minimal_valid)
+    elif "standalone_query" in prompt_content:
+        # Query-reformulation prompt (v2+, structured) — anchored on its
+        # primary output field name, which the prompt must describe.
+        content = json.dumps(registry["query_reformulation"].minimal_valid)
     elif parse_structured_output:
         content = json.dumps(registry["profile_extraction"].minimal_valid)
     else:

package/plugin/vendor/reflexio/reflexio/test_support/llm_model_registry.py

@@ -30,9 +30,14 @@ class ModelRegistryEntry:
 def _build_registry() -> dict[str, ModelRegistryEntry]:
     """Build the model registry with lazy imports to avoid circular dependencies."""
     from reflexio.models.api_schema.eval_overview_schema import ShadowComparisonOutput
+    from reflexio.models.api_schema.retriever_schema import ReformulationResult
     from reflexio.server.services.agent_success_evaluation.agent_success_evaluation_constants import (
         AgentSuccessEvaluationOutput,
     )
+    from reflexio.server.services.agent_success_evaluation.components.retrieved_learning_evaluator import (
+        RetrievedLearningImpactOutput,
+        RetrievedLearningRelevanceOutput,
+    )
     from reflexio.server.services.playbook.components.consolidator import (
         PlaybookConsolidationOutput,
     )
@@ -114,6 +119,30 @@ def _build_registry() -> dict[str, ModelRegistryEntry]:
                 "is_escalated": False,
             },
         ),
+        "retrieved_learning_relevance": ModelRegistryEntry(
+            model_class=RetrievedLearningRelevanceOutput,
+            minimal_valid={
+                "verdicts": [
+                    {
+                        "learning_ref": "profile:mock-profile",
+                        "is_relevant": True,
+                        "relevance_reason": "Applies to the session task.",
+                    },
+                ],
+            },
+        ),
+        "retrieved_learning_impact": ModelRegistryEntry(
+            model_class=RetrievedLearningImpactOutput,
+            minimal_valid={
+                "verdicts": [
+                    {
+                        "learning_ref": "profile:mock-profile",
+                        "impact": "positive",
+                        "impact_reason": "The response followed this learning.",
+                    },
+                ],
+            },
+        ),
         "tagging": ModelRegistryEntry(
             model_class=TagsOutput,
             minimal_valid={"tags": ["example_tag"]},
@@ -152,6 +181,10 @@ def _build_registry() -> dict[str, ModelRegistryEntry]:
             model_class=None,
             minimal_valid="true",
         ),
+        "query_reformulation": ModelRegistryEntry(
+            model_class=ReformulationResult,
+            minimal_valid={"standalone_query": "example reformulated query"},
+        ),
     }