claude-smart 0.2.46 → 0.2.47

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

@@ -75,6 +75,10 @@ def _build_tags_sql(alias: str, tags: list[str] | None) -> tuple[str, list[Any]]
     )
 
 
+def _escape_like_pattern(value: str) -> str:
+    return value.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+
+
 class ProfileMixin:
     """Mixin providing profile and interaction CRUD + search."""
 
@@ -100,21 +104,87 @@ class ProfileMixin:
     llm_client: Any
     embedding_model_name: str
     embedding_dimensions: int
+    _subject_ref_for_user_id: Any
+    _assert_subject_writable_locked: Any
 
     # ------------------------------------------------------------------
     # CRUD — Profiles
     # ------------------------------------------------------------------
 
+    def _subject_ref_from_profile_row(self, row: sqlite3.Row) -> str:
+        subject_ref = row["governance_subject_ref"]
+        return (
+            str(subject_ref)
+            if subject_ref
+            else self._subject_ref_for_user_id(row["user_id"])
+        )
+
+    def _assert_profile_writable_locked(
+        self,
+        profile_id: str,
+        *,
+        user_id: str | None = None,
+    ) -> sqlite3.Row | None:
+        if user_id is None:
+            row = self.conn.execute(
+                "SELECT user_id, governance_subject_ref FROM profiles WHERE profile_id = ?",
+                (profile_id,),
+            ).fetchone()
+        else:
+            row = self.conn.execute(
+                "SELECT user_id, governance_subject_ref FROM profiles WHERE profile_id = ? AND user_id = ?",
+                (profile_id, user_id),
+            ).fetchone()
+        if row is None:
+            return None
+        self._assert_subject_writable_locked(self._subject_ref_from_profile_row(row))
+        return row
+
     @SQLiteStorageBase.handle_exceptions
     def get_all_profiles(
         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]:
         if status_filter is None:
             status_filter = [None]
         frag, params = _build_status_sql(status_filter)
-        sql = f"SELECT * FROM profiles WHERE {frag} ORDER BY last_modified_timestamp DESC LIMIT ?"
+        conditions = [frag]
+        if user_id:
+            conditions.append("user_id = ?")
+            params.append(user_id)
+        if profile_id:
+            conditions.append("LOWER(profile_id) = LOWER(?)")
+            params.append(profile_id)
+        if query:
+            like = f"%{_escape_like_pattern(query.lower())}%"
+            conditions.append(
+                "(LOWER(content) LIKE ? ESCAPE '\\' OR LOWER(profile_id) LIKE ? ESCAPE '\\' OR LOWER(user_id) LIKE ? ESCAPE '\\')"
+            )
+            params.extend([like, like, like])
+        if source is not None:
+            conditions.append("source = ?")
+            params.append(source)
+        if profile_time_to_live:
+            conditions.append("profile_time_to_live = ?")
+            params.append(profile_time_to_live)
+        if start_time is not None:
+            conditions.append("last_modified_timestamp >= ?")
+            params.append(start_time)
+        if end_time is not None:
+            conditions.append("last_modified_timestamp <= ?")
+            params.append(end_time)
+        sql = (
+            f"SELECT * FROM profiles WHERE {' AND '.join(conditions)} "
+            "ORDER BY last_modified_timestamp DESC LIMIT ?"
+        )
         params.append(limit)
         return [_row_to_profile(r) for r in self._fetchall(sql, params)]
 
@@ -124,6 +194,12 @@ class ProfileMixin:
         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]:
         if status_filter is None:
             status_filter = [None]
@@ -131,6 +207,27 @@ class ProfileMixin:
         frag, params = _build_status_sql(status_filter)
         conditions = ["user_id = ?", "expiration_timestamp >= ?", frag]
         all_params: list[Any] = [user_id, current_ts, *params]
+        if profile_id:
+            conditions.append("LOWER(profile_id) = LOWER(?)")
+            all_params.append(profile_id)
+        if query:
+            like = f"%{_escape_like_pattern(query.lower())}%"
+            conditions.append(
+                "(LOWER(content) LIKE ? ESCAPE '\\' OR LOWER(profile_id) LIKE ? ESCAPE '\\' OR LOWER(user_id) LIKE ? ESCAPE '\\')"
+            )
+            all_params.extend([like, like, like])
+        if source is not None:
+            conditions.append("source = ?")
+            all_params.append(source)
+        if profile_time_to_live:
+            conditions.append("profile_time_to_live = ?")
+            all_params.append(profile_time_to_live)
+        if start_time is not None:
+            conditions.append("last_modified_timestamp >= ?")
+            all_params.append(start_time)
+        if end_time is not None:
+            conditions.append("last_modified_timestamp <= ?")
+            all_params.append(end_time)
         tag_frag, tag_params = _build_tags_sql("profiles", tags)
         if tag_frag:
             conditions.append(tag_frag)
@@ -141,6 +238,9 @@ class ProfileMixin:
     @SQLiteStorageBase.handle_exceptions
     def add_user_profile(self, user_id: str, user_profiles: list[UserProfile]) -> None:  # noqa: ARG002
         for profile in user_profiles:
+            subject_ref = self._subject_ref_for_user_id(profile.user_id)
+            with self._lock:
+                self._assert_subject_writable_locked(subject_ref)
             embedding_text = "\n".join([profile.content, str(profile.custom_features)])
             if self._should_expand_documents():
                 with ThreadPoolExecutor(max_workers=2) as executor:
@@ -151,39 +251,48 @@ class ProfileMixin:
             else:
                 profile.embedding = self._get_embedding(embedding_text)
             embedding = profile.embedding
-            self._execute(
-                """INSERT OR REPLACE INTO profiles
-                   (profile_id, user_id, content, last_modified_timestamp,
-                    generated_from_request_id, profile_time_to_live,
-                    expiration_timestamp, custom_features, embedding, source,
-                   status, extractor_names, expanded_terms,
-                    source_span, notes, reader_angle, tags, source_interaction_ids, created_at,
-                    merged_into, superseded_by)
-                   VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
-                (
-                    profile.profile_id,
-                    profile.user_id,
-                    profile.content,
-                    profile.last_modified_timestamp,
-                    profile.generated_from_request_id,
-                    profile.profile_time_to_live.value,
-                    profile.expiration_timestamp,
-                    _json_dumps(profile.custom_features),
-                    _json_dumps(profile.embedding),
-                    profile.source,
-                    profile.status.value if profile.status else None,
-                    _json_dumps(profile.extractor_names),
-                    profile.expanded_terms,
-                    profile.source_span,
-                    profile.notes,
-                    profile.reader_angle,
-                    _json_dumps(profile.tags),
-                    _json_dumps(profile.source_interaction_ids),
-                    _iso_now(),
-                    profile.merged_into,
-                    profile.superseded_by,
-                ),
-            )
+            with self._lock:
+                try:
+                    self.conn.execute("BEGIN IMMEDIATE")
+                    self._assert_subject_writable_locked(subject_ref)
+                    self.conn.execute(
+                        """INSERT OR REPLACE INTO profiles
+                           (profile_id, user_id, content, last_modified_timestamp,
+                            generated_from_request_id, profile_time_to_live,
+                            expiration_timestamp, custom_features, embedding, source,
+                            status, extractor_names, expanded_terms,
+                            source_span, notes, reader_angle, tags, source_interaction_ids, created_at,
+                            merged_into, superseded_by, governance_subject_ref)
+                           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                        (
+                            profile.profile_id,
+                            profile.user_id,
+                            profile.content,
+                            profile.last_modified_timestamp,
+                            profile.generated_from_request_id,
+                            profile.profile_time_to_live.value,
+                            profile.expiration_timestamp,
+                            _json_dumps(profile.custom_features),
+                            _json_dumps(profile.embedding),
+                            profile.source,
+                            profile.status.value if profile.status else None,
+                            _json_dumps(profile.extractor_names),
+                            profile.expanded_terms,
+                            profile.source_span,
+                            profile.notes,
+                            profile.reader_angle,
+                            _json_dumps(profile.tags),
+                            _json_dumps(profile.source_interaction_ids),
+                            _iso_now(),
+                            profile.merged_into,
+                            profile.superseded_by,
+                            subject_ref,
+                        ),
+                    )
+                    self.conn.commit()
+                except Exception:
+                    self.conn.rollback()
+                    raise
             fts_parts = [profile.content or ""]
             if profile.custom_features:
                 fts_parts.extend(str(v) for v in profile.custom_features.values() if v)
@@ -211,18 +320,28 @@ class ProfileMixin:
         that re-acquire it are safe.
         """
         current_ts = _epoch_now()
-        row = self._fetchone(
-            "SELECT profile_id FROM profiles WHERE user_id = ? AND profile_id = ? AND expiration_timestamp >= ?",
-            (user_id, profile_id, current_ts),
-        )
-        if not row:
-            logger.warning("User profile not found for user id: %s", user_id)
-            return
+        with self._lock:
+            row = self.conn.execute(
+                "SELECT user_id, governance_subject_ref FROM profiles WHERE user_id = ? AND profile_id = ? AND expiration_timestamp >= ?",
+                (user_id, profile_id, current_ts),
+            ).fetchone()
+            if not row:
+                logger.warning("User profile not found for user id: %s", user_id)
+                return
+            self._assert_subject_writable_locked(
+                self._subject_ref_from_profile_row(row)
+            )
         embedding = self._get_embedding(
             "\n".join([new_profile.content, str(new_profile.custom_features)])
         )
         new_profile.embedding = embedding
         with self._lock:
+            if (
+                self._assert_profile_writable_locked(profile_id, user_id=user_id)
+                is None
+            ):
+                logger.warning("User profile not found for user id: %s", user_id)
+                return
             cur = self.conn.execute(
                 """UPDATE profiles SET content=?, last_modified_timestamp=?,
                    generated_from_request_id=?, profile_time_to_live=?,
@@ -282,10 +401,17 @@ class ProfileMixin:
     def update_user_profile_tags(
         self, user_id: str, profile_id: str, tags: list[str]
     ) -> None:
-        self._execute(
-            "UPDATE profiles SET tags=? WHERE user_id=? AND profile_id=?",
-            (_json_dumps(tags), user_id, profile_id),
-        )
+        with self._lock:
+            if (
+                self._assert_profile_writable_locked(profile_id, user_id=user_id)
+                is None
+            ):
+                return
+            self.conn.execute(
+                "UPDATE profiles SET tags=? WHERE user_id=? AND profile_id=?",
+                (_json_dumps(tags), user_id, profile_id),
+            )
+            self.conn.commit()
 
     @SQLiteStorageBase.handle_exceptions
     def delete_user_profile(self, request: DeleteUserProfileRequest) -> None:
@@ -408,20 +534,24 @@ class ProfileMixin:
 
         batch_request_id = uuid.uuid4().hex
         with self._lock:
-            affected = [
-                r["profile_id"]
-                for r in self.conn.execute(
-                    f"SELECT profile_id FROM profiles WHERE {where}",
+            affected = list(
+                self.conn.execute(
+                    f"SELECT profile_id, user_id, governance_subject_ref FROM profiles WHERE {where}",
                     select_params + extra_params,
                 ).fetchall()
-            ]
+            )
+            for row in affected:
+                self._assert_subject_writable_locked(
+                    self._subject_ref_from_profile_row(row)
+                )
             cur = self.conn.execute(
                 f"UPDATE profiles SET status = ?, last_modified_timestamp = ?, retired_at = ? WHERE {where}",
                 [new_val, now_ts, retired_at_val] + select_params + extra_params,
             )
             from_val = old_status.value if old_status else None
             to_val = new_status.value if new_status else None
-            for pid in affected:
+            for row in affected:
+                pid = row["profile_id"]
                 _append_event_stmt(
                     self.conn,
                     org_id=self.org_id,
@@ -530,6 +660,11 @@ class ProfileMixin:
     @SQLiteStorageBase.handle_exceptions
     def archive_profile_by_id(self, user_id: str, profile_id: str) -> bool:
         with self._lock:
+            if (
+                self._assert_profile_writable_locked(profile_id, user_id=user_id)
+                is None
+            ):
+                return False
             now_ts = _epoch_now()
             cur = self.conn.execute(
                 "UPDATE profiles SET status = ?, last_modified_timestamp = ?, retired_at = ? "
@@ -590,11 +725,14 @@ class ProfileMixin:
             for pid in profile_ids:
                 # Read current status for from_status derivation (user_id scoped)
                 row = self.conn.execute(
-                    "SELECT status FROM profiles WHERE profile_id = ? AND user_id = ?",
+                    "SELECT status, user_id, governance_subject_ref FROM profiles WHERE profile_id = ? AND user_id = ?",
                     (pid, user_id),
                 ).fetchone()
                 if row is None:
                     continue
+                self._assert_subject_writable_locked(
+                    self._subject_ref_from_profile_row(row)
+                )
                 old_status_val = (
                     row[0] if isinstance(row, (tuple, list)) else row["status"]
                 )
@@ -744,62 +882,79 @@ class ProfileMixin:
 
     def _insert_interaction(self, interaction: Interaction) -> int:
         created_at_iso = _epoch_to_iso(interaction.created_at)
+        subject_ref = self._subject_ref_for_user_id(interaction.user_id)
         with self._lock:
-            if interaction.interaction_id:
-                self.conn.execute(
-                    """INSERT OR REPLACE INTO interactions
-                       (interaction_id, user_id, content, request_id, created_at,
-                        role, user_action, user_action_description,
-                        interacted_image_url, image_encoding, shadow_content,
-                        expert_content, tools_used, citations, embedding)
-                       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
-                    (
-                        interaction.interaction_id,
-                        interaction.user_id,
-                        interaction.content,
-                        interaction.request_id,
-                        created_at_iso,
-                        interaction.role,
-                        interaction.user_action.value,
-                        interaction.user_action_description,
-                        interaction.interacted_image_url,
-                        interaction.image_encoding,
-                        interaction.shadow_content,
-                        interaction.expert_content,
-                        _json_dumps([t.model_dump() for t in interaction.tools_used]),
-                        _json_dumps([c.model_dump() for c in interaction.citations]),
-                        _json_dumps(interaction.embedding),
-                    ),
-                )
-                iid = interaction.interaction_id
-            else:
-                cur = self.conn.execute(
-                    """INSERT INTO interactions
-                       (user_id, content, request_id, created_at,
-                        role, user_action, user_action_description,
-                        interacted_image_url, image_encoding, shadow_content,
-                        expert_content, tools_used, citations, embedding)
-                       VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
-                    (
-                        interaction.user_id,
-                        interaction.content,
-                        interaction.request_id,
-                        created_at_iso,
-                        interaction.role,
-                        interaction.user_action.value,
-                        interaction.user_action_description,
-                        interaction.interacted_image_url,
-                        interaction.image_encoding,
-                        interaction.shadow_content,
-                        interaction.expert_content,
-                        _json_dumps([t.model_dump() for t in interaction.tools_used]),
-                        _json_dumps([c.model_dump() for c in interaction.citations]),
-                        _json_dumps(interaction.embedding),
-                    ),
-                )
-                iid = cur.lastrowid or 0
-                interaction.interaction_id = iid
-            self.conn.commit()
+            try:
+                self.conn.execute("BEGIN IMMEDIATE")
+                self._assert_subject_writable_locked(subject_ref)
+                if interaction.interaction_id:
+                    self.conn.execute(
+                        """INSERT OR REPLACE INTO interactions
+                           (interaction_id, user_id, content, request_id, created_at,
+                            role, user_action, user_action_description,
+                            interacted_image_url, image_encoding, shadow_content,
+                            expert_content, tools_used, citations, embedding, governance_subject_ref)
+                           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                        (
+                            interaction.interaction_id,
+                            interaction.user_id,
+                            interaction.content,
+                            interaction.request_id,
+                            created_at_iso,
+                            interaction.role,
+                            interaction.user_action.value,
+                            interaction.user_action_description,
+                            interaction.interacted_image_url,
+                            interaction.image_encoding,
+                            interaction.shadow_content,
+                            interaction.expert_content,
+                            _json_dumps(
+                                [t.model_dump() for t in interaction.tools_used]
+                            ),
+                            _json_dumps(
+                                [c.model_dump() for c in interaction.citations]
+                            ),
+                            _json_dumps(interaction.embedding),
+                            subject_ref,
+                        ),
+                    )
+                    iid = interaction.interaction_id
+                else:
+                    cur = self.conn.execute(
+                        """INSERT INTO interactions
+                           (user_id, content, request_id, created_at,
+                            role, user_action, user_action_description,
+                            interacted_image_url, image_encoding, shadow_content,
+                            expert_content, tools_used, citations, embedding, governance_subject_ref)
+                           VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                        (
+                            interaction.user_id,
+                            interaction.content,
+                            interaction.request_id,
+                            created_at_iso,
+                            interaction.role,
+                            interaction.user_action.value,
+                            interaction.user_action_description,
+                            interaction.interacted_image_url,
+                            interaction.image_encoding,
+                            interaction.shadow_content,
+                            interaction.expert_content,
+                            _json_dumps(
+                                [t.model_dump() for t in interaction.tools_used]
+                            ),
+                            _json_dumps(
+                                [c.model_dump() for c in interaction.citations]
+                            ),
+                            _json_dumps(interaction.embedding),
+                            subject_ref,
+                        ),
+                    )
+                    iid = cur.lastrowid or 0
+                    interaction.interaction_id = iid
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+                raise
         # Update FTS and vec
         self._fts_upsert(
             "interactions_fts",

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

@@ -30,6 +30,8 @@ class RequestMixin:
     _execute: Any
     _fetchone: Any
     _fetchall: Any
+    _subject_ref_for_user_id: Any
+    _assert_subject_writable_locked: Any
 
     # ------------------------------------------------------------------
     # Request methods
@@ -38,20 +40,31 @@ class RequestMixin:
     @SQLiteStorageBase.handle_exceptions
     def add_request(self, request: Request) -> None:
         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, evaluation_only)
-               VALUES (?,?,?,?,?,?,?)""",
-            (
-                request.request_id,
-                request.user_id,
-                created_at_iso,
-                request.source,
-                request.agent_version,
-                request.session_id,
-                1 if request.evaluation_only else 0,
-            ),
-        )
+        subject_ref = self._subject_ref_for_user_id(request.user_id)
+        with self._lock:
+            try:
+                self.conn.execute("BEGIN IMMEDIATE")
+                self._assert_subject_writable_locked(subject_ref)
+                self.conn.execute(
+                    """INSERT OR REPLACE INTO requests
+                       (request_id, user_id, created_at, source, agent_version, session_id,
+                        evaluation_only, governance_subject_ref)
+                       VALUES (?,?,?,?,?,?,?,?)""",
+                    (
+                        request.request_id,
+                        request.user_id,
+                        created_at_iso,
+                        request.source,
+                        request.agent_version,
+                        request.session_id,
+                        1 if request.evaluation_only else 0,
+                        subject_ref,
+                    ),
+                )
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+                raise
 
     @SQLiteStorageBase.handle_exceptions
     def get_request(self, request_id: str) -> Request | None:
@@ -155,35 +168,62 @@ class RequestMixin:
         end_time: int | None = None,
         top_k: int | None = 30,
         offset: int = 0,
+        source: str | None = None,
     ) -> dict[str, list[RequestInteractionDataModel]]:
-        sql = "SELECT * FROM requests WHERE 1=1"
-        params: list[Any] = []
-
+        # Request-level filters shared by both the session-page query and the
+        # request-fetch query. Pagination is applied at the SESSION level
+        # (top_k/offset count sessions, not request rows) so a session with many
+        # requests is never truncated to a subset of its rows.
+        filter_sql = ""
+        filter_params: list[Any] = []
         if user_id:
-            sql += " AND user_id = ?"
-            params.append(user_id)
+            filter_sql += " AND user_id = ?"
+            filter_params.append(user_id)
         if request_id:
-            sql += " AND request_id = ?"
-            params.append(request_id)
+            filter_sql += " AND request_id = ?"
+            filter_params.append(request_id)
         if session_id:
-            sql += " AND session_id = ?"
-            params.append(session_id)
-        if start_time:
-            sql += " AND created_at >= ?"
-            params.append(_epoch_to_iso(start_time))
-        if end_time:
-            sql += " AND created_at <= ?"
-            params.append(_epoch_to_iso(end_time))
+            filter_sql += " AND session_id = ?"
+            filter_params.append(session_id)
+        if source is not None:
+            filter_sql += " AND source = ?"
+            filter_params.append(source)
+        if start_time is not None:
+            filter_sql += " AND created_at >= ?"
+            filter_params.append(_epoch_to_iso(start_time))
+        if end_time is not None:
+            filter_sql += " AND created_at <= ?"
+            filter_params.append(_epoch_to_iso(end_time))
 
+        # Step 1: select the page of session_ids, ordered by each session's most
+        # recent matching request (latest-first), with session_id as a stable
+        # tiebreak so pages don't overlap or skip.
         effective_limit = top_k or 100
-        sql += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
-        params.extend([effective_limit, offset])
+        page_rows = self._fetchall(
+            f"SELECT session_id, MAX(created_at) AS latest FROM requests "
+            f"WHERE 1=1{filter_sql} "
+            f"GROUP BY session_id ORDER BY latest DESC, session_id DESC "
+            f"LIMIT ? OFFSET ?",
+            [*filter_params, effective_limit, offset],
+        )
+        if not page_rows:
+            return {}
+        page_session_ids = [r["session_id"] for r in page_rows]
 
-        req_rows = self._fetchall(sql, params)
+        # Step 2: fetch ALL matching requests for the sessions in this page.
+        placeholders = ",".join("?" for _ in page_session_ids)
+        req_rows = self._fetchall(
+            f"SELECT * FROM requests WHERE 1=1{filter_sql} "
+            f"AND session_id IN ({placeholders}) ORDER BY created_at DESC",
+            [*filter_params, *page_session_ids],
+        )
         if not req_rows:
             return {}
 
-        grouped: dict[str, list[RequestInteractionDataModel]] = {}
+        # Preserve the latest-first session ordering from step 1.
+        grouped: dict[str, list[RequestInteractionDataModel]] = {
+            (sid or ""): [] for sid in page_session_ids
+        }
         for rr in req_rows:
             req = _row_to_request(rr)
             group_name = req.session_id or ""

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/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",
+]