claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/_profiles.py

@@ -22,6 +22,13 @@ class ProfileMixin:
         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,
     ) -> list[UserProfile]:
         raise NotImplementedError
 
@@ -34,6 +41,13 @@ class ProfileMixin:
         self,
         user_id: str,
         status_filter: list[Status | None] | None = None,
+        tags: list[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,
     ) -> list[UserProfile]:
         raise NotImplementedError
 
@@ -78,6 +92,13 @@ class ProfileMixin:
     ) -> None:
         raise NotImplementedError
 
+    @abstractmethod
+    def update_user_profile_tags(
+        self, user_id: str, profile_id: str, tags: list[str]
+    ) -> None:
+        """Replace only the tags of a profile, leaving content and embedding untouched."""
+        raise NotImplementedError
+
     @abstractmethod
     def delete_all_interactions_for_user(self, user_id: str) -> None:
         raise NotImplementedError
@@ -178,6 +199,22 @@ class ProfileMixin:
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def get_profile_by_id(
+        self, profile_id: str, *, include_tombstones: bool = False
+    ) -> UserProfile | None:
+        """Fetch a single profile by primary key.
+
+        Args:
+            profile_id: The profile's primary key.
+            include_tombstones: When False (default), MERGED/SUPERSEDED profiles
+                return None. Set to True for lineage resolution (resolve_current).
+
+        Returns:
+            The UserProfile if found and not filtered, otherwise None.
+        """
+        raise NotImplementedError
+
     @abstractmethod
     def archive_profile_by_id(self, user_id: str, profile_id: str) -> bool:
         """Atomically archive a single profile by id, only if currently CURRENT.
@@ -220,17 +257,113 @@ class ProfileMixin:
         raise NotImplementedError
 
     @abstractmethod
-    def delete_profiles_by_ids(self, profile_ids: list[str]) -> int:
+    def delete_profiles_by_ids(
+        self, profile_ids: list[str], *, emit_hard_delete: bool = True
+    ) -> int:
         """Delete profiles by their IDs.
 
         Args:
             profile_ids (list[str]): List of profile IDs to delete
+            emit_hard_delete (bool): When True (default), emit a ``hard_delete``
+                lineage event for each id before removing the row.  Pass ``False``
+                from rollback callers that cleaned up a never-CURRENT successor to
+                avoid poisoning the audit log with phantom erasures.
 
         Returns:
             int: Number of profiles deleted
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def get_distinct_generated_from_request_ids(self) -> list[str]:
+        """Return the DISTINCT non-empty generated_from_request_id values present on profiles.
+
+        Scoped to the org. Includes profiles of any status (tombstones included) so
+        that an add-only run whose profiles were later tombstoned is still discoverable.
+        Empty-string values are excluded by the query (they must never form a group).
+
+        Used by ``reconstruct_profile_change_log`` to discover add-only dedup runs
+        (runs that added new profiles but superseded nothing, which emit no lineage
+        event and would otherwise be invisible).
+
+        Returns:
+            list[str]: Distinct non-empty ``generated_from_request_id`` values.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_profiles_by_generated_from_request_id(
+        self,
+        request_id: str,
+    ) -> list[UserProfile]:
+        """Return all profiles (any status, including tombstones) for a given generated_from_request_id.
+
+        Scoped to the org. Used by reconstruct_profile_change_log to find the
+        "added" side of a dedup run without depending on mutable status columns.
+        The column is set at profile creation and never changes — it is the
+        time-travel-stable signal for "added in run R".
+
+        Args:
+            request_id (str): The generated_from_request_id value to filter on.
+
+        Returns:
+            list[UserProfile]: All profiles (live or tombstone) whose
+                ``generated_from_request_id`` matches, scoped by org.
+        """
+        raise NotImplementedError
+
+    def get_all_generated_profiles(self) -> list[UserProfile]:
+        """Return every profile (any status, incl. tombstones) with a non-empty
+        ``generated_from_request_id``, scoped to the org.
+
+        Bulk equivalent of :meth:`get_profiles_by_generated_from_request_id` — it
+        lets ``reconstruct_profile_change_log`` resolve the "added" side of every
+        run in a single query instead of one read per candidate request_id (an
+        org-history-sized fan-out on network-backed storage).
+
+        The default implementation loops the per-id reads, so every backend is
+        correct without an override; backends SHOULD override it with a single
+        ``WHERE generated_from_request_id <> ''`` query for the performance win.
+
+        Returns:
+            list[UserProfile]: All profiles with a non-empty
+                ``generated_from_request_id``.
+        """
+        out: list[UserProfile] = []
+        for request_id in self.get_distinct_generated_from_request_ids():
+            out.extend(self.get_profiles_by_generated_from_request_id(request_id))
+        return out
+
+    @abstractmethod
+    def supersede_profiles_by_ids(
+        self,
+        user_id: str,
+        profile_ids: list[str],
+        request_id: str,
+    ) -> list[str]:
+        """Soft-delete profiles by setting status to SUPERSEDED, emitting set-based lineage.
+
+        For each profile id that matches (user_id, current status in {NULL/CURRENT,
+        PENDING}), updates status to SUPERSEDED and emits one ``status_change``
+        lineage event under the shared ``request_id``.  Rows are NOT physically
+        deleted — reads that exclude tombstones will simply filter them out by status.
+
+        Args:
+            user_id (str): Owning user id. Predicate scoped to this user.
+            profile_ids (list[str]): Profile ids to supersede. Already-superseded or
+                non-existent ids are silently skipped.
+            request_id (str): Shared request id to stamp on all emitted events so the
+                entire dedup run is reconstructible from a single id.
+
+        Returns:
+            list[str]: The profile ids that were actually superseded by this call, in
+                input order. Already-superseded or non-existent ids are omitted (so an
+                empty list means nothing committed). Callers needing a count use
+                ``len(...)``. This is the commit-accurate set used to build a
+                commit-atomic legacy change-log "removed" entry.
+        """
+        raise NotImplementedError
+
     # Search methods
     @abstractmethod
     def search_interaction(

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/_requests.py

@@ -4,6 +4,7 @@ from reflexio.models.api_schema.domain import Request
 from reflexio.models.api_schema.internal_schema import (
     RequestInteractionDataModel,
     SessionDescriptor,
+    SessionFirstRequest,
 )
 
 
@@ -79,6 +80,7 @@ class RequestMixin:
         end_time: int | None = None,
         top_k: int | None = 30,
         offset: int = 0,
+        source: str | None = None,
     ) -> dict[str, list[RequestInteractionDataModel]]:
         """Get requests with their associated interactions, grouped by session_id.
 
@@ -86,6 +88,7 @@ class RequestMixin:
             user_id (str, optional): User ID to filter requests.
             request_id (str, optional): Specific request ID to retrieve
             session_id (str, optional): Specific session ID to retrieve
+            source (str, optional): Request source to match exactly.
             start_time (int, optional): Start timestamp for filtering
             end_time (int, optional): End timestamp for filtering
             top_k (int, optional): Maximum number of requests to return
@@ -152,3 +155,62 @@ class RequestMixin:
             list[SessionDescriptor]: Deduped descriptors ordered by session_id.
         """
         raise NotImplementedError
+
+    def get_first_requests_by_session_ids(
+        self, session_ids: list[str]
+    ) -> dict[str, SessionFirstRequest]:
+        """Return earliest-request metadata for each requested session.
+
+        Default implementation preserves the historical storage contract by
+        calling ``get_sessions`` per session. SQL backends should override with
+        a set-based query.
+        """
+        out: dict[str, SessionFirstRequest] = {}
+        for session_id in set(session_ids):
+            requests = []
+            page_size = 1000
+            offset = 0
+            while True:
+                grouped = self.get_sessions(
+                    session_id=session_id,
+                    top_k=page_size,
+                    offset=offset,
+                )
+                rows = grouped.get(session_id) or []
+                requests.extend(r.request for r in rows if r.request is not None)
+                if len(rows) < page_size:
+                    break
+                offset += page_size
+            if not requests:
+                continue
+            first = min(requests, key=lambda r: r.created_at)
+            out[session_id] = SessionFirstRequest(
+                session_id=session_id,
+                user_id=first.user_id,
+                source=first.source or "",
+                created_at=first.created_at,
+            )
+        return out
+
+    def get_first_requests_by_user_session_pairs(
+        self, pairs: list[tuple[str, str]]
+    ) -> dict[tuple[str, str], SessionFirstRequest]:
+        """Return earliest-request metadata for each requested (user_id, session_id).
+
+        Default implementation preserves backend compatibility by calling the
+        existing user-scoped request lookup per distinct pair. SQL backends
+        override with set-based queries.
+        """
+        out: dict[tuple[str, str], SessionFirstRequest] = {}
+        for user_id, session_id in set(pairs):
+            requests = self.get_requests_by_session(user_id, session_id)
+            if not requests:
+                continue
+            first = min(requests, key=lambda r: r.created_at)
+            out[(user_id, session_id)] = SessionFirstRequest(
+                session_id=session_id,
+                user_id=user_id,
+                source=first.source or "",
+                created_at=first.created_at,
+            )
+        return out

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/_retrieval_log.py

@@ -0,0 +1,51 @@
+from reflexio.models.api_schema.domain.entities import PlaybookRetrievalLog
+
+
+class RetrievalLogMixin:
+    """Mixin for playbook retrieval log storage methods.
+
+    These methods are optional retrieval-capture storage hooks. They are
+    intentionally concrete (not ``@abstractmethod``) so concrete storage classes
+    remain instantiable; each raises ``NotImplementedError`` until a backend
+    provides a real implementation.
+    """
+
+    def save_playbook_retrieval_log(self, log: PlaybookRetrievalLog) -> int:
+        """Persist a retrieval log entry and return its assigned id.
+
+        Args:
+            log (PlaybookRetrievalLog): The log entry to save. ``retrieval_log_id``
+                may be 0; the storage layer assigns a real id on insert.
+
+        Returns:
+            int: The assigned ``retrieval_log_id``.
+        """
+        raise NotImplementedError
+
+    def get_playbook_retrieval_logs(
+        self,
+        *,
+        session_id: str | None = None,
+        request_id: str | None = None,
+        interaction_id: int | None = None,
+        user_id: str | None = None,
+        start_time: int | None = None,
+        end_time: int | None = None,
+    ) -> list[PlaybookRetrievalLog]:
+        """Retrieve playbook retrieval log entries, optionally filtered.
+
+        Args:
+            session_id (str | None): Filter to logs for this session. If None,
+                no session filter is applied.
+            request_id (str | None): Filter to logs for this request. If None,
+                no request filter is applied.
+            interaction_id (int | None): Filter to logs for this interaction.
+            user_id (str | None): Filter to logs for this user.
+            start_time (int | None): Inclusive lower bound on ``created_at``.
+            end_time (int | None): Inclusive upper bound on ``created_at``.
+
+        Returns:
+            list[PlaybookRetrievalLog]: Matching log entries, ordered by
+                ``created_at`` ascending.
+        """
+        raise NotImplementedError

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/_shadow_verdicts.py

@@ -108,6 +108,23 @@ class ShadowVerdictsMixin:
             f"{type(self).__name__} does not support shadow_comparison_verdicts"
         )
 
+    def get_recent_shadow_comparison_verdicts(
+        self,
+        from_ts: int,
+        to_ts: int,
+        judge_prompt_version: str,
+        limit: int,
+    ) -> list[ShadowComparisonVerdict]:
+        """Fetch newest verdicts in descending ``created_at`` order."""
+        if limit <= 0:
+            return []
+        verdicts = self.get_shadow_comparison_verdicts(
+            from_ts=from_ts,
+            to_ts=to_ts,
+            judge_prompt_version=judge_prompt_version,
+        )
+        return list(reversed(verdicts))[:limit]
+
     def delete_shadow_comparison_verdicts_by_session(self, session_id: str) -> int:
         """Remove all verdicts for one session.
 

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/playbook/__init__.py

@@ -0,0 +1,13 @@
+from ._agent import AgentPlaybookStoreMixin
+from ._eval_results import AgentEvaluationResultStoreMixin
+from ._optimization import OptimizationJobStoreMixin
+from ._source_linkage import PlaybookSourceLinkageMixin
+from ._user import UserPlaybookStoreMixin
+
+__all__ = [
+    "AgentEvaluationResultStoreMixin",
+    "AgentPlaybookStoreMixin",
+    "OptimizationJobStoreMixin",
+    "PlaybookSourceLinkageMixin",
+    "UserPlaybookStoreMixin",
+]