claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/lib/_profiles.py

@@ -1,14 +1,21 @@
 import logging
+from collections import defaultdict
 
 logger = logging.getLogger(__name__)
 
 from datetime import UTC, datetime
+from typing import Protocol
 
 from reflexio.lib._base import (
     STORAGE_NOT_CONFIGURED_MSG,
     ReflexioBase,
     _require_storage,
 )
+from reflexio.models.api_schema.domain.entities import (
+    LineageEvent,
+    ProfileChangeLog,
+    UserProfile,
+)
 from reflexio.models.api_schema.retriever_schema import (
     GetProfileStatisticsResponse,
     GetUserProfilesRequest,
@@ -36,7 +43,7 @@ from reflexio.models.api_schema.service_schemas import (
     UpgradeProfilesRequest,
     UpgradeProfilesResponse,
 )
-from reflexio.server.services.profile.profile_generation_service import (
+from reflexio.server.services.profile.service import (
     ProfileGenerationService,
 )
 from reflexio.server.tracing import profile_step
@@ -199,15 +206,21 @@ class ProfilesMixin(ReflexioBase):
         )
 
     def get_profile_change_logs(self) -> ProfileChangeLogResponse:
-        """Get profile change logs.
+        """Get profile change logs, served from the lineage reconstruction.
+
+        The change-log view is rebuilt on demand from ``lineage_event`` linkage
+        joined to survivor/tombstone content via
+        :func:`reconstruct_profile_change_log`. The legacy ``profile_change_logs``
+        table is no longer written (B3 Task 6) or read (B3 Task 7); it is retained
+        frozen until its removal in Task 8.
 
         Returns:
-            ProfileChangeLogResponse: Response containing profile change logs
+            ProfileChangeLogResponse: Response containing the reconstructed
+                profile change logs.
         """
         if not self._is_storage_configured():
             return ProfileChangeLogResponse(success=True, profile_change_logs=[])
-        changelogs = self._get_storage().get_profile_change_logs()
-        return ProfileChangeLogResponse(success=True, profile_change_logs=changelogs)
+        return reconstruct_profile_change_log(self._get_storage())
 
     @_require_storage(DeleteUserProfileResponse)
     def delete_profile(
@@ -401,26 +414,22 @@ class ProfilesMixin(ReflexioBase):
                 status_filter = [None]  # Default to current profiles
 
         profiles = self._get_storage().get_user_profile(
-            request.user_id, status_filter=status_filter
+            request.user_id,
+            status_filter=status_filter,
+            tags=request.tags,
+            profile_id=request.profile_id,
+            query=request.query,
+            source=request.source,
+            profile_time_to_live=request.profile_time_to_live,
+            start_time=(
+                int(request.start_time.timestamp()) if request.start_time else None
+            ),
+            end_time=int(request.end_time.timestamp()) if request.end_time else None,
         )
         profiles = sorted(
             profiles, key=lambda x: x.last_modified_timestamp, reverse=True
         )
 
-        # Apply time filters
-        if request.start_time:
-            profiles = [
-                p
-                for p in profiles
-                if p.last_modified_timestamp >= int(request.start_time.timestamp())
-            ]
-        if request.end_time:
-            profiles = [
-                p
-                for p in profiles
-                if p.last_modified_timestamp <= int(request.end_time.timestamp())
-            ]
-
         # Apply top_k limit
         if request.top_k:
             profiles = sorted(
@@ -437,6 +446,13 @@ class ProfilesMixin(ReflexioBase):
         self,
         limit: int = 100,
         status_filter: list[Status | None] | None = None,
+        user_id: str | None = None,
+        profile_id: str | None = None,
+        query: str | None = None,
+        source: str | None = None,
+        profile_time_to_live: str | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
     ) -> GetUserProfilesResponse:
         """Get all user profiles across all users.
 
@@ -454,7 +470,15 @@ class ProfilesMixin(ReflexioBase):
         if status_filter is None:
             status_filter = [None]  # Default to current profiles
         profiles = self._get_storage().get_all_profiles(
-            limit=limit, status_filter=status_filter
+            limit=limit,
+            status_filter=status_filter,
+            user_id=user_id,
+            profile_id=profile_id,
+            query=query,
+            source=source,
+            profile_time_to_live=profile_time_to_live,
+            start_time=start_time,
+            end_time=end_time,
         )
         profiles = sorted(
             profiles, key=lambda x: x.last_modified_timestamp, reverse=True
@@ -543,3 +567,182 @@ class ProfilesMixin(ReflexioBase):
             return GetProfileStatisticsResponse(
                 success=False, msg=f"Failed to get profile statistics: {str(e)}"
             )
+
+
+# ---------------------------------------------------------------------------
+# Standalone read-side reconstruction (Phase B3 Task 2)
+# ---------------------------------------------------------------------------
+
+
+class ChangeLogReadStorage(Protocol):
+    """The storage read surface ``reconstruct_profile_change_log`` requires.
+
+    Both the real ``BaseStorage`` backends and the read-only
+    ``RestStorageReader`` satisfy this structurally — no inheritance required —
+    so reconstruction can run against either without an unsound ``cast`` to
+    ``BaseStorage``.
+    """
+
+    org_id: str
+
+    def get_lineage_events(
+        self,
+        *,
+        entity_type: str | None = ...,
+        entity_id: str | None = ...,
+        org_id: str | None = ...,
+        request_id: str | None = ...,
+    ) -> list[LineageEvent]: ...
+
+    def get_distinct_generated_from_request_ids(self) -> list[str]: ...
+
+    def get_profiles_by_generated_from_request_id(
+        self, request_id: str
+    ) -> list[UserProfile]: ...
+
+    def get_all_generated_profiles(self) -> list[UserProfile]: ...
+
+    def get_profile_by_id(
+        self, profile_id: str, *, include_tombstones: bool = ...
+    ) -> UserProfile | None: ...
+
+
+def reconstruct_profile_change_log(
+    storage: ChangeLogReadStorage,
+    *,
+    limit: int = 100,
+) -> ProfileChangeLogResponse:
+    """Rebuild the ProfileChangeLog view using time-travel-stable signals.
+
+    Uses two immutable / stable signals to classify every dedup run:
+
+    * **added(R)** — profiles whose ``generated_from_request_id == R``.  This
+      column is set at creation and never changes, so it correctly classifies
+      a profile as "added in run R" even if it is later tombstoned in run R2.
+      Tombstones are included so the content is available.
+
+    * **removed(R)** — entity_ids of ``status_change`` lineage events with
+      ``to_status == "superseded"`` and ``request_id == R``.  This is the
+      exact signature emitted by ``supersede_profiles_by_ids`` (the dedup
+      soft-delete path).  It is distinct from reflection which emits
+      ``op="revise"``, so reflection events are never mis-counted as removals.
+
+    Groups are formed over the union of request_ids from both signals.
+    Request_id ``""`` is skipped — it would merge unrelated runs.
+    A row is emitted only when ``added or removed`` is non-empty (matching
+    legacy semantics: the legacy table was written only when
+    ``all_new_profiles or superseded_profiles``).
+
+    When a removed profile's tombstone has been physically purged (GDPR GC),
+    it is silently omitted from ``removed_profiles`` rather than crashing.
+
+    Args:
+        storage (ChangeLogReadStorage): Storage read surface to query (any
+            BaseStorage backend or the read-only ``RestStorageReader``).
+        limit (int): Maximum number of reconstructed entries to return.
+            Defaults to 100.
+
+    Returns:
+        ProfileChangeLogResponse: ``success=True`` with reconstructed rows
+            ordered most-recent first (by max event ``created_at`` in each
+            request_id group), capped at ``limit``.
+    """
+    if limit <= 0:
+        return ProfileChangeLogResponse(success=True, profile_change_logs=[])
+
+    all_events = storage.get_lineage_events(
+        entity_type="profile", org_id=storage.org_id
+    )
+
+    # Dedup soft-delete signature: status_change to_status=="superseded".
+    # Each such event records one profile removed in the dedup run ``request_id``.
+    # Distinct from reflection which emits op="revise" — so revise events are
+    # never counted as removals here.
+    removal_by_req: dict[str, list[str]] = defaultdict(list)
+    sort_key: dict[str, tuple[int, int]] = {}  # request_id -> (created_at, event_id)
+    for evt in all_events:
+        key = evt.request_id
+        if not key:
+            continue  # skip empty-string request_ids — never merge unrelated runs
+        cur = sort_key.get(key, (0, 0))
+        if (evt.created_at, evt.event_id) > cur:
+            sort_key[key] = (evt.created_at, evt.event_id)
+        if evt.op == "status_change" and evt.to_status == "superseded":
+            removal_by_req[key].append(evt.entity_id)
+
+    # Resolve the "added" side for every run in ONE bulk read, grouped by each
+    # profile's immutable generated_from_request_id. This replaces a read per
+    # candidate request_id, which fanned out over the org's whole dedup history
+    # before the limit slice below — a hot-path N+1 on network-backed storage now
+    # that the live endpoint serves this reconstruction.
+    added_by_req: dict[str, list] = defaultdict(list)
+    for profile in storage.get_all_generated_profiles():
+        added_by_req[profile.generated_from_request_id].append(profile)
+
+    # Candidate request_ids are the UNION of:
+    #   (a) lineage EVENT request_ids — runs that produced a dedup removal
+    #       (status_change/superseded event); and
+    #   (b) request_ids stamped on profile rows (the keys of added_by_req) —
+    #       discovers ADD-ONLY dedup runs (new profiles, nothing superseded) that
+    #       emit no lineage event. ``get_all_generated_profiles`` already excludes
+    #       the empty-string sentinel, so unrelated runs are never merged.
+    #
+    # This closes the reconstruction-completeness gap for add-only runs: the
+    # legacy `add_profile_change_log` fired whenever `all_new_profiles or
+    # superseded_profiles` was non-empty, so a run with only adds was still
+    # recorded. The (b) path mirrors that.
+    #
+    # For add-only runs (in set (b) but not (a)), no event timestamp exists.
+    # We derive their sort key from the max `last_modified_timestamp` of the
+    # profiles in that group — set at creation, giving a sensible most-recent-first
+    # ordering relative to event-timestamped runs. The secondary key is 0.
+    candidate_req_ids: set[str] = set(sort_key.keys()) | set(added_by_req.keys())
+
+    def _effective_sort_key(req_id: str) -> tuple[int, int]:
+        """Return (timestamp, event_id) for sorting; for add-only runs fall back to
+        the max last_modified_timestamp of the profiles in that group."""
+        if req_id in sort_key:
+            return sort_key[req_id]
+        profiles = added_by_req.get(req_id, [])
+        max_ts = max((p.last_modified_timestamp for p in profiles), default=0)
+        return (max_ts, 0)
+
+    sorted_keys = sorted(
+        candidate_req_ids,
+        key=_effective_sort_key,
+        reverse=True,
+    )[:limit]
+
+    logs: list[ProfileChangeLog] = []
+    for req_id in sorted_keys:
+        # added: profiles whose generated_from_request_id == req_id (any status,
+        # include tombstones — a profile added in R1 and tombstoned in R2 is still
+        # "added in R1").
+        added = added_by_req[req_id]
+
+        # removed: dedup-superseded profiles from this run's lineage events.
+        removed: list = []
+        for entity_id in removal_by_req.get(req_id, []):
+            profile = storage.get_profile_by_id(entity_id, include_tombstones=True)
+            if profile is not None:
+                removed.append(profile)
+            # Tombstone physically purged (GDPR GC) → silently omit; no crash.
+
+        if not added and not removed:
+            # No dedup activity for this request_id — skip to match legacy semantics.
+            continue
+
+        ts, _ = _effective_sort_key(req_id)
+        user_id = added[0].user_id if added else removed[0].user_id
+        logs.append(
+            ProfileChangeLog(
+                id=0,
+                user_id=user_id,
+                request_id=req_id,
+                created_at=ts,
+                added_profiles=added,
+                removed_profiles=removed,
+            )
+        )
+
+    return ProfileChangeLogResponse(success=True, profile_change_logs=logs)

package/plugin/vendor/reflexio/reflexio/lib/_reflection.py

@@ -41,7 +41,7 @@ class ReflectionMixin(ReflexioBase):
 
         # Local import keeps the heavy service module out of facade
         # cold-start when reflection is disabled.
-        from reflexio.server.services.reflection.reflection_service import (
+        from reflexio.server.services.reflection.service import (
             ReflectionService,
         )
 

package/plugin/vendor/reflexio/reflexio/lib/_search.py

@@ -13,6 +13,7 @@ from reflexio.models.api_schema.retriever_schema import (
 )
 from reflexio.server.llm.model_defaults import ModelRole, resolve_model_name
 from reflexio.server.site_var.site_var_manager import SiteVarManager
+from reflexio.server.tracing import profile_step
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -40,9 +41,23 @@ class SearchMixin(ReflexioBase):
             request = GetAgentSuccessEvaluationResultsRequest(**request)
 
         try:
-            results = self._get_storage().get_agent_success_evaluation_results(
-                limit=request.limit or 100, agent_version=request.agent_version
-            )
+            if request.start_time or request.end_time:
+                results = self._get_storage().get_agent_success_evaluation_results_in_window(
+                    from_ts=(
+                        int(request.start_time.timestamp()) if request.start_time else 0
+                    ),
+                    to_ts=(
+                        int(request.end_time.timestamp())
+                        if request.end_time
+                        else 2**31 - 1
+                    ),
+                    limit=request.limit or 100,
+                    agent_version=request.agent_version,
+                )
+            else:
+                results = self._get_storage().get_agent_success_evaluation_results(
+                    limit=request.limit or 100, agent_version=request.agent_version
+                )
             return GetAgentSuccessEvaluationResultsResponse(
                 success=True,
                 agent_success_evaluation_results=results,
@@ -78,6 +93,7 @@ class SearchMixin(ReflexioBase):
                 user_id=request.user_id,
                 request_id=request.request_id,
                 session_id=request.session_id,
+                source=request.source,
                 start_time=(
                     int(request.start_time.timestamp()) if request.start_time else None
                 ),
@@ -103,10 +119,11 @@ class SearchMixin(ReflexioBase):
                     Session(session_id=group_name, requests=request_data_list)
                 )
 
-            # Determine has_more: count total requests returned across all groups
+            # Pagination is session-based (top_k counts sessions): there may be
+            # more pages when this page filled the session limit.
             total_returned = sum(len(s.requests) for s in sessions)
             effective_limit = request.top_k or 100
-            has_more = total_returned >= effective_limit
+            has_more = len(sessions) >= effective_limit
 
             return GetRequestsResponse(
                 success=True,
@@ -136,32 +153,42 @@ class SearchMixin(ReflexioBase):
         if isinstance(request, dict):
             request = UnifiedSearchRequest(**request)
 
-        config = self.request_context.configurator.get_config()
+        with profile_step(
+            "search.prepare",
+            enabled=bool(request.enable_reformulation),
+            has_conversation_history=bool(request.conversation_history),
+            search_mode=request.search_mode,
+        ):
+            config = self.request_context.configurator.get_config()
+            config_llm_config = config.llm_config if config else None
+
+            # Resolve pre_retrieval_model_name: config override -> site var -> auto-detect.
+            model_setting = SiteVarManager().get_site_var("llm_model_setting")
+            site_var = model_setting if isinstance(model_setting, dict) else {}
+            api_key_config = config.api_key_config if config else None
+
+            pre_retrieval_model_name = resolve_model_name(
+                ModelRole.PRE_RETRIEVAL,
+                site_var_value=site_var.get("pre_retrieval_model_name"),
+                config_override=config_llm_config.pre_retrieval_model_name
+                if config_llm_config
+                else None,
+                api_key_config=api_key_config,
+            )
+            storage = self._get_storage()
+            prompt_manager = self.request_context.prompt_manager
+            retrieval_floor = config.retrieval_floor if config else None
+            recency = getattr(storage, "recency", None)
 
         from reflexio.server.services.unified_search_service import run_unified_search
 
-        config_llm_config = config.llm_config if config else None
-
-        # Resolve pre_retrieval_model_name: config override → site var → auto-detect
-        model_setting = SiteVarManager().get_site_var("llm_model_setting")
-        site_var = model_setting if isinstance(model_setting, dict) else {}
-        api_key_config = config.api_key_config if config else None
-
-        pre_retrieval_model_name = resolve_model_name(
-            ModelRole.PRE_RETRIEVAL,
-            site_var_value=site_var.get("pre_retrieval_model_name"),
-            config_override=config_llm_config.pre_retrieval_model_name
-            if config_llm_config
-            else None,
-            api_key_config=api_key_config,
-        )
-
         return run_unified_search(
             request=request,
             org_id=org_id,
-            storage=self._get_storage(),
+            storage=storage,
             llm_client=self.llm_client,
-            prompt_manager=self.request_context.prompt_manager,
+            prompt_manager=prompt_manager,
             pre_retrieval_model_name=pre_retrieval_model_name,
-            retrieval_floor=config.retrieval_floor if config else None,
+            retrieval_floor=retrieval_floor,
+            recency=recency,
         )

package/plugin/vendor/reflexio/reflexio/lib/_user_playbook.py

@@ -24,7 +24,7 @@ from reflexio.models.api_schema.service_schemas import (
     UpgradeUserPlaybooksResponse,
 )
 from reflexio.models.config_schema import SearchOptions
-from reflexio.server.services.playbook.playbook_generation_service import (
+from reflexio.server.services.playbook.service import (
     PlaybookGenerationService,
 )
 from reflexio.server.tracing import profile_step
@@ -53,10 +53,20 @@ class UserPlaybookMixin(ReflexioBase):
         try:
             user_playbooks = self._get_storage().get_user_playbooks(
                 limit=request.limit or 100,
+                user_playbook_id=request.user_playbook_id,
                 user_id=request.user_id,
+                request_id=request.request_id,
+                query=request.query,
                 playbook_name=request.playbook_name,
                 agent_version=request.agent_version,
                 status_filter=request.status_filter,
+                start_time=(
+                    int(request.start_time.timestamp()) if request.start_time else None
+                ),
+                end_time=(
+                    int(request.end_time.timestamp()) if request.end_time else None
+                ),
+                tags=request.tags,
             )
             return GetUserPlaybooksResponse(
                 success=True,

package/plugin/vendor/reflexio/reflexio/models/api_schema/domain/__init__.py

@@ -1,3 +1,4 @@
 from ..common import *  # noqa: F401, F403
 from .entities import *  # noqa: F401, F403
 from .enums import *  # noqa: F401, F403
+from .governance import *  # noqa: F401, F403