claude-smart 0.2.49 → 0.2.50

package/plugin/vendor/reflexio/reflexio/server/services/retrieval/session_dedup.py

@@ -0,0 +1,127 @@
+"""In-memory record of search results already served to a session.
+
+When a unified search request carries a ``session_id``, results returned for
+that ``(org_id, session_id)`` are remembered here so later searches in the
+same session can skip items the session has already received and surface the
+next-best matches instead. The session is the dedup scope: concurrent
+sessions never affect each other, and a request without a ``session_id``
+neither reads nor writes this cache.
+
+The cache is deliberately process-local and best-effort. Losing it (restart,
+another replica) only means an item may be served to a session twice — the
+pre-dedup behavior. The time- and size-based limits below are memory bounds,
+not dedup semantics: within a live session an item stays suppressed for the
+session's lifetime.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections import OrderedDict
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+
+# Entity key: (entity_kind, entity_id) with entity_kind one of
+# "profile" | "user_playbook" | "agent_playbook" and entity_id stringified.
+EntityKey = tuple[str, str]
+
+_MAX_SESSIONS = 1024
+_MAX_ENTRIES_PER_SESSION = 2000
+_IDLE_EVICTION_SECONDS = 12 * 60 * 60
+
+
+@dataclass
+class _SessionEntry:
+    last_access: float
+    # OrderedDict used as an insertion-ordered set for FIFO eviction.
+    entries: OrderedDict[EntityKey, None] = field(default_factory=OrderedDict)
+
+
+class SessionSeenCache:
+    """Bounded per-(org, session) set of entity keys already served.
+
+    Bounds: least-recently-used session eviction beyond ``max_sessions``,
+    FIFO entry eviction beyond ``max_entries_per_session``, and lazy removal
+    of sessions idle longer than ``idle_eviction_seconds``.
+    """
+
+    def __init__(
+        self,
+        max_sessions: int = _MAX_SESSIONS,
+        max_entries_per_session: int = _MAX_ENTRIES_PER_SESSION,
+        idle_eviction_seconds: float = _IDLE_EVICTION_SECONDS,
+    ) -> None:
+        self._lock = threading.Lock()
+        self._max_sessions = max_sessions
+        self._max_entries_per_session = max_entries_per_session
+        self._idle_eviction_seconds = idle_eviction_seconds
+        self._sessions: OrderedDict[tuple[str, str], _SessionEntry] = OrderedDict()
+
+    def seen(self, org_id: str, session_id: str) -> frozenset[EntityKey]:
+        """Return the entity keys already served to this org's session.
+
+        Args:
+            org_id (str): Organization the session belongs to
+            session_id (str): Session identifier from the search request
+
+        Returns:
+            frozenset[EntityKey]: Keys previously recorded for the session
+        """
+        now = time.monotonic()
+        key = (org_id, session_id)
+        with self._lock:
+            self._evict_idle(now)
+            entry = self._sessions.get(key)
+            if entry is None:
+                return frozenset()
+            entry.last_access = now
+            self._sessions.move_to_end(key)
+            return frozenset(entry.entries)
+
+    def record(self, org_id: str, session_id: str, keys: Iterable[EntityKey]) -> None:
+        """Record entity keys as served to this org's session.
+
+        Args:
+            org_id (str): Organization the session belongs to
+            session_id (str): Session identifier from the search request
+            keys (Iterable[EntityKey]): Entity keys returned to the caller
+        """
+        now = time.monotonic()
+        session_key = (org_id, session_id)
+        entity_keys = list(keys)
+        with self._lock:
+            self._evict_idle(now)
+            entry = self._sessions.get(session_key)
+            if entry is None:
+                if not entity_keys:
+                    # Nothing to remember: don't let empty results consume a
+                    # session slot and evict a live session's seen-state.
+                    return
+                entry = _SessionEntry(last_access=now)
+                self._sessions[session_key] = entry
+            entry.last_access = now
+            self._sessions.move_to_end(session_key)
+            for entity_key in entity_keys:
+                entry.entries[entity_key] = None
+            while len(entry.entries) > self._max_entries_per_session:
+                entry.entries.popitem(last=False)
+            while len(self._sessions) > self._max_sessions:
+                self._sessions.popitem(last=False)
+
+    def clear(self) -> None:
+        """Drop all sessions (test hook)."""
+        with self._lock:
+            self._sessions.clear()
+
+    def _evict_idle(self, now: float) -> None:
+        # Sessions are LRU-ordered, so idle ones cluster at the front.
+        while self._sessions:
+            _, entry = next(iter(self._sessions.items()))
+            if now - entry.last_access <= self._idle_eviction_seconds:
+                break
+            self._sessions.popitem(last=False)
+
+
+# Process-wide instance used by the unified search service.
+session_seen_cache = SessionSeenCache()

package/plugin/vendor/reflexio/reflexio/server/services/retrieval/temporal.py

@@ -0,0 +1,104 @@
+"""Temporal post-processing for search results.
+
+Applies query-derived temporal signals (extracted by the query reformulator
+alongside the rewrite — see ``ReformulationResult``) to ranked entity lists:
+
+- ``window_bounds``: relative day offsets → absolute datetimes for the
+  per-arm ``start_time``/``end_time`` SQL filters.
+- ``freshness_collapse``: within near-duplicate groups of competing facts,
+  the freshest wins — deterministically fixing "stale fact with the same
+  wording outranks its fresh update", which LLM ordering alone misses.
+- ``sort_by_recency``: absolute timestamp ordering for "current/latest X"
+  questions.
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+from reflexio.server.services.profile.profile_generation_service_utils import (
+    check_string_token_overlap,
+)
+
+_DUPLICATE_OVERLAP_THRESHOLD = 0.6
+
+
+def entity_timestamp(entity: Any) -> int:
+    """The entity's primary timestamp (0 when missing).
+
+    Profiles carry ``last_modified_timestamp``; playbooks carry
+    ``created_at`` — same fields the recency decay reads.
+    """
+    return int(
+        getattr(entity, "last_modified_timestamp", None)
+        or getattr(entity, "created_at", None)
+        or 0
+    )
+
+
+def window_bounds(
+    start_days_ago: float | None,
+    end_days_ago: float | None,
+    now: datetime | None = None,
+) -> tuple[datetime | None, datetime | None]:
+    """Convert relative day offsets into absolute (start, end) datetimes.
+
+    Args:
+        start_days_ago: Older bound ("in the last 7 days" → 7).
+        end_days_ago: Newer bound ("before this month" → ~30, no start).
+        now: Reference time (real now when omitted).
+
+    Returns:
+        tuple: (start_time, end_time), either side None when unbounded.
+    """
+    now = now or datetime.now(UTC)
+    start = now - timedelta(days=start_days_ago) if start_days_ago is not None else None
+    end = now - timedelta(days=end_days_ago) if end_days_ago is not None else None
+    if start and end and start > end:
+        start, end = end, start
+    return start, end
+
+
+def freshness_collapse(entities: list[Any]) -> list[Any]:
+    """Within near-duplicate groups of competing facts, freshest wins.
+
+    Greedy grouping in ranked order by token overlap of (trigger + content);
+    each group stays anchored at its best-ranked member's position but is
+    internally ordered newest-first. Relevance order across unrelated
+    entities is untouched.
+
+    Args:
+        entities: Ranked entities of one arm.
+
+    Returns:
+        list: Entities with near-duplicate groups collapsed newest-first.
+    """
+    groups: list[list[Any]] = []
+    for entity in entities:
+        text = _compare_text(entity)
+        for group in groups:
+            if check_string_token_overlap(
+                text, _compare_text(group[0]), _DUPLICATE_OVERLAP_THRESHOLD
+            ):
+                group.append(entity)
+                break
+        else:
+            groups.append([entity])
+    collapsed: list[Any] = []
+    for group in groups:
+        collapsed.extend(sorted(group, key=entity_timestamp, reverse=True))
+    return collapsed
+
+
+def sort_by_recency(entities: list[Any]) -> list[Any]:
+    """Order entities newest-first (for explicit current/latest questions)."""
+    return sorted(entities, key=entity_timestamp, reverse=True)
+
+
+def _compare_text(entity: Any) -> str:
+    """Trigger + content, punctuation-normalized for token-overlap grouping."""
+    trigger = getattr(entity, "trigger", None) or ""
+    content = getattr(entity, "content", "") or ""
+    return re.sub(r"[^\w\s]", " ", f"{trigger} {content}").strip()

package/plugin/vendor/reflexio/reflexio/server/services/shadow_comparison/dispatcher.py

@@ -0,0 +1,139 @@
+"""Publish-time dispatch for per-turn shadow comparisons."""
+
+from __future__ import annotations
+
+import logging
+import random
+
+from reflexio.models.api_schema.domain.entities import Interaction
+from reflexio.server.api_endpoints.request_context import RequestContext
+from reflexio.server.llm.litellm_client import LiteLLMClient
+from reflexio.server.services.shadow_comparison.judge import ShadowComparisonJudge
+
+logger = logging.getLogger(__name__)
+
+_ASSISTANT_ROLES = {"agent", "assistant"}
+
+
+def dispatch_shadow_comparison_judge(
+    *,
+    storage,  # noqa: ANN001 - BaseStorage; concrete type would create import cycles
+    interactions: list[Interaction],
+    session_id: str,
+    agent_version: str,
+    request_context: RequestContext,
+    llm_client: LiteLLMClient,
+) -> None:
+    """Judge each shadow-bearing assistant turn in a single publish request."""
+    if not interactions:
+        return
+
+    supports_verdicts = getattr(
+        storage, "supports_shadow_comparison_verdicts", lambda: False
+    )
+    if not supports_verdicts():
+        logger.info(
+            "Skipping shadow comparison for session=%s because %s does not support verdict storage",
+            session_id,
+            type(storage).__name__,
+        )
+        return
+
+    sorted_interactions = sorted(interactions, key=lambda i: i.created_at)
+    shadow_interactions = [
+        interaction
+        for interaction in sorted_interactions
+        if interaction.shadow_content
+        and interaction.role.strip().lower() in _ASSISTANT_ROLES
+    ]
+    if not shadow_interactions:
+        return
+
+    config = request_context.configurator.get_config()  # type: ignore[reportOptionalMemberAccess]
+    judge = ShadowComparisonJudge(
+        llm_client=llm_client,
+        prompt_manager=request_context.prompt_manager,  # type: ignore[reportOptionalMemberAccess]
+        prompt_version=config.shadow_comparison_judge_prompt_version,
+    )
+    rng = random.Random()  # noqa: S311 - position randomization, not crypto
+    saved_count = 0
+
+    for interaction in shadow_interactions:
+        conversation_context = _format_request_transcript_before(
+            sorted_interactions=sorted_interactions,
+            target=interaction,
+        )
+        try:
+            verdict = judge.judge_turn(
+                interaction=interaction,
+                session_id=session_id,
+                agent_version=agent_version,
+                rng=rng,
+                conversation_context=conversation_context,
+            )
+        except Exception as exc:  # noqa: BLE001 - one judge failure must not abort the batch
+            logger.warning(
+                "shadow_comparison dispatch failed for interaction %s: %s",
+                interaction.interaction_id,
+                exc,
+            )
+            continue
+        if verdict is None:
+            continue
+        try:
+            storage.save_shadow_comparison_verdict(verdict)
+            saved_count += 1
+        except NotImplementedError:
+            logger.info(
+                "Stopping shadow comparison for session=%s because %s does not support verdict storage",
+                session_id,
+                type(storage).__name__,
+            )
+            return
+        except Exception as exc:  # noqa: BLE001 - single-row save failure must not abort batch
+            logger.warning(
+                "shadow_comparison verdict save failed for interaction %s: %s",
+                interaction.interaction_id,
+                exc,
+            )
+
+    if saved_count:
+        logger.info(
+            "Saved %d shadow_comparison verdict(s) for session=%s",
+            saved_count,
+            session_id,
+        )
+
+
+def _format_request_transcript_before(
+    *, sorted_interactions: list[Interaction], target: Interaction
+) -> str:
+    """Format prior turns in the same publish request as judge context.
+
+    ``sorted_interactions`` must already be ordered by ``created_at`` — the
+    caller sorts once and passes the shared list so this runs O(n) per turn.
+    """
+    prior_turns: list[Interaction] = []
+    for interaction in sorted_interactions:
+        if interaction is target or (
+            interaction.interaction_id
+            and interaction.interaction_id == target.interaction_id
+        ):
+            break
+        if interaction.content:
+            prior_turns.append(interaction)
+    if not prior_turns:
+        return ""
+    return "\n\n".join(
+        f"{_display_role(interaction.role)}:\n{interaction.content}"
+        for interaction in prior_turns
+    )
+
+
+def _display_role(role: str) -> str:
+    normalized = role.strip().lower()
+    if normalized in {"user", "human"}:
+        return "User"
+    if normalized in _ASSISTANT_ROLES:
+        return "Assistant"
+    return role.strip() or "Unknown"

package/plugin/vendor/reflexio/reflexio/server/services/shadow_comparison/judge.py

@@ -77,14 +77,16 @@ class ShadowComparisonJudge:
         agent_version: str,
         rng: random.Random,
         user_message: str = "",
+        conversation_context: str | None = None,
     ) -> ShadowComparisonVerdict | None:
         """
         Grade one interaction; return ``None`` when the LLM fails or the
         interaction has no shadow response to compare against.
 
-        Returning ``None`` (rather than raising) lets the regen worker
-        skip this turn and continue with the rest of the session — one
-        rate-limit blip should not abort an entire batch.
+        Returning ``None`` (rather than raising) lets the publish-time
+        dispatcher skip this turn and continue with the rest of the
+        request's shadow-bearing turns — one rate-limit blip should not
+        abort an entire batch.
 
         Args:
             interaction (Interaction): The agent-side interaction. Its
@@ -98,9 +100,11 @@ class ShadowComparisonJudge:
                 Production callers pass a fresh ``random.Random()`` per
                 judge call; tests inject a seeded ``Random`` for
                 reproducibility.
-            user_message (str): The user turn this interaction responds
-                to. Optional — empty string is rendered into the prompt
-                if the caller does not provide a value.
+            user_message (str): Backward-compatible single-turn context used
+                by the v1.0 prompt.
+            conversation_context (str | None): Request-local transcript context
+                used by v1.1+ prompts. Defaults to ``user_message`` so explicit
+                v1.0 prompt-version overrides keep working.
 
         Returns:
             ShadowComparisonVerdict | None: The constructed verdict, or
@@ -118,7 +122,13 @@ class ShadowComparisonJudge:
         prompt = self._prompt_manager.render_prompt(
             prompt_id=_PROMPT_ID,
             variables={
+                # ``user_message`` is retained only for explicit v1.0.0
+                # prompt-version overrides; the active v1.1+ template reads
+                # ``conversation_context`` instead. Do not drop it as "unused".
                 "user_message": user_message,
+                "conversation_context": conversation_context
+                if conversation_context is not None
+                else user_message,
                 "request_1_response": request_1,
                 "request_2_response": request_2,
             },

package/plugin/vendor/reflexio/reflexio/server/services/shadow_comparison/worker.py

@@ -0,0 +1,137 @@
+"""Bounded background worker for publish-time shadow comparison."""
+
+from __future__ import annotations
+
+import logging
+import queue
+import threading
+from dataclasses import dataclass
+
+from reflexio.models.api_schema.domain.entities import Interaction
+from reflexio.server.services.shadow_comparison.dispatcher import (
+    dispatch_shadow_comparison_judge,
+)
+from reflexio.server.usage_metrics import record_usage_event
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_WORKER_COUNT = 2
+_DEFAULT_QUEUE_SIZE = 1000
+
+
+@dataclass(frozen=True)
+class ShadowComparisonJob:
+    """Metadata needed to judge one publish request's shadow-bearing turns.
+
+    Carries only ``org_id`` plus request-scoped data — never the live
+    ``storage`` / ``request_context`` / ``llm_client`` objects. Those are
+    re-resolved via ``get_reflexio(org_id)`` inside the worker so a job that
+    waits in the queue across a config reload / cache eviction runs against
+    the *current* per-org instance rather than a stale one.
+    """
+
+    org_id: str
+    interactions: list[Interaction]
+    session_id: str
+    agent_version: str
+
+
+class ShadowComparisonWorker:
+    """Small process-local daemon worker pool for shadow comparison jobs."""
+
+    def __init__(
+        self,
+        *,
+        worker_count: int = _DEFAULT_WORKER_COUNT,
+        queue_size: int = _DEFAULT_QUEUE_SIZE,
+    ) -> None:
+        self.worker_count = max(1, worker_count)
+        self._queue: queue.Queue[ShadowComparisonJob] = queue.Queue(
+            maxsize=max(1, queue_size)
+        )
+        self._threads: list[threading.Thread] = []
+        self._start_lock = threading.Lock()
+        self._started = False
+
+    def start(self) -> None:
+        with self._start_lock:
+            if self._started:
+                return
+            self._threads = [
+                threading.Thread(
+                    target=self._worker_loop,
+                    name=f"shadow-comparison-worker-{idx}",
+                    daemon=True,
+                )
+                for idx in range(self.worker_count)
+            ]
+            for thread in self._threads:
+                thread.start()
+            self._started = True
+            logger.info(
+                "event=shadow_comparison_worker_started workers=%d queue_size=%d",
+                self.worker_count,
+                self._queue.maxsize,
+            )
+
+    def enqueue(self, job: ShadowComparisonJob) -> bool:
+        self.start()
+        try:
+            self._queue.put_nowait(job)
+        except queue.Full:
+            logger.warning(
+                "event=shadow_comparison_queue_full org_id=%s session_id=%s queue_size=%d",
+                job.org_id,
+                job.session_id,
+                self._queue.maxsize,
+            )
+            record_usage_event(
+                org_id=job.org_id,
+                user_id=None,
+                request_id=None,
+                session_id=job.session_id,
+                source=None,
+                agent_version=job.agent_version,
+                event_name="shadow_comparison_dropped",
+                event_category="shadow_comparison",
+                outcome="dropped",
+                metadata={"queue_size": self._queue.maxsize},
+            )
+            return False
+        return True
+
+    def _worker_loop(self) -> None:
+        # Imported lazily to break the import cycle generation_service ->
+        # shadow_comparison.worker -> reflexio_cache -> reflexio_lib ->
+        # generation_service (the publish_learning_worker does the same).
+        from reflexio.server.cache.reflexio_cache import get_reflexio
+
+        while True:
+            job = self._queue.get()
+            try:
+                reflexio = get_reflexio(org_id=job.org_id)
+                request_context = reflexio.request_context
+                dispatch_shadow_comparison_judge(
+                    storage=request_context.storage,
+                    interactions=job.interactions,
+                    session_id=job.session_id,
+                    agent_version=job.agent_version,
+                    request_context=request_context,
+                    llm_client=reflexio.llm_client,
+                )
+            except Exception:
+                logger.exception(
+                    "event=shadow_comparison_job_failed org_id=%s session_id=%s",
+                    job.org_id,
+                    job.session_id,
+                )
+            finally:
+                self._queue.task_done()
+
+
+_worker = ShadowComparisonWorker()
+
+
+def enqueue_shadow_comparison(job: ShadowComparisonJob) -> bool:
+    """Enqueue a shadow comparison job, dropping it when the local queue is full."""
+    return _worker.enqueue(job)

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

@@ -34,6 +34,10 @@ _CANONICAL_DELETE_TARGET_NAMES = (
     "profile",
     "user_playbook",
     "agent_success_evaluation_result",
+    "retrieved_learning_evaluation_result",
+    "evaluation_operation_state",
+    "offline_tuner_reward_label",
+    "offline_tuner_reward_label_target_by_target_owner",
     "profile_purge",
     "user_playbook_purge",
 )
@@ -52,6 +56,10 @@ _ALLOWED_PURGE_TARGET_NAMES = frozenset(
         "profile",
         "user_playbook",
         "agent_success_evaluation_result",
+        "retrieved_learning_evaluation_result",
+        "evaluation_operation_state",
+        "offline_tuner_reward_label",
+        "offline_tuner_reward_label_target_by_target_owner",
         "agent_playbook",
         "profile_purge",
         "user_playbook_purge",
@@ -157,6 +165,10 @@ _ALLOWED_DELETED_COUNTS_KEYS = frozenset(
         "profiles",
         "requests",
         "agent_success_evaluation_results",
+        "retrieved_learning_evaluation_results",
+        "evaluation_operation_states",
+        "offline_tuner_reward_labels",
+        "offline_tuner_reward_label_targets_by_target_owner",
         "purged_profiles",
         "purged_user_playbooks",
     }

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

@@ -0,0 +1,54 @@
+"""Shared validation for the lifecycle filters on bulk by-id getters.
+
+``include_inactive=True`` returns every owned row regardless of lifecycle
+status, expiry, or approval — it is the historical-resolution mode used by the
+retrieved-learning evaluator. Combining it with an explicit status filter is
+contradictory: the filter would be silently discarded and the caller would get
+back rows it asked to exclude. Fail loud instead.
+"""
+
+from __future__ import annotations
+
+from reflexio.models.api_schema.domain import PlaybookStatus, Status
+from reflexio.server.services.storage.error import StorageError
+
+
+def validate_include_inactive(
+    *,
+    include_inactive: bool,
+    status_filter: list[Status | None] | None = None,
+    playbook_status_filter: list[PlaybookStatus] | None = None,
+) -> None:
+    """Reject ``include_inactive=True`` combined with an explicit status filter.
+
+    Raises ``StorageError`` rather than ``ValueError`` so the behavior is uniform
+    across backends: both ``handle_exceptions`` decorators re-raise ``StorageError``
+    untouched, whereas any other exception type is swallowed, wrapped, and (on
+    Supabase) reported to Sentry — turning a caller bug into noise.
+
+    Args:
+        include_inactive (bool): Whether the caller asked for all rows regardless
+            of lifecycle status.
+        status_filter (list[Status | None] | None): Explicit lifecycle statuses
+            the caller asked for, if any.
+        playbook_status_filter (list[PlaybookStatus] | None): Explicit approval
+            statuses the caller asked for, if any.
+
+    Raises:
+        StorageError: If ``include_inactive`` is True and either filter is set.
+    """
+    if not include_inactive:
+        return
+    conflicting = [
+        name
+        for name, value in (
+            ("status_filter", status_filter),
+            ("playbook_status_filter", playbook_status_filter),
+        )
+        if value is not None
+    ]
+    if conflicting:
+        raise StorageError(
+            f"include_inactive=True cannot be combined with {' and '.join(conflicting)}"
+            " — include_inactive ignores lifecycle filters. Pass one or the other."
+        )