claude-smart 0.2.48 → 0.2.50

package/plugin/vendor/reflexio/reflexio/server/services/evaluation_overview/components/hero_state.py

@@ -11,7 +11,6 @@ from enum import StrEnum
 
 _FULL_MIN_DAYS = 14
 _FULL_MIN_SHADOW_N = 500
-_SHADOW_OFF_MIN_DAYS = 7
 
 
 class HeroState(StrEnum):
@@ -50,7 +49,7 @@ def compute_hero_state(
             migration pair in supabase/data/supabase/migrations/. The
             per-turn shadow grade in F1 lives on a different surface.)
         total_results (int): Total AgentSuccessEvaluationResult rows in the
-            trend window (used only to differentiate EMPTY from SHADOW_OFF).
+            trend window, used to distinguish EMPTY from states with data.
 
     Returns:
         HeroState: The single applicable state. Empty wins over everything;
@@ -59,15 +58,7 @@ def compute_hero_state(
     if total_results == 0:
         return HeroState.EMPTY
     if not shadow_enabled:
-        if (
-            days_since_first_eval is not None
-            and days_since_first_eval >= _SHADOW_OFF_MIN_DAYS
-        ):
-            return HeroState.SHADOW_OFF
-        # <7 days since first eval AND shadow off → still onboarding;
-        # render as EMPTY so the frontend shows onboarding rather than a
-        # partly-formed trend.
-        return HeroState.EMPTY
+        return HeroState.SHADOW_OFF
     if days_since_first_eval is None or days_since_first_eval < _FULL_MIN_DAYS:
         return HeroState.EARLY
     if n_shadow_in_window < _FULL_MIN_SHADOW_N:

package/plugin/vendor/reflexio/reflexio/server/services/evaluation_overview/components/rule_attribution.py

@@ -10,7 +10,11 @@ from __future__ import annotations
 from collections.abc import Mapping
 from dataclasses import dataclass
 
-CitationKey = tuple[str, str]  # (kind, real_id) — matches PlaybookApplicationStat
+from reflexio.models.api_schema.domain import CitationKind
+
+CitationKey = tuple[
+    CitationKind, str
+]  # (kind, real_id) — matches PlaybookApplicationStat
 SessionIdentity = tuple[str, str]  # (user_id, session_id)
 
 
@@ -19,7 +23,7 @@ class RuleAttribution:
     """One row of the "rules that moved the needle" panel."""
 
     rule_id: str
-    kind: str
+    kind: CitationKind
     title: str
     successes_with: int
     failures_with: int

package/plugin/vendor/reflexio/reflexio/server/services/evaluation_overview/service.py

@@ -47,6 +47,7 @@ from reflexio.server.services.evaluation_overview.components.hero_state import (
     compute_hero_state,
 )
 from reflexio.server.services.evaluation_overview.components.rule_attribution import (
+    CitationKey,
     compute_net_sessions,
 )
 from reflexio.server.services.evaluation_overview.components.shadow_aggregation import (
@@ -80,14 +81,14 @@ class EvaluationOverviewService:
         Time windows used here:
           - ``[request.from_ts, request.to_ts]`` is the *trend* window. The hero
             chart, rule attribution, and the rule-attribution session set are
-            all computed over it. The frontend sends an 8-week range so the
-            trend chart has shape.
+            all computed over it. The frontend defaults to a 7-day range but
+            the user can widen it via the date pickers.
           - The *tile baseline* and *distribution baseline* are tighter:
             ``last_7d`` (≤ to_ts) vs ``prior_7d`` (the 7d before that).
-            Tying these to ``request.from_ts`` is wrong — with an 8-week
-            request, ``prior`` would land 9 weeks back and always be empty,
-            so every tile would display "no baseline" regardless of how much
-            data the org has.
+            Tying these to ``request.from_ts`` is wrong — for any window wider
+            than 7 days ``prior`` would land before the requested window and
+            always be empty, so every tile would display "no baseline"
+            regardless of how much data the org has.
         """
         # Tile + distribution baselines are always last-7d-vs-prior-7d,
         # anchored to ``request.to_ts`` (which is "now" from the frontend's
@@ -206,6 +207,9 @@ class EvaluationOverviewService:
         results: list[AgentSuccessEvaluationResult],
         earliest_eval_ts: int | None,
     ) -> HeroBlock:
+        # days_since only feeds the EARLY-vs-FULL gate, which is reachable only
+        # when shadow_enabled is True. Shadow is hardcoded off below, so this is
+        # currently inert — retained for the (pending) shadow re-enable.
         if earliest_eval_ts is None:
             days_since = None
         else:
@@ -264,8 +268,8 @@ class EvaluationOverviewService:
     def _build_attribution(
         self,
         results: list[AgentSuccessEvaluationResult],
-        citations_by_session: dict[ResultKey, list[tuple[str, str]]],
-        rule_titles: dict[tuple[str, str], str],
+        citations_by_session: dict[ResultKey, list[CitationKey]],
+        rule_titles: dict[CitationKey, str],
     ) -> list[RuleAttributionRow]:
         is_success_by_session = {
             (r.user_id, r.session_id): r.is_success for r in results
@@ -291,7 +295,7 @@ class EvaluationOverviewService:
 
     def _load_citations(
         self, result_keys: list[ResultKey]
-    ) -> tuple[dict[ResultKey, list[tuple[str, str]]], dict[tuple[str, str], str]]:
+    ) -> tuple[dict[ResultKey, list[CitationKey]], dict[CitationKey, str]]:
         """Pull `Interaction.citations` keyed by user/session, with title lookup.
 
         Falls back to empty data when the underlying storage method returns
@@ -300,8 +304,8 @@ class EvaluationOverviewService:
         """
         wanted = set(result_keys)
         session_ids = sorted({session_id for _, session_id in result_keys})
-        citations_by_session: dict[ResultKey, list[tuple[str, str]]] = defaultdict(list)
-        rule_titles: dict[tuple[str, str], str] = {}
+        citations_by_session: dict[ResultKey, list[CitationKey]] = defaultdict(list)
+        rule_titles: dict[CitationKey, str] = {}
         for citation in self.storage.get_citations_by_session_ids(session_ids):  # type: ignore[attr-defined]
             result_key = (citation.user_id, citation.session_id)
             if result_key not in wanted:
@@ -369,8 +373,8 @@ class EvaluationOverviewService:
         previous: list[AgentSuccessEvaluationResult],
         session_sources: dict[ResultKey, str],
         bucket: BucketLiteral,
-        citations_by_session: dict[ResultKey, list[tuple[str, str]]],
-        rule_titles: dict[tuple[str, str], str],
+        citations_by_session: dict[ResultKey, list[CitationKey]],
+        rule_titles: dict[CitationKey, str],
         current_scores: list[ImportedScore],
         prior_scores: list[ImportedScore],
     ) -> SourceSetComparison:

package/plugin/vendor/reflexio/reflexio/server/services/extraction/agent_run_records.py

@@ -47,14 +47,25 @@ def build_extractor_agent_run_record(
     org_id: str,
     extractor_kind: str,
     user_id: str | None,
-    request_id: str,
     agent_version: str | None,
     source: str | None,
     request_interaction_data_models: list[RequestInteractionDataModel],
     extractor_config: BaseModel,
     service_config: Any,
     agent_context: str,
+    generation_request_id: str | None = None,
+    request_id: str | None = None,
 ) -> AgentRunRecord:
+    if generation_request_id is not None:
+        if request_id is not None and request_id != generation_request_id:
+            raise TypeError(
+                "generation_request_id and request_id must match when both are provided"
+            )
+    elif request_id is not None:
+        generation_request_id = request_id
+    else:
+        raise TypeError("generation_request_id is required")
+
     source_interaction_ids = extract_source_interaction_ids(
         request_interaction_data_models
     )
@@ -66,7 +77,9 @@ def build_extractor_agent_run_record(
             org_id=org_id,
             extractor_kind=extractor_kind,
             user_id=user_id,
-            request_id=request_id,
+            # The durable storage boundary still uses the legacy ``request_id``
+            # field name for run provenance.
+            request_id=generation_request_id,
             agent_version=agent_version,
             source=source,
             source_interaction_ids=source_interaction_ids,
@@ -80,7 +93,9 @@ def build_extractor_agent_run_record(
         ),
         status=AgentRunStatus.RUNNING,
         generation_request_snapshot={
-            "request_id": request_id,
+            # Snapshot payloads also keep the legacy ``request_id`` key so
+            # existing storage readers do not need a migration.
+            "request_id": generation_request_id,
             "source": source,
             "source_interaction_ids": source_interaction_ids,
             "session_count": len(request_interaction_data_models),

package/plugin/vendor/reflexio/reflexio/server/services/extraction/outcome.py

@@ -7,6 +7,9 @@ from typing import TYPE_CHECKING, Literal
 
 if TYPE_CHECKING:
     from reflexio.server.llm.token_accounting import RunTokenTotals
+    from reflexio.server.services.deferred_learning_plan import (
+        ExtractorBookmarkAdvance,
+    )
 
 
 @dataclass(frozen=True)
@@ -17,6 +20,9 @@ class ExtractionOutcome[T]:
     items: list[T] = field(default_factory=list)
     run_id: str | None = None
     token_totals: RunTokenTotals | None = None
+    # The stride-bookmark advance the extractor no longer applies itself (F1);
+    # applied downstream in persist (durable) or ``.run()``'s persist half.
+    bookmark_advance: ExtractorBookmarkAdvance | None = None
 
     @classmethod
     def completed(
@@ -25,9 +31,14 @@ class ExtractionOutcome[T]:
         *,
         run_id: str | None = None,
         token_totals: RunTokenTotals | None = None,
+        bookmark_advance: ExtractorBookmarkAdvance | None = None,
     ) -> ExtractionOutcome[T]:
         return cls(
-            status="completed", items=items, run_id=run_id, token_totals=token_totals
+            status="completed",
+            items=items,
+            run_id=run_id,
+            token_totals=token_totals,
+            bookmark_advance=bookmark_advance,
         )
 
     @classmethod

package/plugin/vendor/reflexio/reflexio/server/services/extraction/prior_answer_search.py

@@ -151,7 +151,7 @@ def format_prior_knowledge_context(matches: list[PriorAnswerMatch]) -> str | Non
         for match in resolved:
             lines.extend(
                 [
-                    f"- source_request_id: {match.pending_tool_call_id}",
+                    f"- pending_tool_call_id: {match.pending_tool_call_id}",
                     f"  question: {match.question_text}",
                     f"  answer: {_format_result(match.result)}",
                     f"  resolved_at: {_format_datetime(match.resolved_at)}",

package/plugin/vendor/reflexio/reflexio/server/services/extraction/resumable_agent.py

@@ -161,6 +161,7 @@ def run_resumable_extraction_agent(
     log_label: str,
 ) -> AgentRunResult:
     """Run and finalize a config-gated classic extraction agent pass."""
+    generation_request_id = request_id
     pending_config = _pending_tool_call_config(request_context)
     storage = request_context.storage
     if storage is None:
@@ -172,7 +173,7 @@ def run_resumable_extraction_agent(
         org_id=request_context.org_id,
         extractor_kind=extractor_kind,
         user_id=user_id,
-        request_id=request_id,
+        generation_request_id=generation_request_id,
         agent_version=agent_version,
         source=source,
         request_interaction_data_models=request_interaction_data_models,

package/plugin/vendor/reflexio/reflexio/server/services/extraction/resume_scheduler.py

@@ -107,9 +107,7 @@ class ExtractionResumeScheduler(ThreadedScheduler):
         try:
             bootstrap_ctx = self.request_context_factory(self.bootstrap_org_id)
             config = bootstrap_ctx.configurator.get_config()
-            poll_interval = (
-                config.pending_tool_call_config.resume_poll_interval_seconds
-            )
+            poll_interval = config.pending_tool_call_config.resume_poll_interval_seconds
             self._expire_pending_tool_calls(bootstrap_ctx)
             for org_id in self._discover_org_ids(bootstrap_ctx):
                 if self._stop_event.is_set():

package/plugin/vendor/reflexio/reflexio/server/services/extraction/resume_worker.py

@@ -764,6 +764,7 @@ class ExtractionResumeWorker:
                 force_extraction=True,
             )
             service._finalize_extracted_items(items)
+            self._record_finalized_learnings(run, items, entity_type="profile")
             return
         if run.binding.extractor_kind == "playbook":
             service = PlaybookGenerationService(
@@ -779,11 +780,76 @@ class ExtractionResumeWorker:
                 force_extraction=True,
             )
             service._finalize_extracted_items(items)
+            self._record_finalized_learnings(run, items, entity_type="user_playbook")
             return
         raise ResumeWorkerError(
             f"Unsupported extractor kind {run.binding.extractor_kind!r}"
         )
 
+    def _record_finalized_learnings(
+        self, run: AgentRunRecord, items: list[Any], *, entity_type: str
+    ) -> None:
+        """Emit ``learnings_generated`` for a finalized resumable-extraction batch.
+
+        Prefers one event per learning id (``entity_id``/``profile_id`` for
+        profiles, ``user_playbook_id`` for playbooks) when every item in
+        ``items`` carries a durable id — the common case, since these ids are
+        assigned by the extractor (profile) or by ``save_user_playbooks``
+        in-place during ``_finalize_extracted_items`` (playbook), which has
+        already run by the time this is called. Falls back to the
+        count-based aggregate event when any item lacks one (e.g. dropped by
+        within-batch/consolidator dedup before persist, leaving a default
+        ``user_playbook_id=0``) — this avoids both fabricating an id for a row
+        that never persisted and colliding on the shared default-id key.
+        Totals are preserved either way: ``len(items)`` learnings are counted
+        whether via ``len(learning_ids)`` per-record events or one aggregate
+        ``count=len(items)`` event.
+        """
+        from reflexio.server.billing_meter import (
+            emit_learnings_generated,
+            emit_learnings_generated_records,
+        )
+
+        if not items:
+            return
+
+        id_attr = "profile_id" if entity_type == "profile" else "user_playbook_id"
+        learning_ids = [
+            str(getattr(item, id_attr))
+            for item in items
+            if getattr(item, id_attr, None)
+        ]
+        metadata = {
+            "run_id": run.id,
+            "extractor_kind": run.binding.extractor_kind,
+        }
+        if len(learning_ids) == len(items):
+            emit_learnings_generated_records(
+                org_id=self.request_context.org_id,
+                configurator=self.request_context.configurator,
+                learning_ids=learning_ids,
+                source="resumable_extraction",
+                pipeline=run.binding.extractor_kind,
+                user_id=run.binding.user_id,
+                request_id=run.binding.request_id,
+                agent_version=run.binding.agent_version,
+                entity_type=entity_type,
+                metadata=metadata,
+            )
+            return
+        emit_learnings_generated(
+            org_id=self.request_context.org_id,
+            configurator=self.request_context.configurator,
+            count=len(items),
+            source="resumable_extraction",
+            pipeline=run.binding.extractor_kind,
+            user_id=run.binding.user_id,
+            request_id=run.binding.request_id,
+            agent_version=run.binding.agent_version,
+            entity_type=entity_type,
+            metadata=metadata,
+        )
+
     def _schedule_finalized_tagging(self, run: AgentRunRecord) -> None:
         user_id = run.binding.user_id
         if not user_id: