claude-smart 0.2.45 → 0.2.47

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

@@ -17,7 +17,8 @@ from collections import OrderedDict
 from collections.abc import Callable
 from concurrent.futures import Future, ThreadPoolExecutor
 from concurrent.futures import TimeoutError as FuturesTimeoutError
-from typing import TYPE_CHECKING, Any
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any, cast
 
 from reflexio.models.api_schema.retriever_schema import (
     ConversationTurn,
@@ -41,7 +42,14 @@ from reflexio.models.config_schema import (
 from reflexio.server.llm.litellm_client import LiteLLMClient
 from reflexio.server.prompt.prompt_manager import PromptManager
 from reflexio.server.services.pre_retrieval import QueryReformulator
-from reflexio.server.services.retrieval.relevance_floor import apply_relevance_floor
+from reflexio.server.services.retrieval.recency import (
+    RecencyConfig,
+    ScoredItem,
+    additive_penalty,
+    decay_for_item,
+    multiplicative_factor,
+)
+from reflexio.server.services.retrieval.relevance_floor import apply_relevance_floors
 from reflexio.server.services.storage.storage_base import BaseStorage
 from reflexio.server.tracing import profile_step, set_span_data
 
@@ -50,6 +58,7 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 _DEFAULT_ENTITY_TYPES = frozenset({"profiles", "agent_playbooks", "user_playbooks"})
+_SOURCE_USER_PLAYBOOK_IDS_KEY = "_source_user_playbook_ids"
 # Statuses returned for agent_playbooks when the caller does not pass an
 # explicit ``agent_playbook_status_filter``. Excludes REJECTED so that a
 # rejection in the dashboard immediately suppresses the playbook from search
@@ -66,6 +75,7 @@ _SEARCH_FANOUT_EXECUTOR = ThreadPoolExecutor(
     max_workers=_SEARCH_FANOUT_MAX_WORKERS,
     thread_name_prefix="reflexio-search",
 )
+_ENV_SINGLE_RPC = "REFLEXIO_UNIFIED_SEARCH_SINGLE_RPC"
 _EMBEDDING_CACHE_TTL_SECONDS = max(
     0, int(os.getenv("REFLEXIO_QUERY_EMBEDDING_CACHE_TTL_SECONDS", "300") or "300")
 )
@@ -76,6 +86,20 @@ _embedding_cache_lock = threading.Lock()
 _embedding_cache: OrderedDict[tuple[str, int, str, str], tuple[float, list[float]]] = (
     OrderedDict()
 )
+RetrievalCaptureHook = Callable[
+    [UnifiedSearchRequest, UnifiedSearchResponse, BaseStorage, str], None
+]
+_retrieval_capture_hook: RetrievalCaptureHook | None = None
+
+
+def configure_retrieval_capture_hook(hook: RetrievalCaptureHook | None) -> None:
+    """Register an optional final-response retrieval capture hook.
+
+    Deployments that capture retrieval logs install the hook; OSS leaves it
+    unset so unified search behavior is unchanged by default.
+    """
+    global _retrieval_capture_hook
+    _retrieval_capture_hook = hook
 
 
 def run_unified_search(
@@ -86,6 +110,7 @@ def run_unified_search(
     prompt_manager: PromptManager,
     pre_retrieval_model_name: str | None = None,
     retrieval_floor: RetrievalFloorConfig | None = None,
+    recency: RecencyConfig | None = None,
 ) -> UnifiedSearchResponse:
     """
     Search across all entity types (profiles, agent playbooks, user playbooks) in parallel.
@@ -113,7 +138,12 @@ def run_unified_search(
 
     floor_cfg = retrieval_floor or RetrievalFloorConfig()
     floor_on = floor_cfg.enabled
-    fetch_k = max(top_k, floor_cfg.pool_size) if floor_on else top_k
+    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(
@@ -137,6 +167,7 @@ def run_unified_search(
         query=reformulated_query,
         top_k=fetch_k,
         threshold=threshold,
+        recency_on=recency_on,
     )
 
     if profiles is None:
@@ -150,9 +181,36 @@ def run_unified_search(
             user_playbooks=user_playbooks,  # type: ignore[arg-type]
             top_k=top_k,
             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
+        )
+        agent_playbooks = _apply_combined_score_recency(
+            agent_playbooks or [],
+            entity_type="agent_playbooks",
+            top_k=top_k,
+            cfg=recency,
+        )
+        user_playbooks = _apply_combined_score_recency(
+            user_playbooks or [],
+            entity_type="user_playbooks",
+            top_k=top_k,
+            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]
 
-    return UnifiedSearchResponse(
+    user_playbooks = _suppress_source_user_playbooks(
+        storage=storage,
+        agent_playbooks=agent_playbooks or [],
+        user_playbooks=user_playbooks or [],
+    )
+
+    response = UnifiedSearchResponse(
         success=True,
         profiles=profiles,
         agent_playbooks=agent_playbooks,  # type: ignore[reportArgumentType]
@@ -161,6 +219,32 @@ def run_unified_search(
         if reformulated_query != request.query
         else None,
     )
+    _maybe_capture_final_response(
+        request=request,
+        response=response,
+        storage=storage,
+        org_id=org_id,
+    )
+    return response
+
+
+def _maybe_capture_final_response(
+    *,
+    request: UnifiedSearchRequest,
+    response: UnifiedSearchResponse,
+    storage: BaseStorage,
+    org_id: str,
+) -> None:
+    hook = _retrieval_capture_hook
+    if hook is None:
+        return
+    try:
+        hook(request, response, storage, org_id)
+    except Exception:
+        logger.warning(
+            "Unified search retrieval capture hook failed",
+            exc_info=True,
+        )
 
 
 def _run_phase_a(
@@ -236,10 +320,11 @@ def _run_phase_b(
     query: str,
     top_k: int,
     threshold: float,
+    recency_on: bool = False,
 ) -> tuple[
-    list[UserProfile] | None,
-    list[AgentPlaybook] | None,
-    list[UserPlaybook] | None,
+    list[Any] | None,
+    list[Any] | None,
+    list[Any] | None,
 ]:
     """Run parallel searches across all entity types by delegating to storage methods.
 
@@ -266,6 +351,43 @@ def _run_phase_b(
             entity_types=sorted(entity_types),
             top_k=top_k,
         ) as span:
+            # Recency needs the per-row ``combined_score``, which only the scored
+            # single-RPC method threads back. Backends that don't advertise
+            # ``supports_unified_hybrid_search`` (e.g. native Postgres, which still
+            # inherits ``unified_hybrid_search_scored`` and runs it via the same
+            # ``_rpc`` it already uses for ``hybrid_match_*``) opt into the scored
+            # path only when recency is on, so non-recency routing is unchanged.
+            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
+            ):
+                combined = _run_phase_b_single_rpc(
+                    request=request,
+                    storage=storage,
+                    embedding=embedding,
+                    query=query,
+                    top_k=top_k,
+                    threshold=threshold,
+                    entity_types=entity_types,
+                    allowed_agent_statuses=allowed_agent_statuses,
+                    recency_on=recency_on,
+                )
+                if combined is not None:
+                    profiles, agent_playbooks, user_playbooks = combined
+                    set_span_data(
+                        span,
+                        {
+                            "single_rpc": True,
+                            "profiles_count": len(profiles),
+                            "agent_playbooks_count": len(agent_playbooks),
+                            "user_playbooks_count": len(user_playbooks),
+                        },
+                    )
+                    return profiles, agent_playbooks, user_playbooks
+                span.set_data("single_rpc_fallback", True)
             profiles_future = (
                 _submit_with_current_context(
                     _SEARCH_FANOUT_EXECUTOR,
@@ -347,6 +469,96 @@ def _run_phase_b(
     return profiles, agent_playbooks, user_playbooks
 
 
+def _unified_single_rpc_enabled() -> bool:
+    """Kill switch for the combined Phase B RPC (default on)."""
+    return os.getenv(_ENV_SINGLE_RPC, "1").strip().lower() not in {"0", "false", "off"}
+
+
+def _run_phase_b_single_rpc(
+    *,
+    request: UnifiedSearchRequest,
+    storage: BaseStorage,
+    embedding: list[float] | None,
+    query: str,
+    top_k: int,
+    threshold: float,
+    entity_types: set[str],
+    allowed_agent_statuses: list[PlaybookStatus] | None,
+    recency_on: bool = False,
+) -> tuple[list[Any], list[Any], list[Any]] | None:
+    """Run all Phase B arms through one combined storage round trip.
+
+    Trades the per-arm round-trip overhead for serialized execution of the
+    three queries inside one database session — a win when round-trip
+    overhead dominates per-arm query time (toggle via
+    ``REFLEXIO_UNIFIED_SEARCH_SINGLE_RPC`` to compare).
+
+    Returns:
+        The three result lists, or None when the combined call fails so the
+        caller can fall back to the per-arm fan-out (e.g. the SQL function
+        is not yet migrated on this deployment). Timeouts propagate like the
+        fan-out path so a hung database is not retried.
+    """
+    statuses = (
+        list(allowed_agent_statuses)
+        if allowed_agent_statuses
+        else list(_DEFAULT_AGENT_PLAYBOOK_STATUSES)
+    )
+    # Resolve storage.unified_hybrid_search before submit so missing or stale
+    # capability flags can fall back to the fan-out path.
+    method_name = (
+        "unified_hybrid_search_scored" if recency_on else "unified_hybrid_search"
+    )
+    unified_hybrid_search = getattr(storage, method_name, None)
+    if not callable(unified_hybrid_search):
+        if recency_on:
+            logger.warning(
+                "event=search_recency_missing_scores source=single_rpc method=%s",
+                method_name,
+            )
+        return None
+
+    future = _submit_with_current_context(
+        _SEARCH_FANOUT_EXECUTOR,
+        unified_hybrid_search,
+        query=query,
+        query_embedding=embedding,
+        top_k=top_k,
+        threshold=threshold,
+        user_id=request.user_id,
+        agent_version=request.agent_version,
+        playbook_name=request.playbook_name,
+        agent_playbook_statuses=statuses,
+        search_mode=request.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,
+    )
+    try:
+        profiles, agent_playbooks, user_playbooks = future.result(timeout=30)
+    except FuturesTimeoutError:
+        raise
+    except Exception:
+        logger.warning(
+            "Unified single-RPC search failed; falling back to per-arm fan-out",
+            exc_info=True,
+        )
+        return None
+
+    # Mirror _search_agent_playbooks_via_storage: dedupe by id, cap at top_k.
+    deduped: list[Any] = []
+    seen_ids: set[str] = set()
+    for candidate in agent_playbooks:
+        playbook = _unwrap_item(candidate)
+        playbook_id = str(getattr(playbook, "agent_playbook_id", ""))
+        if playbook_id and playbook_id not in seen_ids:
+            seen_ids.add(playbook_id)
+            deduped.append(candidate)
+            if len(deduped) >= top_k:
+                break
+    return profiles, deduped, user_playbooks
+
+
 def _apply_floors(
     query: str,
     profiles: list[UserProfile],
@@ -354,37 +566,163 @@ def _apply_floors(
     user_playbooks: list[UserPlaybook],
     top_k: int,
     cfg: RetrievalFloorConfig,
+    recency: RecencyConfig | None = None,
 ) -> tuple[list[UserProfile], list[AgentPlaybook], list[UserPlaybook]]:
-    """Apply the per-arm relevance floor to each entity arm in parallel."""
-    with ThreadPoolExecutor(max_workers=3) as ex:
-        f_profiles = _submit_with_current_context(
-            ex,
-            apply_relevance_floor,
-            query,
-            profiles,
-            cfg.profile_floor,
-            top_k,
-            arm="profiles",
+    """Apply the per-arm relevance floor with one batched cross-encoder call."""
+    floored_profiles, floored_agent, floored_user = apply_relevance_floors(
+        query,
+        [
+            ("profiles", profiles, cfg.profile_floor),
+            ("agent_playbooks", agent_playbooks, cfg.agent_playbook_floor),
+            ("user_playbooks", user_playbooks, cfg.user_playbook_floor),
+        ],
+        top_k,
+        content_of=lambda item: _unwrap_item(item).content,
+    )
+    return (
+        _finalize_floor_arm(
+            floored_profiles, entity_type="profiles", top_k=top_k, recency=recency
+        ),
+        _finalize_floor_arm(
+            floored_agent,
+            entity_type="agent_playbooks",
+            top_k=top_k,
+            recency=recency,
+        ),
+        _finalize_floor_arm(
+            floored_user,
+            entity_type="user_playbooks",
+            top_k=top_k,
+            recency=recency,
+        ),
+    )
+
+
+def _finalize_floor_arm(
+    result: Any,
+    *,
+    entity_type: str,
+    top_k: int,
+    recency: RecencyConfig | None,
+) -> list[Any]:
+    if not recency or not recency.enabled:
+        return _unwrap_items(result.items)[:top_k]
+    if result.scores is None:
+        return _apply_combined_score_recency(
+            result.items, entity_type=entity_type, top_k=top_k, cfg=recency
+        )
+    now = int(datetime.now(UTC).timestamp())
+    rescored = []
+    for item, score in zip(result.items, result.scores, strict=True):
+        unwrapped = _unwrap_item(item)
+        freshness = decay_for_item(unwrapped, entity_type=entity_type, now=now)
+        rescored.append(
+            (unwrapped, score - additive_penalty(freshness, recency.max_penalty_logit))
         )
-        f_agent = _submit_with_current_context(
-            ex,
-            apply_relevance_floor,
-            query,
-            agent_playbooks,
-            cfg.agent_playbook_floor,
-            top_k,
-            arm="agent_playbooks",
+    rescored.sort(key=lambda pair: pair[1], reverse=True)
+    return [item for item, _score in rescored[:top_k]]
+
+
+def _apply_combined_score_recency(
+    items: list[Any],
+    *,
+    entity_type: str,
+    top_k: int,
+    cfg: RecencyConfig,
+) -> list[Any]:
+    if not items:
+        return []
+    scored_items: list[tuple[Any, float]] = []
+    for item in items:
+        if not isinstance(item, ScoredItem) or item.score is None:
+            logger.warning(
+                "event=search_recency_missing_scores entity_type=%s items=%d",
+                entity_type,
+                len(items),
+            )
+            return _unwrap_items(items)[:top_k]
+        scored_items.append((item.item, item.score))
+    now = int(datetime.now(UTC).timestamp())
+    rescored = []
+    for item, score in scored_items:
+        freshness = decay_for_item(item, entity_type=entity_type, now=now)
+        rescored.append(
+            (
+                item,
+                score * multiplicative_factor(freshness, cfg.max_penalty_frac),
+            )
         )
-        f_user = _submit_with_current_context(
-            ex,
-            apply_relevance_floor,
-            query,
-            user_playbooks,
-            cfg.user_playbook_floor,
-            top_k,
-            arm="user_playbooks",
+    rescored.sort(key=lambda pair: pair[1], reverse=True)
+    return [item for item, _score in rescored[:top_k]]
+
+
+def _unwrap_item(item: Any) -> Any:
+    return item.item if isinstance(item, ScoredItem) else item
+
+
+def _unwrap_items(items: list[Any]) -> list[Any]:
+    return [_unwrap_item(item) for item in items]
+
+
+def _suppress_source_user_playbooks(
+    *,
+    storage: BaseStorage,
+    agent_playbooks: list[AgentPlaybook],
+    user_playbooks: list[UserPlaybook],
+) -> list[UserPlaybook]:
+    """Drop user playbooks already represented by returned agent playbooks."""
+    if not agent_playbooks or not user_playbooks:
+        return user_playbooks
+
+    source_user_playbook_ids: set[int] = set()
+    agent_ids_needing_lookup: list[int] = []
+    for playbook in agent_playbooks:
+        source_ids = getattr(playbook, _SOURCE_USER_PLAYBOOK_IDS_KEY, None)
+        if source_ids is None:
+            agent_playbook_id = int(getattr(playbook, "agent_playbook_id", 0) or 0)
+            if agent_playbook_id:
+                agent_ids_needing_lookup.append(agent_playbook_id)
+            continue
+        source_user_playbook_ids.update(int(source_id) for source_id in source_ids)
+
+    if agent_ids_needing_lookup:
+        lookup = getattr(
+            storage, "get_source_user_playbook_ids_for_agent_playbooks", None
         )
-        return f_profiles.result(), f_agent.result(), f_user.result()
+        if callable(lookup):
+            try:
+                source_ids_by_agent = cast(
+                    dict[int, list[int]], lookup(agent_ids_needing_lookup)
+                )
+            except Exception:
+                logger.warning(
+                    "Failed to resolve source user playbooks for unified search suppression",
+                    exc_info=True,
+                )
+            else:
+                for source_ids in source_ids_by_agent.values():
+                    source_user_playbook_ids.update(
+                        int(source_id) for source_id in source_ids
+                    )
+
+    if not source_user_playbook_ids:
+        return user_playbooks
+
+    filtered = [
+        playbook
+        for playbook in user_playbooks
+        if int(getattr(playbook, "user_playbook_id", 0) or 0)
+        not in source_user_playbook_ids
+    ]
+    suppressed_count = len(user_playbooks) - len(filtered)
+    if suppressed_count:
+        with profile_step(
+            "search.suppress_source_user_playbooks",
+            suppressed_count=suppressed_count,
+            source_user_playbook_count=len(source_user_playbook_ids),
+        ):
+            pass
+    return filtered
 
 
 def _get_cached_query_embedding(

package/plugin/vendor/reflexio/reflexio/server/site_var/README.md

@@ -11,7 +11,7 @@ Description: Global configuration manager for site-wide variables and per-org fe
 
 ## Purpose
 
-1. **Global settings** - Model names, embedding models
+1. **Global settings** - Model names, embedding models, and retrieval defaults
 2. **Feature flags** - Per-org feature gating (global enable or per-org allowlist)
 3. **Dual storage** - File-based with optional Redis caching
 4. **Auto-fallback** - Redis → File system graceful degradation
@@ -62,6 +62,7 @@ site_var/
 └── site_var_sources/
     ├── app_config.json        # JSON → parsed dict
     ├── model_config.json
+    ├── search_settings.json   # Default retrieval mode and hybrid search weights
     └── feature_flags.json     # Feature flag config (per-flag enable + org allowlist)
 ```
 

package/plugin/vendor/reflexio/reflexio/server/site_var/feature_flags.py

@@ -55,7 +55,7 @@ def is_feature_enabled(org_id: str, feature_name: str) -> bool:
     if feature_config.get("enabled", False):
         return True
 
-    enabled_org_ids = feature_config.get("enabled_org_ids", [])
+    enabled_org_ids = feature_config.get("enabled_org_ids", []) or []
     return org_id in enabled_org_ids
 
 
@@ -103,6 +103,103 @@ def is_deduplicator_enabled(org_id: str) -> bool:
     return is_feature_enabled(org_id, "deduplicator")
 
 
+def _is_fail_closed_flag_enabled(org_id: str, feature_key: str) -> bool:
+    """
+    Shared fail-closed helper: returns False if key absent or config malformed.
+
+    Unlike is_feature_enabled (fail-open), this function returns False when the
+    feature key is absent or when its value is not a dict. This is the safety
+    invariant for soft-delete flags — unconfigured or malformed entries must
+    never accidentally activate tombstone-producing paths.
+
+    A feature is enabled if:
+    - The feature's "enabled" field is True (globally enabled), OR
+    - The org_id is in the feature's "enabled_org_ids" list.
+
+    Args:
+        org_id (str): The organization ID to check
+        feature_key (str): The feature flag key in the config dict
+
+    Returns:
+        bool: True only if the feature is explicitly enabled for this org
+    """
+    config = _get_feature_flags_config()
+    feature_config = config.get(feature_key)
+
+    if feature_config is None:
+        # Key absent — fail-CLOSED
+        return False
+
+    if not isinstance(feature_config, dict):
+        logger.warning(
+            "feature_flags[%s] is not a dict (got %s), defaulting to OFF",
+            feature_key,
+            type(feature_config).__name__,
+        )
+        return False
+
+    # Strict bool identity — truthy strings like "false" must not enable (#195).
+    enabled = feature_config.get("enabled", False)
+    if enabled is True:
+        return True
+
+    # Reject non-list values — a string does substring `in` match, not membership (#195).
+    org_ids = feature_config.get("enabled_org_ids", [])
+    if not isinstance(org_ids, list):
+        return False
+    return org_id in org_ids
+
+
+def _is_default_open_flag_enabled(org_id: str, feature_key: str) -> bool:
+    """
+    Shared default-open helper for soft-delete flags.
+
+    Returns True when the feature key is absent from config (default ON), but
+    preserves all explicit-disable and per-org override semantics:
+    - Key absent or None → True (default ON — GC is also ON by default).
+    - Key present but malformed (not a dict) → False with a warning (safe fallback).
+    - Key present, enabled=True → True for all orgs.
+    - Key present, enabled=False, org in enabled_org_ids → True.
+    - Key present, enabled=False, org NOT in enabled_org_ids → False (explicit disable).
+
+    Strict-bool and strict-list guards from _is_fail_closed_flag_enabled are
+    preserved: truthy strings and non-bool ints do NOT enable, and a string
+    enabled_org_ids does NOT match via substring (anti-#195).
+
+    Args:
+        org_id (str): The organization ID to check
+        feature_key (str): The feature flag key in the config dict
+
+    Returns:
+        bool: True when the flag is on (including when absent/unconfigured)
+    """
+    config = _get_feature_flags_config()
+    feature_config = config.get(feature_key)
+
+    if feature_config is None:
+        # Key absent — default OPEN (soft-delete is on by default; GC runs too).
+        return True
+
+    if not isinstance(feature_config, dict):
+        logger.warning(
+            "feature_flags[%s] is not a dict (got %s), defaulting to OFF",
+            feature_key,
+            type(feature_config).__name__,
+        )
+        return False
+
+    # Strict bool identity — truthy strings like "false" must not enable (#195).
+    enabled = feature_config.get("enabled", False)
+    if enabled is True:
+        return True
+
+    # Reject non-list values — a string does substring `in` match, not membership (#195).
+    org_ids = feature_config.get("enabled_org_ids", [])
+    if not isinstance(org_ids, list):
+        return False
+    return org_id in org_ids
+
+
 def is_resumable_extraction_agent_enabled(org_id: str) -> bool:
     """
     Convenience check for whether classic extraction should use the resumable agent.
@@ -114,3 +211,25 @@ def is_resumable_extraction_agent_enabled(org_id: str) -> bool:
         bool: True if the resumable extraction agent is enabled
     """
     return is_feature_enabled(org_id, "resumable_extraction_agent")
+
+
+def is_lineage_dual_read_diff_enabled(org_id: str) -> bool:
+    """
+    Check if the lineage dual-read diff path is enabled for a given organization.
+
+    Defaults to DISABLED when the key is absent from config (default-CLOSED). This
+    flag gates an experimental read path that compares new and old lineage query
+    results side-by-side; it must never activate accidentally on unconfigured
+    deployments.
+
+    A feature is enabled only if:
+    - The feature's "enabled" field is True (globally enabled), OR
+    - The org_id is in the feature's "enabled_org_ids" list.
+
+    Args:
+        org_id (str): The organization ID to check
+
+    Returns:
+        bool: True only if the feature is explicitly enabled for this org
+    """
+    return _is_fail_closed_flag_enabled(org_id, "lineage_dual_read_diff")

package/plugin/vendor/reflexio/reflexio/server/site_var/site_var_sources/feature_flags.json

@@ -9,5 +9,9 @@
     "resumable_extraction_agent": {
         "enabled": true,
         "enabled_org_ids": []
+    },
+    "lineage_dual_read_diff": {
+        "enabled": true,
+        "enabled_org_ids": []
     }
 }

package/plugin/vendor/reflexio/reflexio/server/site_var/site_var_sources/search_settings.json

@@ -0,0 +1,5 @@
+{
+    "search_mode": "hybrid",
+    "vector_weight": 1.0,
+    "fts_weight": 1.0
+}