claude-smart 0.2.49 → 0.2.50

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/playbook/_eval_results.py

@@ -1,9 +1,17 @@
 """Abstract agent success evaluation result store declarations."""
 
 from abc import abstractmethod
+from typing import Any
 
 from reflexio.models.api_schema.domain import (
     AgentSuccessEvaluationResult,
+    RetrievedLearningEvaluationResult,
+)
+
+from ..retrieved_learning_state import (
+    DEFAULT_TRANSCRIPT_CHAR_LIMIT,
+    BoundedRetrievedLearningSnapshot,
+    RetrievedLearningCommitResult,
 )
 
 
@@ -122,3 +130,166 @@ class AgentEvaluationResultStoreMixin:
             int: Number of rows deleted.
         """
         raise NotImplementedError
+
+    # ==============================
+    # Retrieved-learning evaluation methods
+    # ==============================
+    #
+    # Concurrency contract (see storage_base/retrieved_learning_state.py):
+    # generation fencing + session-fingerprint CAS recomputed under the
+    # replacement transaction's lock. No interaction write/delete path is
+    # instrumented.
+
+    @abstractmethod
+    def begin_retrieved_learning_evaluation_run(
+        self, user_id: str, session_id: str
+    ) -> int:
+        """Allocate the next evaluation generation for one session.
+
+        Atomically increments (creating on first use) the ``generation``
+        counter in the session's ``_operation_state`` row after asserting the
+        governance subject is writable. Concurrent callers receive distinct
+        generations.
+
+        Args:
+            user_id (str): Session owner.
+            session_id (str): Evaluated session.
+
+        Returns:
+            int: The allocated generation (monotonically increasing per
+            session).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def load_bounded_retrieved_learning_snapshot(
+        self,
+        user_id: str,
+        session_id: str,
+        raw_ref_limit: int = 5_000,
+        transcript_char_limit: int = DEFAULT_TRANSCRIPT_CHAR_LIMIT,
+    ) -> BoundedRetrievedLearningSnapshot:
+        """Load the bounded session projection for evaluation.
+
+        Streams interaction rows (no ``Interaction`` objects, no embeddings or
+        image encodings) and counts raw attachment occurrences before
+        appending; on occurrence ``raw_ref_limit + 1`` the scan aborts with
+        ``attachment_limit_exceeded=True``.
+
+        Args:
+            user_id (str): Session owner.
+            session_id (str): Evaluated session.
+            raw_ref_limit (int): Maximum raw attachment occurrences to parse.
+            transcript_char_limit (int): Maximum transcript characters retained.
+
+        Returns:
+            BoundedRetrievedLearningSnapshot: The bounded projection.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_matching_retrieved_learning_terminal_state(
+        self, user_id: str, session_id: str, session_fingerprint: str
+    ) -> dict[str, Any] | None:
+        """Return the session's terminal evaluation state if still fresh.
+
+        Implementations must use a writer transaction and recompute the live
+        session fingerprint in that transaction. A match requires terminal
+        status and equality among the supplied, persisted, and live
+        fingerprints.
+
+        Args:
+            user_id (str): Session owner.
+            session_id (str): Evaluated session.
+            session_fingerprint (str): Fingerprint of the current session.
+
+        Returns:
+            dict | None: The persisted state JSON on a match, else None.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def replace_retrieved_learning_evaluation_results(
+        self,
+        user_id: str,
+        session_id: str,
+        generation: int,
+        session_fingerprint: str,
+        proposed_status: str,
+        diagnostics: dict[str, Any],
+        results: list[RetrievedLearningEvaluationResult],
+    ) -> RetrievedLearningCommitResult:
+        """Atomically replace one session's evaluation result set.
+
+        In one transaction: locks the session's state row, requires the
+        current generation to equal ``generation`` (else ``superseded``),
+        recomputes the session fingerprint from live rows and requires it to
+        equal ``session_fingerprint`` (else ``stale``), rechecks every
+        result's source row for retrieval eligibility (ineligible rows are
+        dropped), then deletes the prior session set, inserts the filtered
+        set, and persists completion state — all or nothing.
+
+        When commit-time eligibility removes every candidate, prior rows are
+        cleared and the final status is ``not_applicable`` regardless of
+        ``proposed_status``.
+
+        Args:
+            user_id (str): Session owner.
+            session_id (str): Evaluated session.
+            generation (int): Generation allocated by
+                :meth:`begin_retrieved_learning_evaluation_run`.
+            session_fingerprint (str): Fingerprint of the judged snapshot.
+            proposed_status (str): ``"complete"`` or ``"degraded"``.
+            diagnostics (dict): Sanitized counters/timestamps persisted in
+                operation state (never prompt content or raw exception text).
+            results (list[RetrievedLearningEvaluationResult]): Proposed rows.
+
+        Returns:
+            RetrievedLearningCommitResult: Disposition plus authoritative
+            final status/count when applied.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def finish_retrieved_learning_evaluation_run(
+        self,
+        user_id: str,
+        session_id: str,
+        generation: int,
+        status: str,
+        diagnostics: dict[str, Any],
+    ) -> None:
+        """Record a non-applied run outcome (``failed`` or ``pending``).
+
+        Generation-guarded CAS: updates state only while ``generation`` is
+        still current, so an older failure cannot overwrite a newer run.
+        Result rows are never touched.
+
+        Args:
+            user_id (str): Session owner.
+            session_id (str): Evaluated session.
+            generation (int): Generation of the finishing run.
+            status (str): ``"failed"`` or ``"pending"``.
+            diagnostics (dict): Sanitized counters and error type.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_retrieved_learning_evaluation_results(
+        self,
+        user_id: str | None = None,
+        session_id: str | None = None,
+        limit: int = 100,
+    ) -> list[RetrievedLearningEvaluationResult]:
+        """Read persisted per-learning verdicts.
+
+        Args:
+            user_id (str, optional): Filter by session owner.
+            session_id (str, optional): Filter by session.
+            limit (int): Maximum rows, ordered by
+                ``created_at DESC, result_id DESC``.
+
+        Returns:
+            list[RetrievedLearningEvaluationResult]: Matching rows.
+        """
+        raise NotImplementedError

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/playbook/_user.py

@@ -12,7 +12,44 @@ class UserPlaybookStoreMixin:
     """Abstract user playbook CRUD + search methods."""
 
     @abstractmethod
-    def save_user_playbooks(self, user_playbooks: list[UserPlaybook]) -> None:
+    def save_user_playbooks(
+        self,
+        user_playbooks: list[UserPlaybook],
+        *,
+        skip_embedding: bool = False,
+    ) -> None:
+        """Insert user playbooks, assigning survivor ids.
+
+        Args:
+            user_playbooks: Playbooks to insert.
+            skip_embedding: When ``False`` (default — what every current caller
+                gets), the embedding (and, when document expansion is enabled,
+                ``expanded_terms``) is recomputed unconditionally at write time,
+                exactly as before. Callers that ``model_copy`` a DB-loaded row
+                with changed content but the old embedding preserved rely on
+                this recompute, so it must stay the default. When ``True``, the
+                embedding step is skipped because ``.embedding`` was already
+                populated up front by
+                :meth:`precompute_user_playbook_embeddings` (the durable
+                compute/persist split — the only caller that opts in). A bare
+                ``if not up.embedding`` guard is deliberately NOT used: it would
+                persist a stale vector for the ``model_copy`` callers' changed
+                content (silent search corruption).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def precompute_user_playbook_embeddings(
+        self, playbooks: list[UserPlaybook]
+    ) -> None:
+        """Populate ``.embedding`` (and ``.expanded_terms`` when document
+        expansion is enabled) on each playbook in place, issuing NO DB write.
+
+        Lets the durable learning worker do the (slow, LLM/embedding) compute
+        outside the writer transaction, then pass ``skip_embedding=True`` to
+        :meth:`save_user_playbooks` so the fenced persist writes the
+        pre-computed vector without re-embedding.
+        """
         raise NotImplementedError
 
     @abstractmethod
@@ -183,6 +220,8 @@ class UserPlaybookStoreMixin:
         user_id: str,
         user_playbook_ids: list[int],
         status_filter: list[Status | None] | None = None,
+        *,
+        include_inactive: bool = False,
     ) -> list[UserPlaybook]:
         """Fetch the subset of a user's playbooks whose ids are in the list.
 
@@ -197,11 +236,23 @@ class UserPlaybookStoreMixin:
             status_filter (list[Status | None] | None): Statuses to
                 include. ``None`` (default) means CURRENT only — same
                 default as ``get_user_playbooks`` for consistency.
+            include_inactive (bool): Return matching owned rows regardless of
+                lifecycle status. This is the *historical resolution* mode (see
+                ``RetrievedLearningEvaluator``): it answers "what did this id
+                point at", not "what is retrievable now". It is a strict superset
+                of ``include_tombstones`` on ``get_user_playbook_by_id``, which
+                only unhides MERGED/SUPERSEDED for lineage walks —
+                ``include_inactive`` also returns ARCHIVED rows. ``user_id``
+                scoping still applies. The default preserves retrieval behavior.
 
         Returns:
             list[UserPlaybook]: Matching playbooks. Order is unspecified.
                 Ids that do not exist (or do not match the user / status
                 filter) are silently omitted.
+
+        Raises:
+            StorageError: If ``include_inactive`` is combined with an explicit
+                ``status_filter`` — the two are contradictory.
         """
         raise NotImplementedError
 

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/profiles/_interaction_store.py

@@ -60,6 +60,65 @@ class InteractionStoreMixin:
         """
         return
 
+    def iter_interactions_missing_vectors(
+        self,
+        limit: int,  # noqa: ARG002
+    ) -> list[tuple[int, str]]:
+        """Enumerate interactions whose embedding vector was never persisted.
+
+        When an embedding call fails or degrades, the ingest path stores an empty
+        embedding (and writes no vector row), returns success, and nothing ever
+        re-embeds the row — so that interaction is invisible to vector/hybrid
+        search forever. This method surfaces those rows so a background sweep can
+        re-embed them (see ``backfill_missing_interaction_vectors``).
+
+        Returns ``(interaction_id, embed_text)`` pairs where ``embed_text`` is
+        derived exactly as the ingest path derives it, so a backfilled vector is
+        byte-for-byte comparable to a freshly-ingested one.
+
+        Safe default: returns ``[]`` — "this backend does not support backfill
+        detection". Backends that store embeddings (SQLite here; Supabase and
+        Postgres in the enterprise repo) MUST override this so their rows are
+        actually recoverable. Bounded by ``limit`` per call.
+
+        Args:
+            limit: Maximum number of interactions to return.
+
+        Returns:
+            list[tuple[int, str]]: ``(interaction_id, embed_text)`` pairs, at
+            most ``limit`` long. Empty when nothing needs backfilling or the
+            backend does not support detection.
+        """
+        return []
+
+    def backfill_missing_interaction_vectors(
+        self,
+        limit: int,  # noqa: ARG002
+    ) -> int:
+        """Re-embed and persist vectors for interactions missing them.
+
+        Idempotent and bounded: enumerates up to ``limit`` interactions via
+        ``iter_interactions_missing_vectors``, re-embeds their text using the
+        same embedder + derivation the ingest path uses, and writes the vector
+        back through the same code path a fresh insert uses. Once a vector
+        exists the row is skipped on the next call.
+
+        Fail-safe: if the embedder is unavailable the implementation must skip
+        gracefully and leave the work for a later call (never raise, never
+        hot-loop a down embedder).
+
+        Safe default: returns ``0`` — "this backend does not support backfill".
+        SQLite overrides this; the enterprise Supabase/Postgres backends must
+        override it (and ``iter_interactions_missing_vectors``) for production.
+
+        Args:
+            limit: Maximum number of interactions to re-embed this call.
+
+        Returns:
+            int: Number of interactions whose vector was backfilled.
+        """
+        return 0
+
     @abstractmethod
     def delete_user_interaction(self, request: DeleteUserInteractionRequest) -> None:
         raise NotImplementedError

package/plugin/vendor/reflexio/reflexio/server/services/storage/storage_base/profiles/_profile_store.py

@@ -66,8 +66,43 @@ class ProfileStoreMixin:
         raise NotImplementedError
 
     @abstractmethod
-    def add_user_profile(self, user_id: str, user_profiles: list[UserProfile]) -> None:
-        """Add the user profile for a given user id."""
+    def add_user_profile(
+        self,
+        user_id: str,
+        user_profiles: list[UserProfile],
+        *,
+        skip_embedding: bool = False,
+    ) -> None:
+        """Add the user profile for a given user id.
+
+        Args:
+            user_id: The owning user id (positional, unused by some backends).
+            user_profiles: Profiles to insert.
+            skip_embedding: When ``False`` (default — what every current caller
+                gets), the embedding (and, when document expansion is enabled,
+                ``expanded_terms``) is recomputed unconditionally at write time,
+                exactly as before. Callers that ``model_copy`` a DB-loaded row
+                with changed content but the old embedding preserved rely on
+                this recompute, so it must stay the default. When ``True``, the
+                embedding step is skipped because ``.embedding`` was already
+                populated up front by :meth:`precompute_profile_embeddings`
+                (the durable compute/persist split — the only caller that opts
+                in). A bare ``if not profile.embedding`` guard is deliberately
+                NOT used: it would persist a stale vector for the ``model_copy``
+                callers' changed content (silent search corruption).
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def precompute_profile_embeddings(self, profiles: list[UserProfile]) -> None:
+        """Populate ``.embedding`` (and ``.expanded_terms`` when document
+        expansion is enabled) on each profile in place, issuing NO DB write.
+
+        Lets the durable learning worker do the (slow, LLM/embedding) compute
+        outside the writer transaction, then pass ``skip_embedding=True`` to
+        :meth:`add_user_profile` so the fenced persist writes the pre-computed
+        vector without re-embedding.
+        """
         raise NotImplementedError
 
     @abstractmethod
@@ -175,6 +210,8 @@ class ProfileStoreMixin:
         user_id: str,
         profile_ids: list[str],
         status_filter: list[Status | None] | None = None,
+        *,
+        include_inactive: bool = False,
     ) -> list[UserProfile]:
         """Fetch the subset of a user's profiles whose ids are in the list.
 
@@ -189,11 +226,24 @@ class ProfileStoreMixin:
             status_filter (list[Status | None] | None): Statuses to
                 include. ``None`` (default) means CURRENT only — same
                 default as ``get_user_profile`` for consistency.
+            include_inactive (bool): Return matching owned rows regardless of
+                lifecycle status or expiry. This is the *historical resolution*
+                mode (see ``RetrievedLearningEvaluator``): it answers "what did
+                this id point at", not "what is retrievable now". It is a strict
+                superset of ``include_tombstones`` on ``get_profile_by_id``,
+                which only unhides MERGED/SUPERSEDED for lineage walks —
+                ``include_inactive`` also returns ARCHIVED and EXPIRED rows.
+                ``user_id`` scoping still applies. The default preserves
+                retrieval behavior.
 
         Returns:
             list[UserProfile]: Matching profiles. Order is unspecified.
                 Ids that do not exist (or do not match the user / status
                 filter) are silently omitted.
+
+        Raises:
+            StorageError: If ``include_inactive`` is combined with an explicit
+                ``status_filter`` — the two are contradictory.
         """
         raise NotImplementedError
 

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

@@ -0,0 +1,226 @@
+"""Shared pure helpers for retrieved-learning evaluation state.
+
+Used by every storage backend (SQLite, Supabase, native Postgres) and by the
+group-evaluation runner, so this module must stay free of storage imports.
+
+Concurrency model (no mutation-site instrumentation):
+
+- The **session fingerprint** is a SHA-256 digest over every interaction ID in
+  the session plus each interaction's canonical attachment refs. Any
+  interaction publish or delete changes it (autoincrement interaction IDs make
+  ABA collisions unrealizable), so it covers transcript-only changes as well
+  as attachment changes.
+- Each evaluation run receives a monotonically increasing **generation**
+  allocated in ``_operation_state``. Replacement CASes generation and a
+  fingerprint recomputed under the replacement transaction's lock, so an
+  older or stale snapshot cannot overwrite newer session state.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass, field
+from typing import Literal
+
+RETRIEVED_LEARNING_STATE_PREFIX = "retrieved_learning_eval"
+
+# Statuses persisted in _operation_state. "complete" and "not_applicable" are
+# terminal (the fast path may short-circuit on them); "degraded" and "failed"
+# are retried by the next scheduled or forced run.
+type RetrievedLearningPersistedStatus = Literal[
+    "pending", "in_progress", "complete", "degraded", "failed", "not_applicable"
+]
+TERMINAL_RETRIEVED_STATUSES: frozenset[str] = frozenset({"complete", "not_applicable"})
+
+# Outcomes of one runner invocation. "stale"/"superseded"/"skipped" are
+# invocation outcomes only and are never stored as persisted status.
+type RetrievedLearningInvocationStatus = Literal[
+    "pending",
+    "complete",
+    "degraded",
+    "failed",
+    "not_applicable",
+    "stale",
+    "superseded",
+    "skipped",
+]
+
+# Canonical kinds accepted and persisted by retrieved-learning evaluation.
+# ``RetrievedLearning.kind`` validates these at the API boundary; storage
+# parsers still filter defensively against this set.
+CANONICAL_RETRIEVED_KINDS: frozenset[str] = frozenset(
+    {"profile", "user_playbook", "agent_playbook"}
+)
+DEFAULT_TRANSCRIPT_CHAR_LIMIT = 64_000
+
+
+class SessionFingerprintBuilder:
+    """Incrementally build the canonical session fingerprint."""
+
+    def __init__(self) -> None:
+        self._digest = hashlib.sha256()
+        self._digest.update(b"[")
+        self._has_entries = False
+
+    def add(
+        self,
+        interaction_id: int,
+        refs: list[tuple[str, str]],
+        role: str = "",
+        content: str = "",
+    ) -> None:
+        """Fold one interaction into the running digest.
+
+        ``role``/``content`` are the transcript the judges actually saw, so a
+        content-only edit (e.g. ``INSERT OR REPLACE`` on an existing
+        interaction that keeps its id and attachments) still invalidates the
+        fingerprint. Callers on the precompute and commit-recompute sides MUST
+        pass content truncated identically (``DEFAULT_TRANSCRIPT_CHAR_LIMIT``);
+        otherwise a session would compare unequal and never commit.
+        """
+        if self._has_entries:
+            self._digest.update(b",")
+        self._digest.update(
+            json.dumps(
+                [interaction_id, sorted(refs), role, content],
+                separators=(",", ":"),
+            ).encode("utf-8")
+        )
+        self._has_entries = True
+
+    def hexdigest(self) -> str:
+        digest = self._digest.copy()
+        digest.update(b"]")
+        return digest.hexdigest()
+
+
+def build_retrieved_learning_state_key(user_id: str, session_id: str) -> str:
+    """Build the ``_operation_state`` key for one session's evaluation state.
+
+    Length-prefixed (following the grade_on_demand cache-key precedent) so a
+    crafted user/session pair cannot collide with another pair. Org scoping is
+    unnecessary: ``_operation_state`` is already org-scoped on every backend.
+
+    Args:
+        user_id (str): Session owner.
+        session_id (str): Evaluated session.
+
+    Returns:
+        str: The state key.
+    """
+    return (
+        f"{RETRIEVED_LEARNING_STATE_PREFIX}"
+        f"::{len(user_id)}:{user_id}::{len(session_id)}:{session_id}"
+    )
+
+
+@dataclass
+class SnapshotInteraction:
+    """One interaction row in the bounded session projection.
+
+    ``refs`` holds ``(kind, learning_id)`` attachment tuples; interaction
+    content is carried only for transcript construction and is never
+    persisted in operation state.
+    """
+
+    interaction_id: int
+    role: str
+    content: str
+    created_at: int
+    refs: list[tuple[str, str]] = field(default_factory=list)
+
+
+@dataclass
+class BoundedRetrievedLearningSnapshot:
+    """Bounded projection of one session for retrieved-learning evaluation.
+
+    Loaded without constructing full ``Interaction`` objects (no embeddings,
+    no image encodings). ``attachment_limit_exceeded`` is set when the raw
+    attachment-occurrence cap was hit; the evaluator must then make zero LLM
+    calls.
+    """
+
+    interactions: list[SnapshotInteraction] = field(default_factory=list)
+    earliest_request_created_at: int | None = None
+    agent_version: str = ""
+    raw_attachment_count: int = 0
+    attachment_limit_exceeded: bool = False
+    precomputed_fingerprint: str | None = None
+
+
+def append_bounded_snapshot_interaction(
+    snapshot: BoundedRetrievedLearningSnapshot,
+    *,
+    interaction_id: int,
+    role: str,
+    content: str,
+    created_at: int,
+    refs: list[tuple[str, str]],
+    transcript_chars_remaining: int,
+) -> int:
+    """Retain refs and only the transcript prefix that fits the char budget."""
+    retained_role = ""
+    retained_content = ""
+    if transcript_chars_remaining > 0 and content:
+        prefix_size = len(role) + 3
+        content_budget = max(0, transcript_chars_remaining - prefix_size)
+        if content_budget:
+            retained_role = role
+            retained_content = content[:content_budget]
+            transcript_chars_remaining -= prefix_size + len(retained_content)
+    if refs or retained_content:
+        snapshot.interactions.append(
+            SnapshotInteraction(
+                interaction_id=interaction_id,
+                role=retained_role,
+                content=retained_content,
+                created_at=created_at,
+                refs=refs,
+            )
+        )
+    return max(0, transcript_chars_remaining)
+
+
+def session_fingerprint(snapshot: BoundedRetrievedLearningSnapshot) -> str:
+    """Compute the canonical session fingerprint for a bounded snapshot.
+
+    Covers every interaction ID, each interaction's ``(kind, learning_id)``
+    refs, and its transcript role/content, so any publish, delete, or in-place
+    content edit in the session invalidates it. Only this digest is ever
+    persisted.
+
+    Args:
+        snapshot (BoundedRetrievedLearningSnapshot): The session projection.
+
+    Returns:
+        str: Hex SHA-256 digest.
+    """
+    if snapshot.precomputed_fingerprint is not None:
+        return snapshot.precomputed_fingerprint
+    builder = SessionFingerprintBuilder()
+    for interaction in sorted(
+        snapshot.interactions,
+        key=lambda item: (item.created_at, item.interaction_id),
+    ):
+        builder.add(
+            interaction.interaction_id,
+            interaction.refs,
+            interaction.role,
+            interaction.content,
+        )
+    return builder.hexdigest()
+
+
+@dataclass
+class RetrievedLearningCommitResult:
+    """Outcome of one atomic result-set replacement.
+
+    ``status``/``committed_count`` are authoritative only when ``disposition``
+    is ``"applied"`` (commit-time eligibility can turn a proposed status into
+    ``"not_applicable"``).
+    """
+
+    disposition: Literal["applied", "stale", "superseded"]
+    status: RetrievedLearningPersistedStatus | None = None
+    committed_count: int = 0

package/plugin/vendor/reflexio/reflexio/server/services/tagging/tagging_scheduler.py

@@ -20,8 +20,10 @@ import os
 import threading
 import time
 from collections.abc import Callable
+from functools import partial
 
 from reflexio.server.api_endpoints.request_context import RequestContext
+from reflexio.server.callback_executor import submit_callback
 from reflexio.server.llm.litellm_client import LiteLLMClient
 from reflexio.server.services.tagging.service import TaggingService
 
@@ -101,13 +103,10 @@ class TaggingScheduler:
                             continue
 
                         del self._scheduled[key]
-                        t = threading.Thread(
-                            target=self._run_callback,
-                            args=(key, callback),
-                            daemon=True,
-                            name=f"tagging-{key[1][:20]}",
+                        submit_callback(
+                            f"tagging-{key[1][:20]}",
+                            partial(self._run_callback, key, callback),
                         )
-                        t.start()
             except Exception:
                 logger.exception("Error in tagging scheduler loop")
                 time.sleep(1)