claude-smart 0.2.48 → 0.2.50

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/governance/_erase_execution.py

@@ -30,7 +30,6 @@ resolve through the composed MRO.
 
 from __future__ import annotations
 
-import json
 import sqlite3
 import threading
 from collections.abc import Callable
@@ -50,6 +49,14 @@ from reflexio.server.services.storage.governance_validation import (
     _successful_erase_identity,
     _validate_governance_purge_id,
 )
+from reflexio.server.services.storage.storage_base.evaluation_state_keys import (
+    GRADE_ON_DEMAND_CACHE_PREFIX,
+    build_agent_success_marker_key,
+    build_grade_on_demand_session_prefix,
+)
+from reflexio.server.services.storage.storage_base.retrieved_learning_state import (
+    build_retrieved_learning_state_key,
+)
 
 from .._governance import _row_to_audit_event, _row_to_purge_operation
 
@@ -157,13 +164,6 @@ class GovernanceEraseExecutionMixin:
             raise ValueError(
                 "Current user playbooks no longer match prepared purge snapshot"
             )
-        request_ids = [
-            str(row["request_id"])
-            for row in self.conn.execute(
-                "SELECT request_id FROM requests WHERE user_id = ?",
-                (user_id,),
-            ).fetchall()
-        ]
         profile_rows = self.conn.execute(
             "SELECT rowid, profile_id FROM profiles WHERE user_id = ?",
             (user_id,),
@@ -183,40 +183,12 @@ class GovernanceEraseExecutionMixin:
         )
         purge_upb_ids = [int(entity_id) for entity_id in purge_upb_str_ids]
         delete_upb_ids = [int(entity_id) for entity_id in delete_upb_str_ids]
-        erased_entity_ids = [
-            *request_ids,
-            *[str(interaction_id) for interaction_id in interaction_ids],
-            *all_profile_ids,
-            *[str(user_playbook_id) for user_playbook_id in raw_upb_ids],
-        ]
-        if erased_entity_ids:
-            erased_entity_id_set = set(erased_entity_ids)
-            lineage_source_event_ids: list[int] = []
-            for row in self.conn.execute(
-                "SELECT event_id, source_ids FROM lineage_event WHERE org_id = ?",
-                (self.org_id,),
-            ).fetchall():
-                try:
-                    source_ids = json.loads(str(row["source_ids"] or "[]"))
-                except json.JSONDecodeError:
-                    source_ids = []
-                if any(
-                    str(source_id) in erased_entity_id_set for source_id in source_ids
-                ):
-                    lineage_source_event_ids.append(int(row["event_id"]))
-            deps._delete_in_chunks(
-                "lineage_event", "event_id", lineage_source_event_ids
-            )
-            placeholders = ",".join("?" for _ in erased_entity_ids)
-            self.conn.execute(
-                f"""DELETE FROM lineage_event
-                    WHERE org_id = ?
-                      AND (
-                        request_id IN ({placeholders})
-                        OR entity_id IN ({placeholders})
-                      )""",  # noqa: S608
-                [self.org_id, *erased_entity_ids, *erased_entity_ids],
-            )
+        # SEC-016: retain the content-free lineage_event skeleton on erase to
+        # match Supabase (which never enumerates lineage_event for erasure).
+        # lineage_event has no PII/content column, no foreign keys, and no
+        # FTS/vec shadow tables, so leaving these rows in place is safe and
+        # preserves the audit/lineage skeleton. Content-bearing entities are
+        # still deleted/purged below.
         delete_profile_rowids = [
             profile_rowid_by_id[profile_id]
             for profile_id in delete_profile_ids
@@ -240,6 +212,23 @@ class GovernanceEraseExecutionMixin:
                WHERE user_id = ?""",
             (user_id,),
         )
+        rle_results_cur = self.conn.execute(
+            """DELETE FROM retrieved_learning_evaluation
+               WHERE user_id = ?""",
+            (user_id,),
+        )
+        # Snapshot the user's session ids BEFORE requests are deleted — the
+        # evaluation _operation_state namespaces are keyed by session.
+        session_ids = [
+            str(row["session_id"])
+            for row in self.conn.execute(
+                "SELECT DISTINCT session_id FROM requests WHERE user_id = ?",
+                (user_id,),
+            ).fetchall()
+        ]
+        eval_operation_states = self._delete_evaluation_operation_states_locked(
+            user_id, session_ids
+        )
         requests_cur = self.conn.execute(
             "DELETE FROM requests WHERE user_id = ?",
             (user_id,),
@@ -280,10 +269,75 @@ class GovernanceEraseExecutionMixin:
             "profiles": len(delete_profile_ids),
             "requests": requests_cur.rowcount,
             "agent_success_evaluation_results": eval_results_cur.rowcount,
+            # Enterprise-only tables absent from the OSS SQLite backend;
+            # reported as zero so the delete target matrix stays complete.
+            "offline_tuner_reward_labels": 0,
+            "offline_tuner_reward_label_targets_by_target_owner": 0,
+            "retrieved_learning_evaluation_results": rle_results_cur.rowcount,
+            "evaluation_operation_states": eval_operation_states,
             "purged_profiles": purged_profiles,
             "purged_user_playbooks": purged_user_playbooks,
         }
 
+    def _delete_evaluation_operation_states_locked(
+        self, user_id: str, session_ids: list[str]
+    ) -> int:
+        """Scrub the three evaluation ``_operation_state`` namespaces.
+
+        Deletes, for every session the user owns: the retrieved-learning
+        generation/completion state, the ``agent_success_group_eval`` marker
+        (pre-existing RTBF gap), and the ``grade_on_demand`` cache rows
+        (pre-existing RTBF gap). Exact keys are used for the first two; the
+        grade cache is matched by the injective per-session key prefix so any
+        agent_version / evaluation_name variant is covered.
+
+        Returns:
+            int: Number of state rows deleted.
+        """
+        if not session_ids:
+            return 0
+        deleted = 0
+        exact_keys = [
+            build_retrieved_learning_state_key(user_id, session_id)
+            for session_id in session_ids
+        ] + [
+            build_agent_success_marker_key(self.org_id, user_id, session_id)
+            for session_id in session_ids
+        ]
+        chunk_size = 500
+        for start in range(0, len(exact_keys), chunk_size):
+            chunk = exact_keys[start : start + chunk_size]
+            placeholders = ",".join("?" for _ in chunk)
+            cur = self.conn.execute(
+                f"DELETE FROM _operation_state WHERE service_name IN ({placeholders})",  # noqa: S608
+                chunk,
+            )
+            deleted += cur.rowcount
+        # Grade-cache keys embed agent_version/evaluation_name, so enumerate
+        # the namespace and match each session's injective prefix in Python
+        # (LIKE-escaping free-form session ids is not safe).
+        prefixes = tuple(
+            build_grade_on_demand_session_prefix(self.org_id, session_id)
+            for session_id in session_ids
+        )
+        grade_keys = [
+            str(row["service_name"])
+            for row in self.conn.execute(
+                "SELECT service_name FROM _operation_state WHERE service_name LIKE ?",
+                (f"{GRADE_ON_DEMAND_CACHE_PREFIX}::%",),
+            ).fetchall()
+            if str(row["service_name"]).startswith(prefixes)
+        ]
+        for start in range(0, len(grade_keys), chunk_size):
+            chunk = grade_keys[start : start + chunk_size]
+            placeholders = ",".join("?" for _ in chunk)
+            cur = self.conn.execute(
+                f"DELETE FROM _operation_state WHERE service_name IN ({placeholders})",  # noqa: S608
+                chunk,
+            )
+            deleted += cur.rowcount
+        return deleted
+
     def apply_governance_user_data_delete(
         self, purge_id: str, user_id: str
     ) -> dict[str, int]:
@@ -294,6 +348,14 @@ class GovernanceEraseExecutionMixin:
             "profiles": "profile",
             "requests": "request",
             "agent_success_evaluation_results": "agent_success_evaluation_result",
+            "offline_tuner_reward_labels": "offline_tuner_reward_label",
+            "offline_tuner_reward_label_targets_by_target_owner": (
+                "offline_tuner_reward_label_target_by_target_owner"
+            ),
+            "retrieved_learning_evaluation_results": (
+                "retrieved_learning_evaluation_result"
+            ),
+            "evaluation_operation_states": "evaluation_operation_state",
             "purged_profiles": "profile_purge",
             "purged_user_playbooks": "user_playbook_purge",
         }

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/governance/_subject_barrier.py

@@ -166,6 +166,7 @@ class SubjectBarrierMixin:
             "profiles",
             "user_playbooks",
             "agent_success_evaluation_result",
+            "retrieved_learning_evaluation",
         ):
             row = self.conn.execute(
                 f"""SELECT 1 FROM {table}
@@ -198,9 +199,14 @@ class SubjectBarrierMixin:
             request_id_column="request_id",
         ):
             return True
-        return self._legacy_user_id_rows_remain_locked(
+        if self._legacy_user_id_rows_remain_locked(
             table="agent_success_evaluation_result",
             subject_ref=subject_ref,
+        ):
+            return True
+        return self._legacy_user_id_rows_remain_locked(
+            table="retrieved_learning_evaluation",
+            subject_ref=subject_ref,
         )
 
     def begin_subject_erasure_barrier(

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/playbook/_agent.py

@@ -19,6 +19,9 @@ from reflexio.models.api_schema.service_schemas import (
     Status,
 )
 from reflexio.models.config_schema import SearchMode, SearchOptions
+from reflexio.server.services.storage.lifecycle_filters import (
+    validate_include_inactive,
+)
 from reflexio.server.services.storage.storage_base._playbook import (
     AGGREGATE_REASON_PREFIX,
 )
@@ -87,6 +90,7 @@ class AgentPlaybookStoreMixin:
     _fts_upsert: Any
     _vec_upsert: Any
     _delete_playbook_search_rows: Any
+    _own_transaction: Any
 
     def _index_agent_playbook_fts_vec(self, ap: AgentPlaybook) -> None:
         """Update the FTS and vector indexes for a single agent playbook row.
@@ -178,7 +182,8 @@ class AgentPlaybookStoreMixin:
             created_at_iso = _epoch_to_iso(ap.created_at)
             with self._lock:
                 self._insert_agent_playbook_row(self.conn, ap, created_at_iso)
-                self.conn.commit()
+                if self._own_transaction():
+                    self.conn.commit()
 
             self._index_agent_playbook_fts_vec(ap)
             saved.append(ap)
@@ -228,6 +233,7 @@ class AgentPlaybookStoreMixin:
 
         created_at_iso = _epoch_to_iso(ap.created_at)
         with self._lock:
+            own_txn = self._own_transaction()
             try:
                 self._insert_agent_playbook_row(self.conn, ap, created_at_iso)
                 _append_event_stmt(
@@ -242,9 +248,11 @@ class AgentPlaybookStoreMixin:
                     request_id=request_id,
                     reason=f"{AGGREGATE_REASON_PREFIX}{run_mode}",
                 )
-                self.conn.commit()
+                if own_txn:
+                    self.conn.commit()
             except Exception:
-                self.conn.rollback()
+                if own_txn:
+                    self.conn.rollback()
                 raise
 
         # FTS/vec indexing AFTER commit — these helpers self-commit and must
@@ -339,6 +347,46 @@ class AgentPlaybookStoreMixin:
             row = self._fetchone(sql, (agent_playbook_id,))
         return _row_to_agent_playbook(row) if row else None
 
+    @SQLiteStorageBase.handle_exceptions
+    def get_agent_playbooks_by_ids(
+        self,
+        agent_playbook_ids: list[int],
+        *,
+        status_filter: list[Status | None] | None = None,
+        playbook_status_filter: list[PlaybookStatus] | None = None,
+        include_inactive: bool = False,
+    ) -> list[AgentPlaybook]:
+        validate_include_inactive(
+            include_inactive=include_inactive,
+            status_filter=status_filter,
+            playbook_status_filter=playbook_status_filter,
+        )
+        if not agent_playbook_ids:
+            return []
+        unique_ids = list(dict.fromkeys(agent_playbook_ids))
+        rows: list[sqlite3.Row] = []
+        for start in range(0, len(unique_ids), 900):
+            chunk = unique_ids[start : start + 900]
+            placeholders = ",".join("?" for _ in chunk)
+            query = (
+                "SELECT * FROM agent_playbooks "
+                f"WHERE agent_playbook_id IN ({placeholders})"
+            )
+            params: list[Any] = list(chunk)
+            if not include_inactive:
+                if status_filter is not None:
+                    fragment, status_params = _build_status_sql(status_filter)
+                    query += f" AND {fragment}"
+                    params.extend(status_params)
+                else:
+                    query += " AND status IS NULL"
+                if playbook_status_filter:
+                    status_placeholders = ",".join("?" for _ in playbook_status_filter)
+                    query += f" AND playbook_status IN ({status_placeholders})"
+                    params.extend(status.value for status in playbook_status_filter)
+            rows.extend(self._fetchall(query, params))
+        return [_row_to_agent_playbook(row) for row in rows]
+
     @SQLiteStorageBase.handle_exceptions
     def delete_all_agent_playbooks(self) -> None:
         batch_request_id = uuid.uuid4().hex
@@ -609,7 +657,8 @@ class AgentPlaybookStoreMixin:
                     to_status="archived",
                     status_namespace="lifecycle_status",
                 )
-            self.conn.commit()
+            if self._own_transaction():
+                self.conn.commit()
 
     @SQLiteStorageBase.handle_exceptions
     def archive_agent_playbooks_by_ids(self, agent_playbook_ids: list[int]) -> None:
@@ -648,7 +697,8 @@ class AgentPlaybookStoreMixin:
                     to_status="archived",
                     status_namespace="lifecycle_status",
                 )
-            self.conn.commit()
+            if self._own_transaction():
+                self.conn.commit()
 
     @SQLiteStorageBase.handle_exceptions
     def supersede_agent_playbooks_by_ids(
@@ -712,7 +762,8 @@ class AgentPlaybookStoreMixin:
                         request_id=request_id,
                     )
                     updated += 1
-            self.conn.commit()
+            if self._own_transaction():
+                self.conn.commit()
         return updated
 
     @SQLiteStorageBase.handle_exceptions
@@ -773,7 +824,8 @@ class AgentPlaybookStoreMixin:
                         request_id=request_id,
                     )
                     updated += 1
-            self.conn.commit()
+            if self._own_transaction():
+                self.conn.commit()
         return updated
 
     @SQLiteStorageBase.handle_exceptions