claude-smart 0.2.44 → 0.2.46

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

@@ -1,12 +1,12 @@
 """Request CRUD methods for SQLite storage."""
 
-import json
 import sqlite3
 from typing import Any
 
 from reflexio.models.api_schema.internal_schema import (
     RequestInteractionDataModel,
     SessionDescriptor,
+    SessionFirstRequest,
 )
 from reflexio.models.api_schema.service_schemas import (
     Request,
@@ -15,6 +15,7 @@ from reflexio.models.api_schema.service_schemas import (
 from ._base import (
     SQLiteStorageBase,
     _epoch_to_iso,
+    _iso_to_epoch,
     _row_to_interaction,
     _row_to_request,
 )
@@ -39,7 +40,7 @@ class RequestMixin:
         created_at_iso = _epoch_to_iso(request.created_at)
         self._execute(
             """INSERT OR REPLACE INTO requests
-               (request_id, user_id, created_at, source, agent_version, session_id, metadata)
+               (request_id, user_id, created_at, source, agent_version, session_id, evaluation_only)
                VALUES (?,?,?,?,?,?,?)""",
             (
                 request.request_id,
@@ -48,7 +49,7 @@ class RequestMixin:
                 request.source,
                 request.agent_version,
                 request.session_id,
-                json.dumps(request.metadata, sort_keys=True),
+                1 if request.evaluation_only else 0,
             ),
         )
 
@@ -261,3 +262,76 @@ class RequestMixin:
             )
             for r in rows
         ]
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_first_requests_by_session_ids(
+        self, session_ids: list[str]
+    ) -> dict[str, SessionFirstRequest]:
+        if not session_ids:
+            return {}
+        out: dict[str, SessionFirstRequest] = {}
+        ids = sorted(set(session_ids))
+        chunk_size = 500
+        for i in range(0, len(ids), chunk_size):
+            chunk = ids[i : i + chunk_size]
+            ph = ",".join("?" for _ in chunk)
+            rows = self._fetchall(
+                f"""SELECT session_id, user_id, source, created_at
+                    FROM (
+                        SELECT session_id, user_id, source, created_at,
+                               ROW_NUMBER() OVER (
+                                   PARTITION BY session_id
+                                   ORDER BY created_at ASC, request_id ASC
+                               ) AS rn
+                        FROM requests
+                        WHERE session_id IN ({ph})
+                    )
+                    WHERE rn = 1""",  # noqa: S608
+                chunk,
+            )
+            for row in rows:
+                session_id = row["session_id"]
+                out[session_id] = SessionFirstRequest(
+                    session_id=session_id,
+                    user_id=row["user_id"],
+                    source=row["source"] or "",
+                    created_at=_iso_to_epoch(row["created_at"]),
+                )
+        return out
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_first_requests_by_user_session_pairs(
+        self, pairs: list[tuple[str, str]]
+    ) -> dict[tuple[str, str], SessionFirstRequest]:
+        if not pairs:
+            return {}
+        out: dict[tuple[str, str], SessionFirstRequest] = {}
+        pair_list = sorted(set(pairs))
+        chunk_size = 300
+        for i in range(0, len(pair_list), chunk_size):
+            chunk = pair_list[i : i + chunk_size]
+            values = ",".join("(?, ?)" for _ in chunk)
+            params = [value for pair in chunk for value in pair]
+            rows = self._fetchall(
+                f"""SELECT session_id, user_id, source, created_at
+                    FROM (
+                        SELECT session_id, user_id, source, created_at,
+                               ROW_NUMBER() OVER (
+                                   PARTITION BY user_id, session_id
+                                   ORDER BY created_at ASC, request_id ASC
+                               ) AS rn
+                        FROM requests
+                        WHERE (user_id, session_id) IN ({values})
+                    )
+                    WHERE rn = 1""",  # noqa: S608
+                params,
+            )
+            for row in rows:
+                key = (row["user_id"], row["session_id"])
+                out[key] = SessionFirstRequest(
+                    session_id=row["session_id"],
+                    user_id=row["user_id"],
+                    source=row["source"] or "",
+                    created_at=_iso_to_epoch(row["created_at"]),
+                )
+        return out

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

@@ -13,13 +13,6 @@ from reflexio.models.api_schema.eval_overview_schema import (
 
 from ._base import SQLiteStorageBase, _epoch_to_iso
 
-# Maximum epoch seconds that ``datetime.fromtimestamp`` can represent (year
-# 9999-12-31). Callers passing sentinel "open" upper bounds like
-# ``sys.maxsize`` or ``10**12`` would otherwise overflow ``_epoch_to_iso``;
-# clamping to this value yields the same query semantics (≥ everything) with
-# a valid ISO string.
-_MAX_SAFE_EPOCH_TS = 253_402_300_799  # 9999-12-31T23:59:59Z
-
 
 def _parse_dt(value: str) -> datetime:
     """
@@ -164,8 +157,8 @@ class ShadowVerdictsMixin:
             list[ShadowComparisonVerdict]: Verdicts in chronological order
                 (ascending ``created_at``).
         """
-        from_iso = _epoch_to_iso(max(0, min(from_ts, _MAX_SAFE_EPOCH_TS)))
-        to_iso = _epoch_to_iso(max(0, min(to_ts, _MAX_SAFE_EPOCH_TS)))
+        from_iso = _epoch_to_iso(from_ts)
+        to_iso = _epoch_to_iso(to_ts)
         rows = self._fetchall(
             """SELECT * FROM shadow_comparison_verdicts
                WHERE created_at >= ? AND created_at <= ?
@@ -175,6 +168,27 @@ class ShadowVerdictsMixin:
         )
         return [_row_to_verdict(r) for r in rows]
 
+    @SQLiteStorageBase.handle_exceptions
+    def get_recent_shadow_comparison_verdicts(
+        self,
+        from_ts: int,
+        to_ts: int,
+        judge_prompt_version: str,
+        limit: int,
+    ) -> list[ShadowComparisonVerdict]:
+        from_iso = _epoch_to_iso(from_ts)
+        to_iso = _epoch_to_iso(to_ts)
+        safe_limit = max(0, limit)
+        rows = self._fetchall(
+            """SELECT * FROM shadow_comparison_verdicts
+               WHERE created_at >= ? AND created_at <= ?
+                 AND judge_prompt_version = ?
+               ORDER BY created_at DESC
+               LIMIT ?""",
+            (from_iso, to_iso, judge_prompt_version, safe_limit),
+        )
+        return [_row_to_verdict(r) for r in rows]
+
     @SQLiteStorageBase.handle_exceptions
     def delete_shadow_comparison_verdicts_by_session(self, session_id: str) -> int:
         """

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/_stall_state.py

@@ -11,7 +11,7 @@ from __future__ import annotations
 import logging
 import sqlite3
 from dataclasses import dataclass
-from datetime import datetime
+from datetime import UTC, datetime
 from typing import Any
 
 from reflexio.models.api_schema.stall_state_schema import StallReason
@@ -163,10 +163,13 @@ def _parse_ts(raw: str | None) -> datetime | None:
     if raw is None:
         return None
     try:
-        return datetime.fromisoformat(raw)
+        parsed = datetime.fromisoformat(raw)
     except ValueError:
         _LOGGER.warning("Malformed timestamp in stall_state: %r", raw)
         return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=UTC)
+    return parsed
 
 
 class SQLiteStallStateMixin:

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

@@ -23,10 +23,12 @@ from ._agent_run import (
 )
 from ._base import BaseStorageCore, matches_status_filter
 from ._extras import ExtrasMixin
+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
@@ -37,6 +39,8 @@ class BaseStorage(
     ProfileMixin,
     RequestMixin,
     PlaybookMixin,
+    RetrievalLogMixin,
+    LineageEventMixin,
     OperationMixin,
     ExtrasMixin,
     ShareLinkMixin,
@@ -46,6 +50,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 +120,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 +200,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",
@@ -135,6 +245,7 @@ __all__ = [
     "PendingToolCallStatus",
     "PendingToolCallUpsertResult",
     "PlaybookMixin",
+    "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
@@ -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)
     # ==============================