claude-smart 0.2.44 → 0.2.46

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

@@ -17,7 +17,7 @@ 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 typing import TYPE_CHECKING, Any, cast
 
 from reflexio.models.api_schema.retriever_schema import (
     ConversationTurn,
@@ -41,7 +41,7 @@ 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.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 +50,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 +67,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 +78,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(
@@ -152,7 +168,13 @@ def run_unified_search(
             cfg=floor_cfg,
         )
 
-    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 +183,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(
@@ -266,6 +314,33 @@ def _run_phase_b(
             entity_types=sorted(entity_types),
             top_k=top_k,
         ) as span:
+            if (
+                getattr(storage, "supports_unified_hybrid_search", False)
+                and _unified_single_rpc_enabled()
+            ):
+                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,
+                )
+                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 +422,86 @@ 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,
+) -> tuple[list[UserProfile], list[AgentPlaybook], list[UserPlaybook]] | 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.
+    unified_hybrid_search = getattr(storage, "unified_hybrid_search", None)
+    if not callable(unified_hybrid_search):
+        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[AgentPlaybook] = []
+    seen_ids: set[str] = set()
+    for playbook in agent_playbooks:
+        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(playbook)
+            if len(deduped) >= top_k:
+                break
+    return profiles, deduped, user_playbooks
+
+
 def _apply_floors(
     query: str,
     profiles: list[UserProfile],
@@ -355,36 +510,78 @@ def _apply_floors(
     top_k: int,
     cfg: RetrievalFloorConfig,
 ) -> 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",
-        )
-        f_agent = _submit_with_current_context(
-            ex,
-            apply_relevance_floor,
-            query,
-            agent_playbooks,
-            cfg.agent_playbook_floor,
-            top_k,
-            arm="agent_playbooks",
-        )
-        f_user = _submit_with_current_context(
-            ex,
-            apply_relevance_floor,
-            query,
-            user_playbooks,
-            cfg.user_playbook_floor,
-            top_k,
-            arm="user_playbooks",
+    """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,
+    )
+    return floored_profiles, floored_agent, floored_user
+
+
+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
+}

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

@@ -156,3 +156,33 @@ def sentry_tags(**tags: Any) -> Iterator[None]:
             scope_cm.__exit__(None, None, None)
         except Exception as exc:  # noqa: BLE001
             logger.warning("Failed to close Sentry scope: %s", exc)
+
+
+def capture_anomaly(message: str, *, level: str = "warning", **tags: Any) -> None:
+    """Report a non-fatal anomaly to Sentry, if the SDK is installed.
+
+    For silent-but-noteworthy conditions that return rather than raise — e.g.
+    lineage resolution hitting a cycle or the hop cap, or a best-effort
+    provenance append failing. No-op when ``sentry-sdk`` is absent (the OS
+    package does not depend on it; enterprise deployments pull it in). Never
+    raises — instrumentation must not turn a degraded-but-working path into a
+    failure.
+
+    Args:
+        message: short, low-cardinality description of the anomaly (the Sentry
+            issue title), e.g. ``"lineage.resolve_current.cycle"``.
+        level: Sentry severity ("warning", "error", ...). Defaults to "warning".
+        **tags: contextual tag name → value pairs (None values are skipped).
+    """
+    try:
+        import sentry_sdk  # type: ignore[import-not-found]
+    except ImportError:
+        return
+    try:
+        with sentry_sdk.new_scope() as scope:
+            for key, value in tags.items():
+                if value is not None:
+                    scope.set_tag(key, str(value))
+            sentry_sdk.capture_message(message, level=level)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("Failed to capture Sentry anomaly %r: %s", message, exc)

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

@@ -34,6 +34,12 @@ class UsageEvent:
     backend: str | None = None
     outcome: str | None = None
     count_value: int = 1
+    prompt_tokens: int | None = None
+    completion_tokens: int | None = None
+    billing_input_tokens: int | None = None
+    platform_llm: bool | None = None
+    platform_storage: bool | None = None
+    caller_type: str | None = None
     duration_ms: int | None = None
     error_kind: str | None = None
     metadata: Mapping[str, Any] = field(default_factory=dict)
@@ -73,6 +79,12 @@ def record_usage_event(
     backend: str | None = None,
     outcome: str | None = None,
     count_value: int = 1,
+    prompt_tokens: int | None = None,
+    completion_tokens: int | None = None,
+    billing_input_tokens: int | None = None,
+    platform_llm: bool | None = None,
+    platform_storage: bool | None = None,
+    caller_type: str | None = None,
     duration_ms: int | None = None,
     error_kind: str | None = None,
     metadata: Mapping[str, Any] | None = None,
@@ -104,6 +116,12 @@ def record_usage_event(
                 backend=backend,
                 outcome=outcome,
                 count_value=count_value,
+                prompt_tokens=prompt_tokens,
+                completion_tokens=completion_tokens,
+                billing_input_tokens=billing_input_tokens,
+                platform_llm=platform_llm,
+                platform_storage=platform_storage,
+                caller_type=caller_type,
                 duration_ms=duration_ms,
                 error_kind=error_kind,
                 metadata=metadata or {},