claude-smart 0.2.49 → 0.2.50

package/plugin/vendor/reflexio/reflexio/server/services/deferred_learning_plan.py

@@ -0,0 +1,270 @@
+"""Write-plan dataclasses for the durable-learning compute/persist split (gate b).
+
+Compute resolves these in-memory plans issuing **no** learning DB write; persist
+applies them inside one short fenced ``commit_scope``. This module starts with the
+extractor stride-bookmark advance and grows additional write-plan dataclasses in the
+later gate-(b) tasks (profile/playbook/reflection/generation/deferred plans).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from reflexio.models.api_schema.domain.entities import (
+        UserPlaybook,
+        UserProfile,
+    )
+    from reflexio.models.api_schema.service_schemas import Interaction
+    from reflexio.server.llm.token_accounting import RunTokenTotals
+    from reflexio.server.services.base_generation_service import (
+        BaseGenerationService,
+        PreparedGenerationRun,
+    )
+    from reflexio.server.services.reflection.reflection_service_utils import (
+        ReflectionDecision,
+        ReflectionResult,
+        ReflectionServiceRequest,
+    )
+    from reflexio.server.services.reflection.service import ReflectionService
+
+
+@dataclass(frozen=True)
+class ExtractorBookmarkAdvance:
+    """The extractor stride-bookmark advance, deferred out of the extractor (F1).
+
+    The extractor no longer self-advances its bookmark inside ``run()`` (a DB
+    write). It emits this on the ``ExtractionOutcome`` instead, so the advance is
+    applied later — inside the persist fence on the durable path, or right after
+    result-processing on the synchronous ``.run()`` path — keeping the bookmark
+    advance atomic with the row writes it corresponds to.
+    """
+
+    extractor_name: str
+    processed_interactions: list[Interaction]
+    # str | None (not str): the playbook extractor runs org-level with
+    # user_id=None (PlaybookGenerationServiceConfig.user_id is Optional), which
+    # maps to an unscoped bookmark key. update_extractor_bookmark accepts None.
+    user_id: str | None
+
+
+@dataclass
+class ProfileWritePlan:
+    """Resolved profile write-plan for the compute/persist split (gate b).
+
+    ``ProfileGenerationService._resolve_write_plan`` produces this in compute
+    (dedup 2nd-LLM call + existing-row reads + source/status assignment +
+    precomputed ``.embedding`` via ``precompute_profile_embeddings``), issuing
+    **no** learning DB write. ``_persist_write_plan`` applies it inside the
+    fence: ``add_user_profile(..., skip_embedding=True)`` (embeddings already
+    set) then ``supersede_profiles_by_ids``.
+
+    Attributes:
+        user_id: Owning user id for the row writes.
+        request_id: Generation request id — the lineage key
+            ``supersede_profiles_by_ids`` records. Compute drops any supersede
+            ids when this is empty (unreconstructable), so persist only ever
+            supersedes with a non-empty request_id.
+        new_profiles: New profile rows with ``source``/``status`` set and
+            ``.embedding`` precomputed in compute.
+        superseded_ids: Existing profile ids to soft-supersede on the dedup
+            path.
+    """
+
+    user_id: str
+    request_id: str
+    new_profiles: list[UserProfile]
+    superseded_ids: list[str]
+
+
+@dataclass
+class PlaybookWritePlan:
+    """Resolved playbook write-plan for the compute/persist split (gate b).
+
+    ``PlaybookGenerationService._resolve_write_plan`` produces this in compute
+    (``dedupe_and_drop_empty`` + the deduplicator's 2nd-LLM call + existing-row
+    reads + source/status assignment + precomputed ``.embedding`` via
+    ``precompute_user_playbook_embeddings``), issuing **no** learning DB write.
+    ``_persist_write_plan`` applies it inside the fence:
+    ``save_user_playbooks(..., skip_embedding=True)`` (which assigns survivor
+    ids) then ``_apply_consolidation_lineage`` (which MUST see those ids, so it
+    runs AFTER the save).
+
+    The off-thread schedulers (``_enqueue_user_playbook_optimization`` +
+    ``_trigger_playbook_aggregation``) are NOT part of persist — they fire
+    post-commit in ``emit_generation_side_effects`` (durable / ``.run()`` path)
+    or right after persist in the permanent ``_finalize_extracted_items``
+    wrapper (synchronous resume/manual path). ``output_pending_status`` /
+    ``skip_aggregation`` are snapshotted here so the scheduler dispatch reads the
+    plan rather than the reused service instance.
+
+    Attributes:
+        request_id: Generation request id — the lineage key
+            ``_apply_consolidation_lineage`` records on merges/supersedes.
+        output_pending_status: Whether the run emits PENDING rows (rerun mode);
+            when True the aggregation trigger is suppressed.
+        skip_aggregation: Whether aggregation is skipped (extract-only); when
+            True the aggregation trigger is suppressed.
+        new_playbooks: New playbook rows with ``source``/``status`` set and
+            ``.embedding`` precomputed in compute. Survivor ids are assigned by
+            ``save_user_playbooks`` in persist, before lineage reads them.
+        superseded_ids: ALL archived existing ids (merge sources + leftovers)
+            routed through ``_apply_consolidation_lineage``.
+        merge_groups: ``(survivor_index_into_new_playbooks, source_existing_ids)``
+            per dedup merge group.
+    """
+
+    request_id: str
+    output_pending_status: bool
+    skip_aggregation: bool
+    new_playbooks: list[UserPlaybook]
+    superseded_ids: list[int]
+    merge_groups: list[tuple[int, list[int]]]
+
+
+@dataclass
+class ReflectionWritePlan:
+    """Resolved reflection write-plan for the compute/persist split (F5, V2).
+
+    ``ReflectionService.compute`` produces this issuing **no** learning DB write;
+    ``persist`` applies the whole cap/validate/CAS apply loop verbatim inside the
+    fence, then advances the reflection stride-bookmark; ``emit_side_effects``
+    fires the post-commit billing + aggregation triggers. The apply loop stays a
+    single monolith (no per-revision ``ResolvedReflectionRevision`` dataclass).
+
+    Attributes:
+        request: The originating reflection request (user_id / request_id /
+            agent_version).
+        result: The reflection result. Compute seeds it with the gate/citation
+            counters resolved so far; persist's apply loop mutates it in place
+            (revised/failed/skipped/... counters) as it applies each decision.
+        decisions: ``ReflectionOutput.decisions`` to apply — ``[]`` on the four
+            early bookmark-advance paths (nothing to apply, only advance).
+        profiles_by_id: Cited profile rows resolved in compute, keyed by
+            ``profile_id`` (the apply loop's ``_apply_revision`` input).
+        playbooks_by_id: Cited playbook rows resolved in compute, keyed by
+            ``user_playbook_id``.
+        max_revisions_per_pass: Per-pass revision cap applied inside the loop.
+        bookmark_interactions: The window the reflection stride-bookmark advances
+            over in persist (``[]`` on the empty-window advance path).
+        advance_bookmark: ``True`` on all five bookmark-advance paths (the four
+            early-advance returns + the normal end). Persist advances the
+            reflection bookmark iff this is ``True``.
+        record_learnings: ``True`` only on the normal-end path — gates the
+            post-commit ``_record_learnings_generated`` billing event in emit.
+        replacement_profiles: Replacement ``UserProfile`` rows whose embeddings
+            were precomputed in compute (V2), keyed by the **cited** profile_id
+            they replace. Persist inserts these with ``skip_embedding=True`` so
+            no embedding runs inside the fence. Empty on non-compute (direct)
+            ``_replace_*`` calls, which then build+embed the row themselves.
+        replacement_playbooks: Same, keyed by the cited ``user_playbook_id``.
+        aggregation_successor_ids: Playbook successor ids collected during the
+            persist apply loop; their aggregation trigger is dispatched in
+            ``emit_side_effects`` (post-commit) so it never fires on a
+            rolled-back job.
+    """
+
+    request: ReflectionServiceRequest
+    result: ReflectionResult
+    decisions: list[ReflectionDecision]
+    profiles_by_id: dict[str, UserProfile]
+    playbooks_by_id: dict[int, UserPlaybook]
+    max_revisions_per_pass: int
+    bookmark_interactions: list[Interaction]
+    advance_bookmark: bool
+    record_learnings: bool
+    replacement_profiles: dict[str, UserProfile] = field(default_factory=dict)
+    replacement_playbooks: dict[int, UserPlaybook] = field(default_factory=dict)
+    aggregation_successor_ids: list[int] = field(default_factory=list)
+
+
+@dataclass
+class GenerationComputePlan:
+    """Resolved compute output of one ``BaseGenerationService`` run (gate b).
+
+    ``compute_generation`` runs the prepare gate + extractor + dedup/embedding
+    resolution (``_resolve_write_plan``) and drives the ``agent_run`` rows to
+    their terminal state (``_finalize_extraction_runs`` — agent_run only, §4.3),
+    issuing **no** learning DB write. ``persist_generation`` applies
+    ``write_plan`` + the extractor bookmark advance inside the fence;
+    ``emit_generation_side_effects`` fires the post-commit telemetry + billing.
+
+    The billing inputs (``extraction_run_ids`` / ``token_totals`` /
+    ``generated_count`` / ``prepared``) are **snapshotted at compute time** so
+    the fence-crossing emit reads this plan rather than the reused service
+    instance's mutable ``_last_*`` accumulators (purity contract, plan §File
+    Structure). See ``emit_generation_side_effects`` for the single-use-instance
+    invariant that also keeps the money helper's ``self._last_*`` reads safe.
+
+    Attributes:
+        prepared: The prepared generation run (identifier / extractor_name /
+            extractor_config), reused by emit for telemetry + billing input.
+        generated_count: Learnings produced by this extraction run.
+        write_plan: The resolved write-plan (``ProfileWritePlan`` /
+            ``PlaybookWritePlan`` in Tasks 6-7, a ``_LegacyItems`` shim marker
+            until then) or ``None`` when the extractor produced nothing.
+        bookmark_advance: The deferred extractor stride-bookmark advance (F1),
+            applied inside the persist scope. ``None`` when the extractor
+            produced no output or the service has no stride bookmark.
+        generation_start: ``perf_counter`` captured at compute start; emit reads
+            it for the ``generation_succeeded`` ``duration_ms`` (parity).
+        extraction_run_ids: Snapshot of the run's ``agent_run`` ids.
+        token_totals: Snapshot of the run's LLM token totals (billing cost
+            facet), or ``None`` when the extractor reported none.
+    """
+
+    prepared: PreparedGenerationRun[Any]
+    generated_count: int
+    write_plan: Any
+    bookmark_advance: ExtractorBookmarkAdvance | None
+    generation_start: float
+    extraction_run_ids: list[str]
+    token_totals: RunTokenTotals | None
+
+
+@dataclass
+class DeferredLearningPlan:
+    """One durable-learning job's resolved compute output (gate b, Task 8).
+
+    ``GenerationService.compute_deferred_learning`` acquires the same-user guard
+    (F4), then runs reflection + profile + playbook compute holding **no**
+    ``commit_scope``, and assembles this plan. It carries each present half as a
+    ``(held_service_instance, its_compute_plan)`` pair so
+    ``persist_deferred_learning`` can apply the fence-critical writes and
+    ``emit_deferred_learning_side_effects`` can fire the post-commit telemetry on
+    the very instances that produced the plans (the single-use-instance invariant
+    that keeps the money helpers' ``self._last_*`` reads valid — see
+    ``BaseGenerationService.emit_generation_side_effects``).
+
+    Attributes:
+        request_id: The job's generation request id (lineage key).
+        user_id: The user the job learns for; also the per-user F4 lock scope.
+        agent_version: Resolved agent version — carried so the post-commit
+            ``schedule_tagging`` dispatch in emit has it (the plan is all emit
+            receives).
+        lock_acquired: ``False`` when the F4 same-user guard denied this job
+            (another durable job for the same user is mid-flight). On ``False``
+            the three plan halves are ``None`` and NO LLM/compute ran — the
+            worker (Task 9) must leave the job reclaimable and must NOT
+            ``complete_learning_job`` it.
+        reflection: ``(ReflectionService, ReflectionWritePlan)`` when reflection
+            resolved something to persist, else ``None`` (gate closed / disabled
+            / compute error captured into ``warnings``).
+        profile: ``(ProfileGenerationService, GenerationComputePlan)`` when the
+            profile extractor produced a plan, else ``None``.
+        playbook: ``(PlaybookGenerationService, GenerationComputePlan)`` when the
+            playbook extractor produced a plan, else ``None``.
+        warnings: Best-effort per-half compute failures (mirrors
+            ``GenerationServiceResult.warnings``) — a failed half is dropped from
+            the plan, the others still persist.
+    """
+
+    request_id: str
+    user_id: str
+    agent_version: str
+    lock_acquired: bool
+    reflection: tuple[ReflectionService, ReflectionWritePlan] | None
+    profile: tuple[BaseGenerationService, GenerationComputePlan] | None
+    playbook: tuple[BaseGenerationService, GenerationComputePlan] | None
+    warnings: list[str] = field(default_factory=list)

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

@@ -1,8 +1,15 @@
-"""DurableLearningWorker: claim jobs from the durable queue, process in a fenced
-commit_scope so exactly one of N racing workers commits its outputs.
+"""DurableLearningWorker: claim jobs from the durable queue, split each into
+compute (no writer transaction) -> persist (short fenced commit_scope) ->
+post-commit side-effects so exactly one of N racing workers commits its outputs.
 
-Design constraints (v1 — do not remove):
-- LLM calls are inside the commit_scope (compute/persist separation is deferred).
+Design constraints (gate b — do not remove):
+- LLM extraction + dedup + embeddings run in compute_deferred_learning, OUTSIDE
+  the commit_scope. Only the fence-critical writes (profile/playbook rows +
+  bookmark advances + complete_learning_job) run inside the scope; billing /
+  telemetry / tagging / off-thread schedulers + the per-user lock release run
+  AFTER the scope commits (emit_deferred_learning_side_effects). Holding the
+  writer transaction across the ~30-120s LLM window is exactly what this split
+  removes.
 - No heartbeat thread (deferred; would deadlock a SQLite scope anyway).
 - Exactly-once is guaranteed by the fenced complete_learning_job:
     rowcount == 0  -> lease was stolen -> _SupersededError -> rollback.
@@ -27,8 +34,9 @@ class _SupersededError(Exception):
     """Raised inside commit_scope when complete_learning_job returns 0.
 
     Propagating this exception causes commit_scope to roll back all writes
-    (profiles, playbooks) made by run_deferred_learning for the superseded
-    worker — guaranteeing exactly-once side effects.
+    (profiles, playbooks, bookmark advances) made by persist_deferred_learning
+    for the superseded worker — guaranteeing exactly-once side effects. The
+    post-commit emit is skipped, so a superseded job phantom-bills nothing.
     """
 
     def __init__(self, job_id: str) -> None:
@@ -142,28 +150,59 @@ class DurableLearningWorker:
             )
             return False
 
+        gen: GenerationService | None = None
         try:
             reflexio = get_reflexio(
                 org_id=ctx.org_id, storage_base_dir=ctx.storage_base_dir
             )
             gen = GenerationService(llm_client=reflexio.llm_client, request_context=ctx)
 
-            with storage.commit_scope():
-                gen.run_deferred_learning(
-                    user_id=job.user_id,
-                    request_id=job.latest_request_id,
-                    session_id=request.session_id,
-                    source=request.source,
-                    agent_version=request.agent_version,
-                    force_extraction=job.force_extraction,
-                    skip_aggregation=job.skip_aggregation,
-                    sequential=True,  # prevent ThreadPoolExecutor deadlock on commit_scope RLock
+            # COMPUTE — LLM extraction + dedup + embeddings, NO writer transaction
+            # held. Acquires the per-user F4 lock; issues no learning DB write.
+            plan = gen.compute_deferred_learning(
+                user_id=job.user_id,
+                request_id=job.latest_request_id,
+                session_id=request.session_id,
+                source=request.source,
+                agent_version=request.agent_version,
+                force_extraction=job.force_extraction,
+                skip_aggregation=job.skip_aggregation,
+            )
+
+            # Same-user contention (F4): another same-user durable job holds the
+            # per-user lock. Leave THIS job reclaimable (dead=False) — do NOT
+            # complete it — so the queue re-claims it once the holder finishes.
+            # REFUND the attempt (refund_attempt=True): claim_learning_jobs did
+            # attempts += 1 on this claim, but no real work ran, and the ~2s poll
+            # would otherwise re-claim (and re-increment) every couple of seconds
+            # while the holder is in its ~60s compute — inflating attempts past
+            # max_attempts in seconds so the eventual winner dead-letters on its
+            # first transient error with zero real retries. The refund nets each
+            # contention cycle (claim +1, release -1) to zero. No lock to release
+            # (compute never acquired it).
+            if not plan.lock_acquired:
+                storage.fail_learning_job(
+                    job_id=job.job_id,
+                    claim_token=claim_token,
+                    dead=False,
+                    refund_attempt=True,
                 )
+                return False
+
+            # PERSIST — short fenced scope: fence-critical writes + bookmark
+            # advances only, then the claim-token fence. rows == 0 -> lease
+            # stolen -> _SupersededError -> the scope rolls persist back.
+            with storage.commit_scope():
+                gen.persist_deferred_learning(plan)
                 rows = storage.complete_learning_job(
                     job_id=job.job_id, claim_token=claim_token
                 )
                 if rows == 0:
                     raise _SupersededError(job.job_id)
+
+            # POST-COMMIT — billing / telemetry / tagging / off-thread schedulers
+            # + the per-user lock release, only for the winning worker.
+            gen.emit_deferred_learning_side_effects(plan)
             logger.info(
                 "event=learning_job_done job_id=%s org_id=%s user_id=%s",
                 job.job_id,
@@ -177,6 +216,9 @@ class DurableLearningWorker:
                 job.job_id,
                 job.org_id,
             )
+            # The persist rolled back and emit never ran, so the per-user lock is
+            # still held by this compute — release it so the reclaim isn't blocked.
+            self._release_user_lock(gen, job)
             return False
         except Exception:
             logger.exception(
@@ -185,9 +227,36 @@ class DurableLearningWorker:
                 job.org_id,
                 job.user_id,
             )
+            # emit (which releases the lock) never ran on this path — release the
+            # per-user lock so a failed job doesn't strand it.
+            self._release_user_lock(gen, job)
             # attempts was incremented by claim_learning_jobs; go dead when we've
             # exhausted max_attempts total claim attempts.
             storage.fail_learning_job(
                 job_id=job.job_id, claim_token=claim_token, dead=dead
             )
             return False
+
+    def _release_user_lock(
+        self, gen: GenerationService | None, job: LearningJob
+    ) -> None:
+        """Best-effort release of the per-user F4 lock after a rolled-back/failed
+        job, so a job whose emit (the normal release site) never ran does not
+        strand the lock and block the same user's re-claim.
+
+        Safe to call even when compute never acquired the lock: the release is a
+        CAS on the holder (``clear_in_progress_lock_if_owner``) — a no-op unless
+        this compute's ``request_id`` still owns it. Never raises.
+        """
+        if gen is None or job.latest_request_id is None:
+            return
+        try:
+            gen._release_durable_learning_lock(
+                user_id=job.user_id, request_id=job.latest_request_id
+            )
+        except Exception:
+            logger.exception(
+                "event=learning_job_lock_release_failed job_id=%s org_id=%s",
+                job.job_id,
+                job.org_id,
+            )

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,