claude-smart 0.2.49 → 0.2.50

package/plugin/vendor/reflexio/reflexio/server/services/storage/retention.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass
 
 DEFAULT_ROW_RETENTION_LIMIT = 250_000
 ROW_RETENTION_DELETE_FRACTION = 0.20
+TOMBSTONE_STATUSES = ("archived", "merged", "superseded", "expired")
 
 
 @dataclass(frozen=True, slots=True)
@@ -18,17 +19,32 @@ class RetentionTarget:
     table_name: str
     order_column: str
     id_columns: tuple[str, ...]
+    priority_statuses: tuple[str, ...] = ()
 
 
 RETENTION_TARGETS: tuple[RetentionTarget, ...] = (
-    RetentionTarget("profiles", "profiles", "created_at", ("profile_id",)),
+    RetentionTarget(
+        "profiles",
+        "profiles",
+        "created_at",
+        ("profile_id",),
+        priority_statuses=TOMBSTONE_STATUSES,
+    ),
     RetentionTarget("interactions", "interactions", "created_at", ("interaction_id",)),
     RetentionTarget("requests", "requests", "created_at", ("request_id",)),
     RetentionTarget(
-        "user_playbooks", "user_playbooks", "created_at", ("user_playbook_id",)
+        "user_playbooks",
+        "user_playbooks",
+        "created_at",
+        ("user_playbook_id",),
+        priority_statuses=TOMBSTONE_STATUSES,
     ),
     RetentionTarget(
-        "agent_playbooks", "agent_playbooks", "created_at", ("agent_playbook_id",)
+        "agent_playbooks",
+        "agent_playbooks",
+        "created_at",
+        ("agent_playbook_id",),
+        priority_statuses=TOMBSTONE_STATUSES,
     ),
     RetentionTarget(
         "agent_success_evaluation_result",
@@ -36,6 +52,25 @@ RETENTION_TARGETS: tuple[RetentionTarget, ...] = (
         "created_at",
         ("result_id",),
     ),
+    # Grouped session target: keyed on (user_id, session_id) — not result_id —
+    # so retention always removes whole session snapshots, never a partial
+    # per-learning subset. Rows within a session share created_at (earliest
+    # request timestamp), so ordering keeps groups adjacent. The session's
+    # retrieved-eval _operation_state row is intentionally left in place: it
+    # is content-free (digest + counters) and self-heals on the next
+    # publish/forced evaluation.
+    RetentionTarget(
+        "retrieved_learning_evaluation",
+        "retrieved_learning_evaluation",
+        "created_at",
+        ("user_id", "session_id"),
+    ),
+    RetentionTarget(
+        "offline_tuner_reward_label",
+        "offline_tuner_reward_label",
+        "label_created_at",
+        ("reward_label_id",),
+    ),
     RetentionTarget("share_links", "share_links", "created_at", ("id",)),
     RetentionTarget(
         "agent_playbook_source_user_playbooks",
@@ -117,6 +152,9 @@ RETENTION_CASCADES: dict[str, tuple[CascadeRef, ...]] = {
     "playbook_retrieval_logs": (
         CascadeRef("playbook_retrieval_log_items", "retrieval_log_id"),
     ),
+    "offline_tuner_reward_label": (
+        CascadeRef("offline_tuner_reward_label_target", "reward_label_id"),
+    ),
 }
 
 

package/plugin/vendor/reflexio/reflexio/server/services/storage/retention_mixin.py

@@ -98,12 +98,40 @@ class RetentionMixin(ABC):
         target = get_retention_target(target_name)
         if not self._retention_table_exists(target.table_name):
             return 0
-        keys = self._retention_select_oldest_keys(target, count)
+        keys = self._retention_select_keys(target, count)
         if not keys:
             return 0
         self._retention_perform_delete(target, keys)
         return len(keys)
 
+    def _retention_select_keys(
+        self, target: RetentionTarget, count: int
+    ) -> list[tuple[Any, ...]]:
+        """Select tombstones first, then oldest rows when a target opts in.
+
+        The tombstone pass can never under-delete: the fallback select returns
+        ``min(count, table_rows)`` keys and ``seen`` only ever holds tombstones
+        already counted, so the union still reaches ``count`` whenever the
+        table holds that many rows.
+        """
+        if not target.priority_statuses:
+            return self._retention_select_oldest_keys(target, count)
+
+        keys = self._retention_select_oldest_keys(
+            target, count, statuses=target.priority_statuses
+        )
+        if len(keys) >= count:
+            return keys
+
+        seen = set(keys)
+        for key in self._retention_select_oldest_keys(target, count):
+            if key not in seen:
+                keys.append(key)
+                seen.add(key)
+            if len(keys) == count:
+                break
+        return keys
+
     def _retention_perform_delete(
         self, target: RetentionTarget, keys: list[tuple[Any, ...]]
     ) -> None:
@@ -130,13 +158,23 @@ class RetentionMixin(ABC):
 
     @abstractmethod
     def _retention_select_oldest_keys(
-        self, target: RetentionTarget, count: int
+        self,
+        target: RetentionTarget,
+        count: int,
+        statuses: tuple[str, ...] | None = None,
     ) -> list[tuple[Any, ...]]:
         """Return up to ``count`` oldest key tuples for ``target``.
 
         Each key tuple contains values aligned with ``target.id_columns``.
         Ordering is by ``target.order_column`` ascending with the id
         columns as a stable tiebreaker.
+
+        Args:
+            target (RetentionTarget): Target whose keys are being selected.
+            count (int): Maximum number of key tuples to return.
+            statuses (tuple[str, ...] | None): When not None, restrict the
+                select to rows whose ``status`` is one of these values. An
+                empty tuple matches nothing (never every row).
         """
         raise NotImplementedError
 

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

@@ -1,4 +1,3 @@
-from ._learning_jobs import SQLiteLearningJobStoreMixin
 from ._base import (
     SQLiteStorageBase,
     _cosine_similarity,
@@ -10,6 +9,7 @@ from ._base import (
 )
 from ._extras import ExtrasMixin
 from ._governance import SQLiteGovernanceMixin
+from ._learning_jobs import SQLiteLearningJobStoreMixin
 from ._lineage import SQLiteLineageMixin
 from ._operations import OperationMixin
 from ._requests import RequestMixin

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

@@ -30,6 +30,7 @@ from reflexio.models.api_schema.service_schemas import (
     ProfileTimeToLive,
     RegularVsShadow,
     Request,
+    RetrievedLearning,
     Status,
     ToolUsed,
     UserActionType,
@@ -456,6 +457,12 @@ def _row_to_interaction(row: sqlite3.Row) -> Interaction:
         if citations_raw and isinstance(citations_raw, list)
         else []
     )
+    retrieved_learnings_raw = _json_loads(d.get("retrieved_learnings"))
+    retrieved_learnings = (
+        [RetrievedLearning(**c) for c in retrieved_learnings_raw if isinstance(c, dict)]
+        if retrieved_learnings_raw and isinstance(retrieved_learnings_raw, list)
+        else []
+    )
     return Interaction(
         interaction_id=d["interaction_id"],
         user_id=d["user_id"],
@@ -471,6 +478,7 @@ def _row_to_interaction(row: sqlite3.Row) -> Interaction:
         expert_content=d.get("expert_content") or "",
         tools_used=tools_used,
         citations=citations,
+        retrieved_learnings=retrieved_learnings,
     )
 
 
@@ -662,6 +670,16 @@ class SQLiteStorageBase(RetentionMixin, BaseStorage):
             api_key_config=self.api_key_config,
         )
         self.embedding_dimensions = EMBEDDING_DIMENSIONS
+        # Text-generation model for storage-time document expansion. The
+        # shared self.llm_client is pinned to the EMBEDDING model, which is
+        # not a chat model — expansion calls must override the model or they
+        # fail (e.g. local/minilm-l6-v2 cannot serve completions).
+        self._expansion_model_name = resolve_model_name(
+            ModelRole.GENERATION,
+            site_var_value=site_var.get("default_generation_model_name"),
+            config_override=llm_config.generation_model_name if llm_config else None,
+            api_key_config=self.api_key_config,
+        )
 
         litellm_config = LiteLLMConfig(
             model=self.embedding_model_name,
@@ -855,6 +873,14 @@ class SQLiteStorageBase(RetentionMixin, BaseStorage):
                 )
                 self.conn.commit()
 
+        if "retrieved_learnings" not in columns:
+            logger.info("Adding retrieved_learnings column to interactions table.")
+            with self._lock:
+                self.conn.execute(
+                    "ALTER TABLE interactions ADD COLUMN retrieved_learnings TEXT"
+                )
+                self.conn.commit()
+
     def _migrate_feedback_schema(self) -> None:
         """Drop old-schema feedback/playbook tables so _DDL can recreate them.
 
@@ -1630,6 +1656,7 @@ class SQLiteStorageBase(RetentionMixin, BaseStorage):
             expander = DocumentExpander(
                 llm_client=self.llm_client,
                 prompt_manager=PromptManager(),
+                model_name=self._expansion_model_name,
             )
             result = expander.expand(content)
             return result.expanded_text or None
@@ -1848,6 +1875,7 @@ CREATE TABLE IF NOT EXISTS interactions (
     expert_content TEXT NOT NULL DEFAULT '',
     tools_used TEXT,
     citations TEXT,
+    retrieved_learnings TEXT,
     embedding TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_interactions_user_id ON interactions(user_id);
@@ -1949,6 +1977,28 @@ CREATE INDEX IF NOT EXISTS idx_eval_agent_version_created_at_desc
 CREATE INDEX IF NOT EXISTS idx_eval_identity_created_at_desc
     ON agent_success_evaluation_result(user_id, session_id, evaluation_name, agent_version, created_at DESC);
 
+CREATE TABLE IF NOT EXISTS retrieved_learning_evaluation (
+    result_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id TEXT NOT NULL,
+    session_id TEXT NOT NULL,
+    agent_version TEXT NOT NULL DEFAULT '',
+    kind TEXT NOT NULL,
+    learning_id TEXT NOT NULL,
+    is_relevant INTEGER,
+    relevance_reason TEXT NOT NULL DEFAULT '',
+    impact TEXT,
+    impact_reason TEXT NOT NULL DEFAULT '',
+    created_at INTEGER NOT NULL,
+    governance_subject_ref TEXT,
+    UNIQUE (user_id, session_id, kind, learning_id)
+);
+CREATE INDEX IF NOT EXISTS idx_rle_created_at_result_id
+    ON retrieved_learning_evaluation(created_at DESC, result_id DESC);
+CREATE INDEX IF NOT EXISTS idx_rle_session_id
+    ON retrieved_learning_evaluation(session_id);
+CREATE INDEX IF NOT EXISTS idx_rle_subject_ref
+    ON retrieved_learning_evaluation(governance_subject_ref);
+
 CREATE TABLE IF NOT EXISTS agent_playbook_source_user_playbooks (
     agent_playbook_id INTEGER NOT NULL,
     user_playbook_id INTEGER NOT NULL,

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

@@ -25,7 +25,14 @@ from ._base import (
     _row_to_interaction,
 )
 
-type _CitationKind = Literal["playbook", "profile"]
+type _CitationKind = Literal["playbook", "profile", "user_playbook", "agent_playbook"]
+
+_SUPPORTED_CITATION_KINDS: tuple[_CitationKind, ...] = (
+    "playbook",
+    "profile",
+    "user_playbook",
+    "agent_playbook",
+)
 
 
 class ExtrasMixin:
@@ -291,7 +298,7 @@ class ExtrasMixin:
                     continue
                 kind = c.get("kind")
                 real_id = c.get("real_id")
-                if kind not in ("playbook", "profile") or not real_id:
+                if kind not in _SUPPORTED_CITATION_KINDS or not real_id:
                     continue
                 key: tuple[_CitationKind, str] = (
                     cast(_CitationKind, kind),
@@ -453,12 +460,12 @@ class ExtrasMixin:
                         continue
                     kind = citation.get("kind")
                     real_id = citation.get("real_id")
-                    if kind and real_id:
+                    if kind in _SUPPORTED_CITATION_KINDS and real_id:
                         out.append(
                             SessionCitation(
                                 user_id=row["user_id"],
                                 session_id=row["session_id"],
-                                kind=str(kind),
+                                kind=cast(_CitationKind, kind),
                                 real_id=str(real_id),
                                 title=str(citation.get("title") or ""),
                             )

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

@@ -392,11 +392,27 @@ class SQLiteGovernanceMixin:
                WHERE user_id = ?""",
             (user_id,),
         ).fetchone()
+        rle_result_row = self.conn.execute(
+            """SELECT COUNT(*) AS cnt
+               FROM retrieved_learning_evaluation
+               WHERE user_id = ?""",
+            (user_id,),
+        ).fetchone()
+        session_count_row = self.conn.execute(
+            "SELECT COUNT(DISTINCT session_id) AS cnt FROM requests WHERE user_id = ?",
+            (user_id,),
+        ).fetchone()
         profile_rows = self.conn.execute(
             "SELECT profile_id FROM profiles WHERE user_id = ?",
             (user_id,),
         ).fetchall()
-        if request_row is None or interaction_row is None or eval_result_row is None:
+        if (
+            request_row is None
+            or interaction_row is None
+            or eval_result_row is None
+            or rle_result_row is None
+            or session_count_row is None
+        ):
             raise ValueError("Missing governance count rows")
         profile_ids = [str(row["profile_id"]) for row in profile_rows]
         purge_profile_ids, delete_profile_ids = self._deps()._partition_purge_vs_delete(
@@ -420,6 +436,17 @@ class SQLiteGovernanceMixin:
             "profile_purge": len(purge_profile_ids),
             "user_playbook": len(delete_playbook_ids),
             "agent_success_evaluation_result": int(eval_result_row["cnt"]),
+            # Offline tuner tables are enterprise-only (tenant stream); the
+            # OSS SQLite backend has no such tables, so the planned and
+            # deleted counts are structurally zero. The delete-target matrix
+            # validator still requires the target rows to exist.
+            "offline_tuner_reward_label": 0,
+            "offline_tuner_reward_label_target_by_target_owner": 0,
+            "retrieved_learning_evaluation_result": int(rle_result_row["cnt"]),
+            # Planned as an upper bound: up to 3 evaluation state namespaces
+            # per session (retrieved-eval state, agent-success marker,
+            # grade-cache rows). The delete phase reports the exact count.
+            "evaluation_operation_state": 3 * int(session_count_row["cnt"]),
             "user_playbook_purge": len(purge_playbook_ids),
         }
 

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

@@ -262,11 +262,18 @@ class SQLiteLearningJobStoreMixin(LearningJobStoreABC):
         job_id: str,
         claim_token: str,
         dead: bool,
+        refund_attempt: bool = False,
     ) -> None:
         """Fenced fail/dead transition — sets status, clears token for retry.
 
         Does NOT increment attempts: claim_learning_jobs already incremented on
         delivery.  attempts tracks delivery count; fail only transitions status.
+
+        ``refund_attempt=True`` (the same-user-contention requeue, F4) decrements
+        ``attempts`` by one (``MAX(attempts - 1, 0)``) so a contention cycle
+        (claim +1, contention-release -1) nets to zero and ``attempts`` stays
+        bounded regardless of how many times the job loses the per-user race.
+        Defaults to ``False`` (the ``dead`` retry path is unchanged).
         """
         new_status = "dead" if dead else "failed"
         # Clear claim_token and claim_expires_at only for 'failed' so it's reclaimable.
@@ -282,10 +289,11 @@ class SQLiteLearningJobStoreMixin(LearningJobStoreABC):
                         status = ?,
                         claim_token = CASE WHEN ? THEN claim_token ELSE NULL END,
                         claim_expires_at = CASE WHEN ? THEN claim_expires_at ELSE NULL END,
+                        attempts = CASE WHEN ? THEN MAX(attempts - 1, 0) ELSE attempts END,
                         updated_at = strftime('%Y-%m-%dT%H:%M:%fZ','now')
                     WHERE job_id = ? AND claim_token = ? AND status = 'claimed'
                     """,
-                    (new_status, dead, dead, job_id, claim_token),
+                    (new_status, dead, dead, refund_attempt, job_id, claim_token),
                 )
                 if own_txn:
                     self.conn.commit()
@@ -316,6 +324,33 @@ class SQLiteLearningJobStoreMixin(LearningJobStoreABC):
         )
         return [str(row["org_id"]) for row in rows]
 
+    @SQLiteStorageBase.handle_exceptions
+    def get_oldest_pending_learning_job_age_seconds(self) -> float | None:
+        """Age in seconds of the oldest pending job, or None if none pending.
+
+        Computes the age entirely in SQLite using ``strftime('%s','now')`` to
+        avoid app/DB clock skew.  The table is accessed without a schema prefix
+        (SQLite has no schema routing — the local DB file is the ref).
+        """
+        row = self._fetchall(
+            """
+            SELECT (strftime('%s', 'now') - strftime('%s', MIN(created_at))) AS age_seconds
+            FROM learning_jobs
+            WHERE status = 'pending'
+            """,
+            (),
+        )
+        return None if row[0]["age_seconds"] is None else float(row[0]["age_seconds"])
+
+    @SQLiteStorageBase.handle_exceptions
+    def count_learning_jobs_by_status(self, status: str) -> int:
+        """Count of learning jobs with the given status on this storage ref."""
+        row = self._fetchall(
+            "SELECT COUNT(*) AS cnt FROM learning_jobs WHERE status = ?",
+            (status,),
+        )
+        return int(row[0]["cnt"])
+
     @SQLiteStorageBase.handle_exceptions
     def get_learning_status_for_request(
         self,

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

@@ -74,6 +74,10 @@ class ShadowVerdictsMixin:
     _fetchone: Any
     _fetchall: Any
 
+    def supports_shadow_comparison_verdicts(self) -> bool:
+        """Return whether this backend can persist shadow comparison verdicts."""
+        return True
+
     @SQLiteStorageBase.handle_exceptions
     def save_shadow_comparison_verdict(
         self, verdict: ShadowComparisonVerdict

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/base/_deletion.py

@@ -46,14 +46,25 @@ class SQLiteDeletionMixin:
 
     @SQLiteStorageBase.handle_exceptions
     def _retention_select_oldest_keys(
-        self, target: RetentionTarget, count: int
+        self,
+        target: RetentionTarget,
+        count: int,
+        statuses: tuple[str, ...] | None = None,
     ) -> list[tuple[Any, ...]]:
+        if statuses is not None and not statuses:
+            return []
         id_sql = ", ".join(target.id_columns)
-        tiebreak_sql = id_sql
+        where_sql = ""
+        params: list[Any] = []
+        if statuses:
+            placeholders = ", ".join("?" for _ in statuses)
+            where_sql = f"WHERE status IN ({placeholders}) "
+            params.extend(statuses)
+        params.append(count)
         rows = self._fetchall(
-            f"SELECT {id_sql} FROM {target.table_name} "  # noqa: S608
-            f"ORDER BY {target.order_column} ASC, {tiebreak_sql} ASC LIMIT ?",
-            (count,),
+            f"SELECT {id_sql} FROM {target.table_name} {where_sql}"  # noqa: S608
+            f"ORDER BY {target.order_column} ASC, {id_sql} ASC LIMIT ?",
+            tuple(params),
         )
         return [tuple(row[col] for col in target.id_columns) for row in rows]
 

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",
         }