claude-smart 0.2.45 → 0.2.47

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

@@ -23,20 +23,36 @@ from ._agent_run import (
 )
 from ._base import BaseStorageCore, matches_status_filter
 from ._extras import ExtrasMixin
+from ._governance import GovernanceMixin
+from ._lineage import EntityType, LineageEventMixin
 from ._operations import OperationMixin
-from ._playbook import PlaybookMixin
 from ._profiles import ProfileMixin
 from ._requests import RequestMixin
+from ._retrieval_log import RetrievalLogMixin
 from ._shadow_verdicts import ShadowVerdictsMixin
 from ._share_links import ShareLinkMixin
 from ._stall_state import StallStateMixin
+from .playbook import (
+    AgentEvaluationResultStoreMixin,
+    AgentPlaybookStoreMixin,
+    OptimizationJobStoreMixin,
+    PlaybookSourceLinkageMixin,
+    UserPlaybookStoreMixin,
+)
 
 
 class BaseStorage(
     AgentRunMixin,
     ProfileMixin,
     RequestMixin,
-    PlaybookMixin,
+    AgentPlaybookStoreMixin,
+    UserPlaybookStoreMixin,
+    PlaybookSourceLinkageMixin,
+    OptimizationJobStoreMixin,
+    AgentEvaluationResultStoreMixin,
+    RetrievalLogMixin,
+    GovernanceMixin,
+    LineageEventMixin,
     OperationMixin,
     ExtrasMixin,
     ShareLinkMixin,
@@ -46,6 +62,65 @@ class BaseStorage(
 ):
     """Base class for storage."""
 
+    def _is_lineage_tombstone(self, entity_type: EntityType, entity_id: str) -> bool:
+        """Return True when the entity row is a tombstone (merged_into or superseded_by set).
+
+        Uses the portable ``include_tombstones=True`` getters so the check
+        works for every backend without backend-specific SQL.
+
+        Args:
+            entity_type (EntityType): ``"profile"`` or ``"user_playbook"``.
+            entity_id (str): The entity's primary key as a string.
+
+        Returns:
+            bool: True if the row has ``merged_into`` or ``superseded_by`` set.
+        """
+        if entity_type == "profile":
+            row = self.get_profile_by_id(entity_id, include_tombstones=True)
+            if row is None:
+                return False
+            return bool(row.merged_into or row.superseded_by)
+        if entity_type == "user_playbook":
+            row = self.get_user_playbook_by_id(int(entity_id), include_tombstones=True)
+            if row is None:
+                return False
+            return bool(row.merged_into or row.superseded_by)
+        return False
+
+    def _partition_purge_vs_delete(
+        self, entity_type: EntityType, ids: list[str]
+    ) -> tuple[list[str], list[str]]:
+        """Split entity ids into purge-eligible and hard-delete sets.
+
+        An entity is purge-eligible when it is a tombstone (``merged_into`` or
+        ``superseded_by`` is set) **or** is pointed to by another row
+        (``has_inbound_lineage_refs`` returns True). All other ids go to the
+        hard-delete set.
+
+        Uses only portable storage reads so this helper works for every
+        backend (SQLite, Supabase, Postgres). Callers that need
+        backend-specific efficiency may override ``clear_user_data`` instead.
+
+        Args:
+            entity_type (EntityType): ``"profile"`` or ``"user_playbook"``.
+            ids (list[str]): Entity primary keys as strings.
+
+        Returns:
+            tuple[list[str], list[str]]: ``(purge_ids, delete_ids)`` where
+                ``purge_ids`` are content-purge candidates and ``delete_ids``
+                are safe to hard-delete.
+        """
+        purge_ids: list[str] = []
+        delete_ids: list[str] = []
+        for eid in ids:
+            if self._is_lineage_tombstone(
+                entity_type, eid
+            ) or self.has_inbound_lineage_refs(entity_type=entity_type, entity_id=eid):
+                purge_ids.append(eid)
+            else:
+                delete_ids.append(eid)
+        return purge_ids, delete_ids
+
     def clear_user_data(self, user_id: str) -> dict[str, int]:
         """Delete all rows scoped to a single ``user_id``.
 
@@ -57,38 +132,72 @@ class BaseStorage(
         parallel tasks without one task's clear-all nuking another
         in-flight task's rows.
 
+        **Lineage-aware erasure:** rows that are tombstones (``merged_into``
+        or ``superseded_by`` is set) *or* are pointed to by another row
+        (``has_inbound_lineage_refs`` returns True) are content-purged
+        (skeleton kept, body blanked) rather than hard-deleted. Standalone
+        rows with no lineage involvement are hard-deleted.
+
         The default implementation composes existing per-user / by-ids
         primitives so any backend that implements those (sqlite, supabase,
         postgres, ...) gets correct behaviour for free.
         Subclasses MAY override for atomic / transactional efficiency.
 
+        **Atomicity note (default path only):** this default implementation is
+        NOT wrapped in a single transaction. Each ``purge_content`` call commits
+        independently, so a crash mid-erasure may leave some purge-eligible rows
+        with PII intact until ``clear_user_data`` is re-invoked. The call is
+        idempotent — re-invoking it is safe and will finish the erasure.
+
         Args:
             user_id (str): The user id whose rows should be deleted.
 
         Returns:
-            dict[str, int]: Per-entity deletion counts with keys
-                ``interactions``, ``user_playbooks``, ``profiles``, and
-                ``requests``. Counts reflect pre-deletion totals for the
-                user (i.e. how many rows existed for that user).
+            dict[str, int]: Per-entity counts with keys ``interactions``,
+                ``user_playbooks``, ``profiles``, ``requests``,
+                ``purged_profiles``, and ``purged_user_playbooks``.
+                ``profiles`` and ``user_playbooks`` reflect hard-deleted
+                counts; purged rows are counted separately.
         """
         interaction_count = len(self.get_user_interaction(user_id))
 
-        # Snapshot user_playbook ids for the user so we can both count
-        # and delete via the existing bulk-by-ids primitive (no per-user
-        # playbook delete primitive exists at the mixin level).
-        user_playbook_ids = [
-            up.user_playbook_id
+        # All statuses a user's row can have — including tombstones (SUPERSEDED,
+        # MERGED). Erasure MUST reach every row the user owns regardless of
+        # status; the old filter excluded tombstones, leaving them in the DB
+        # after clear_user_data (GDPR regression).
+        _all_statuses: list[Status | None] = [
+            None,  # CURRENT
+            Status.ARCHIVED,
+            Status.PENDING,
+            Status.ARCHIVE_IN_PROGRESS,
+            Status.SUPERSEDED,
+            Status.MERGED,
+        ]
+
+        # Snapshot user_playbook ids for the user and partition into
+        # purge vs delete sets.
+        raw_upb_ids = [
+            str(up.user_playbook_id)
             for up in self.get_user_playbooks(
                 user_id=user_id,
                 limit=1_000_000,
-                status_filter=[None, Status.ARCHIVED, Status.PENDING],
+                status_filter=_all_statuses,
             )
             if up.user_playbook_id is not None
         ]
-        profile_count = len(
-            self.get_user_profile(
-                user_id, status_filter=[None, Status.ARCHIVED, Status.PENDING]
-            )
+        purge_upb_ids, delete_upb_ids = self._partition_purge_vs_delete(
+            "user_playbook", raw_upb_ids
+        )
+
+        # Snapshot profile ids for the user and partition into
+        # purge vs delete sets.
+        raw_profile_ids = [
+            p.profile_id
+            for p in self.get_user_profile(user_id, status_filter=_all_statuses)
+            if p.profile_id is not None
+        ]
+        purge_profile_ids, delete_profile_ids = self._partition_purge_vs_delete(
+            "profile", raw_profile_ids
         )
 
         # Snapshot request ids for the user so we can both count and
@@ -103,30 +212,43 @@ class BaseStorage(
         ]
 
         # Delete in dependency-safe order: interactions first (they
-        # reference requests), then user playbooks (also reference
-        # requests), then profiles, then the requests themselves.
+        # reference requests), then user playbooks, then profiles, then
+        # requests. Only the delete-sets are hard-deleted; purge-sets are
+        # content-purged below.
         self.delete_all_interactions_for_user(user_id)
         deleted_user_playbooks = (
-            self.delete_user_playbooks_by_ids(user_playbook_ids)
-            if user_playbook_ids
+            self.delete_user_playbooks_by_ids([int(i) for i in delete_upb_ids])
+            if delete_upb_ids
             else 0
         )
-        self.delete_all_profiles_for_user(user_id)
+        deleted_profiles = (
+            self.delete_profiles_by_ids(delete_profile_ids) if delete_profile_ids else 0
+        )
         deleted_requests = (
             self.delete_requests_by_ids(request_ids) if request_ids else 0
         )
 
+        # Content-purge the purge-eligible rows after the hard-deletes.
+        for pid in purge_profile_ids:
+            self.purge_content(entity_type="profile", entity_id=pid)
+        for upid in purge_upb_ids:
+            self.purge_content(entity_type="user_playbook", entity_id=upid)
+
         return {
             "interactions": interaction_count,
             "user_playbooks": deleted_user_playbooks,
-            "profiles": profile_count,
+            "profiles": deleted_profiles,
             "requests": deleted_requests,
+            "purged_profiles": len(purge_profile_ids),
+            "purged_user_playbooks": len(purge_upb_ids),
         }
 
 
 __all__ = [
     "AgentBinding",
     "AgentRunMixin",
+    "EntityType",
+    "LineageEventMixin",
     "AgentRunRecord",
     "AgentRunStatus",
     "BaseStorage",
@@ -134,7 +256,12 @@ __all__ = [
     "PendingToolCallRecord",
     "PendingToolCallStatus",
     "PendingToolCallUpsertResult",
-    "PlaybookMixin",
+    "AgentEvaluationResultStoreMixin",
+    "AgentPlaybookStoreMixin",
+    "OptimizationJobStoreMixin",
+    "PlaybookSourceLinkageMixin",
+    "UserPlaybookStoreMixin",
+    "RetrievalLogMixin",
     "PriorAnswerMatch",
     "RunToolDependencyKind",
     "RunToolDependencyRecord",

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

@@ -11,6 +11,8 @@ from datetime import datetime
 from enum import StrEnum
 from typing import Any
 
+from reflexio.models.api_schema.pending_tool_call_schema import PendingToolCallStatus
+
 _WHITESPACE_RE = re.compile(r"\s+")
 
 
@@ -28,14 +30,6 @@ class AgentRunStatus(StrEnum):
     CANCELLED = "cancelled"
 
 
-class PendingToolCallStatus(StrEnum):
-    PENDING = "pending"
-    RESOLVED = "resolved"
-    EXPIRED = "expired"
-    SUPERSEDED = "superseded"
-    CANCELLED = "cancelled"
-
-
 NOT_APPLICABLE_ANSWER = "User does not have information about this question."
 
 

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

@@ -40,6 +40,11 @@ class BaseStorageCore(ABC):  # noqa: B024
     # Capability flag — backends that implement `_get_embedding` set this to True.
     supports_embedding: ClassVar[bool] = False
 
+    # Capability flag — backends that can serve every unified-search arm in a
+    # single database round trip expose a `unified_hybrid_search` method and
+    # set this to True (see reflexio.server.services.unified_search_service).
+    supports_unified_hybrid_search: ClassVar[bool] = False
+
     def __init__(self, org_id: str, base_dir: str | None = None) -> None:
         self.org_id = org_id
         if base_dir is None:

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

@@ -6,14 +6,13 @@ from reflexio.models.api_schema.braintrust_schema import (
 )
 from reflexio.models.api_schema.domain import (
     Interaction,
-    PlaybookAggregationChangeLog,
-    ProfileChangeLog,
 )
+from reflexio.models.api_schema.internal_schema import SessionCitation
 from reflexio.models.api_schema.retriever_schema import PlaybookApplicationStat
 
 
 class ExtrasMixin:
-    """Mixin for dashboard, profile change logs, playbook aggregation change logs, and misc methods."""
+    """Mixin for dashboard, profile change logs, and misc methods."""
 
     # ==============================
     # Dashboard methods
@@ -30,10 +29,10 @@ class ExtrasMixin:
             dict: Dictionary containing:
                 - current_period: Stats for the current period (days_back)
                 - previous_period: Stats for the previous period (for trend calculation)
-                - interactions_time_series: List of time series data points (raw, ungrouped)
-                - profiles_time_series: List of time series data points (raw, ungrouped)
-                - playbooks_time_series: List of time series data points (raw, ungrouped)
-                - evaluations_time_series: List of time series data points (raw, ungrouped)
+                - interactions_time_series: Daily bucketed interaction counts
+                - profiles_time_series: Daily bucketed profile counts
+                - playbooks_time_series: Daily bucketed playbook counts
+                - evaluations_time_series: Daily bucketed success rates with optional counts
         """
         raise NotImplementedError
 
@@ -72,56 +71,6 @@ class ExtrasMixin:
         """
         raise NotImplementedError
 
-    # ==============================
-    # Profile Change Log methods
-    # ==============================
-
-    @abstractmethod
-    def add_profile_change_log(self, profile_change_log: ProfileChangeLog) -> None:
-        """Add a profile change log entry."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_profile_change_logs(self, limit: int = 100) -> list[ProfileChangeLog]:
-        """Get profile change logs for an organization."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def delete_profile_change_log_for_user(self, user_id: str) -> None:
-        """Delete all profile change logs for a user."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def delete_all_profile_change_logs(self) -> None:
-        """Delete all profile change logs."""
-        raise NotImplementedError
-
-    # ==============================
-    # Playbook Aggregation Change Log methods
-    # ==============================
-
-    @abstractmethod
-    def add_playbook_aggregation_change_log(
-        self, change_log: PlaybookAggregationChangeLog
-    ) -> None:
-        """Add a playbook aggregation change log entry."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_playbook_aggregation_change_logs(
-        self,
-        playbook_name: str,
-        agent_version: str,
-        limit: int = 100,
-    ) -> list[PlaybookAggregationChangeLog]:
-        """Get playbook aggregation change logs filtered by playbook_name and agent_version."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def delete_all_playbook_aggregation_change_logs(self) -> None:
-        """Delete all playbook aggregation change logs."""
-        raise NotImplementedError
-
     # ==============================
     # Misc methods
     # ==============================
@@ -171,6 +120,40 @@ class ExtrasMixin:
         """
         return []
 
+    def get_citations_by_session_ids(
+        self,
+        session_ids: list[str],
+    ) -> list[SessionCitation]:
+        """Return rule/profile citations for the requested sessions.
+
+        Default implementation uses ``get_interactions_by_session`` so legacy
+        backends keep working. SQL backends should override with a bulk
+        request/interactions join.
+        """
+        out: list[SessionCitation] = []
+        for session_id in set(session_ids):
+            for interaction in self.get_interactions_by_session(session_id):
+                for cite in getattr(interaction, "citations", []) or []:
+                    if isinstance(cite, dict):
+                        kind = cite.get("kind")
+                        real_id = cite.get("real_id")
+                        title = cite.get("title") or ""
+                    else:
+                        kind = getattr(cite, "kind", None)
+                        real_id = getattr(cite, "real_id", None)
+                        title = getattr(cite, "title", "") or ""
+                    if kind and real_id:
+                        out.append(
+                            SessionCitation(
+                                user_id="",
+                                session_id=session_id,
+                                kind=str(kind),
+                                real_id=str(real_id),
+                                title=str(title),
+                            )
+                        )
+        return out
+
     # ==============================
     # Braintrust connector (default no-ops; backends override)
     # ==============================

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

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Literal
+
+from reflexio.models.api_schema.domain.governance import (
+    AuditEvent,
+    PurgeOperation,
+    PurgeOperationTarget,
+    SubjectWriteBarrier,
+)
+from reflexio.models.config_schema import GovernanceRetentionConfig
+
+
+class GovernanceMixin(ABC):
+    """Mixin for backend-neutral governance storage primitives."""
+
+    @abstractmethod
+    def append_audit_event(self, event: AuditEvent) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_audit_events(
+        self, subject_ref: str | None = None, *, org_id: str | None = None
+    ) -> list[AuditEvent]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def begin_purge_operation(
+        self,
+        purge_id: str,
+        idempotency_key: str,
+        operation_type: Literal["user_erasure", "org_purge"],
+        scope_type: Literal["user", "org"],
+        subject_ref: str | None,
+        request_ref: str,
+    ) -> PurgeOperation:
+        raise NotImplementedError
+
+    @abstractmethod
+    def record_purge_target(
+        self,
+        purge_id: str,
+        target_name: str,
+        phase: str,
+        status: Literal["pending", "running", "failed", "complete"],
+        target_ref: str = "",
+        detail: dict[str, object] | None = None,
+        deleted_count: int = 0,
+        error_detail: str | None = None,
+    ) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_purge_targets(
+        self, purge_id: str, phase: str | None = None
+    ) -> list[PurgeOperationTarget]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def purge_targets_prepared(self, purge_id: str) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def prepare_governance_erase_targets(
+        self,
+        purge_id: str,
+        user_id: str,
+        owned_user_playbook_ids: set[int] | None = None,
+    ) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def hide_governance_agent_playbooks_for_rebuild(self, purge_id: str) -> list[int]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def apply_governance_user_data_delete(
+        self, purge_id: str, user_id: str
+    ) -> dict[str, int]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def apply_governance_agent_playbook_rebuild(
+        self,
+        purge_id: str,
+        agent_playbook_id: int,
+        remaining_source_windows: list[dict[str, object]],
+        content: str | None,
+        trigger: str | None,
+        rationale: str | None,
+        blocking_issue: dict[str, object] | None,
+        expanded_terms: str | None,
+        tags: list[str] | None,
+    ) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def complete_purge_operation_with_audit(
+        self, purge_id: str, audit_event: AuditEvent
+    ) -> PurgeOperation:
+        raise NotImplementedError
+
+    @abstractmethod
+    def begin_subject_erasure_barrier(
+        self, subject_ref: str, purge_id: str
+    ) -> SubjectWriteBarrier:
+        raise NotImplementedError
+
+    @abstractmethod
+    def assert_subject_writable(self, subject_ref: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def complete_subject_erasure_barrier_after_empty_check(
+        self, purge_id: str, audit_event: AuditEvent
+    ) -> PurgeOperation:
+        raise NotImplementedError
+
+    @abstractmethod
+    def fail_subject_erasure_barrier(
+        self,
+        subject_ref: str,
+        purge_id: str,
+        error_code: str,
+        error_detail: str,
+    ) -> SubjectWriteBarrier:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_subject_write_barrier(
+        self, subject_ref: str
+    ) -> SubjectWriteBarrier | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def fail_purge_operation(
+        self, purge_id: str, error_code: str, error_detail: str
+    ) -> PurgeOperation:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_purge_operation(self, purge_id: str) -> PurgeOperation:
+        raise NotImplementedError
+
+    @abstractmethod
+    def gc_governance_retention(self, *, config: GovernanceRetentionConfig) -> int:
+        raise NotImplementedError