claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/server/services/playbook/{playbook_consolidator.py → components/consolidator.py}

@@ -17,6 +17,7 @@ from reflexio.models.config_schema import (
     DeduplicationConfig,
     SearchOptions,
 )
+from reflexio.models.structured_output import StrictStructuredOutput
 from reflexio.server.api_endpoints.request_context import RequestContext
 from reflexio.server.llm.litellm_client import LiteLLMClient
 from reflexio.server.services.deduplication_utils import (
@@ -36,18 +37,19 @@ logger = logging.getLogger(__name__)
 def _coerce_existing_position(value: object) -> int:
     """Accept either a bare int position or an ``"EXISTING-N"`` label.
 
-    Wired ONLY to ``UnifyDecision.archive_existing_ids`` — the one field whose
-    int contract is genuinely a list **position** (resolved via
-    ``existing_by_position`` as ``f"EXISTING-{idx}"`` in ``_apply_unify``).
+    Wired to all three EXISTING-id integer fields —
+    ``UnifyDecision.archive_existing_ids``,
     ``RejectNewDecision.superseded_by_existing_id`` and
-    ``DifferentiateDecision.existing_id`` are DB ``user_playbook_id`` values
-    (resolved via ``existing_by_id`` in ``_apply_reject_new`` /
-    ``_apply_differentiate``) — coercing ``"EXISTING-N"`` to ``N`` on those
-    fields would silently misroute decisions when the position int doesn't
-    map to a real DB id.
+    ``DifferentiateDecision.existing_id``. The consolidation prompt instructs
+    the model to emit a list **position** for every one of them, and the apply
+    path resolves each position-first via ``existing_by_position``
+    (``f"EXISTING-{idx}"``), falling back to ``existing_by_id`` only for older
+    prompt outputs. Coercing the label here keeps all three fields consistent
+    so a weak model that returns ``"EXISTING-0"`` for any of them does not kill
+    the whole batch.
 
     The consolidation prompt labels rows as ``[EXISTING-0]``, ``[EXISTING-1]``
-    etc. (see ``_format_playbooks_with_prefix``) and ``_apply_unify``
+    etc. (see ``_format_playbooks_with_prefix``) and the apply path
     reconstructs ``f"EXISTING-{position}"`` from the integer the LLM returns.
     Strong structured-output models (GPT-4o, Claude) honor the ``list[int]``
     schema and return the bare integer ``0``; weaker models (e.g. MiniMax-M3)
@@ -132,12 +134,11 @@ class UnifyDecision(BaseModel):
 class RejectNewDecision(BaseModel):
     """The new candidate is redundant; an existing row supersedes it (storage no-op).
 
-    ``superseded_by_existing_id`` is a DB ``user_playbook_id`` (resolved
-    against ``existing_by_id`` in ``_apply_reject_new``), NOT a list
-    position — no ``"EXISTING-N"`` coercion is wired here. If the LLM
-    returns ``"EXISTING-N"`` for this field, pydantic rejects it loudly
-    rather than silently misrouting the decision (see
-    ``_coerce_existing_position`` docstring).
+    ``superseded_by_existing_id`` is a bare integer that normally refers to the
+    rendered ``EXISTING-N`` list position. The apply path also accepts a DB
+    ``user_playbook_id`` fallback for older prompts/tests, but list position is
+    resolved first because it is the only identifier visible in the rendered
+    consolidation prompt.
     """
 
     kind: Literal["reject_new"] = "reject_new"
@@ -145,16 +146,22 @@ class RejectNewDecision(BaseModel):
     superseded_by_existing_id: int
     reason: str = ""
 
+    @field_validator("superseded_by_existing_id", mode="before")
+    @classmethod
+    def _coerce_superseded_id(cls, value: object) -> int:
+        return _coerce_existing_position(value)
+
     model_config = ConfigDict(json_schema_extra={"additionalProperties": False})
 
 
 class DifferentiateDecision(BaseModel):
     """Both rules valid in distinct contexts: refine both triggers.
 
-    ``existing_id`` is a DB ``user_playbook_id`` (resolved against
-    ``existing_by_id`` in ``_apply_differentiate``), NOT a list position —
-    no ``"EXISTING-N"`` coercion is wired here. See
-    ``_coerce_existing_position`` docstring.
+    ``existing_id`` is a bare integer that normally refers to the rendered
+    ``EXISTING-N`` list position. The apply path also accepts a DB
+    ``user_playbook_id`` fallback for older prompts/tests, but list position is
+    resolved first because it is the only identifier visible in the rendered
+    consolidation prompt.
     """
 
     kind: Literal["differentiate"] = "differentiate"
@@ -164,6 +171,11 @@ class DifferentiateDecision(BaseModel):
     refined_existing_trigger: str
     reason: str = ""
 
+    @field_validator("existing_id", mode="before")
+    @classmethod
+    def _coerce_existing_id(cls, value: object) -> int:
+        return _coerce_existing_position(value)
+
     @field_validator("refined_new_trigger", "refined_existing_trigger")
     @classmethod
     def _non_empty(cls, v: str) -> str:
@@ -190,11 +202,17 @@ ConsolidationDecision = Annotated[
 ]
 
 
-class PlaybookConsolidationOutput(BaseModel):
-    """Output schema for playbook consolidation as a 4-kind discriminated union.
+# ``PlaybookConsolidationOutput`` inherits ``StrictStructuredOutput`` so the
+# emitted JSON schema is folded into the provider-accepted union shape while the
+# discriminator is kept for keyed validation at parse time (Sentry
+# PYTHON-FASTAPI-9J). This note is a comment, NOT part of the docstring, because
+# the docstring is serialized into the wire schema's ``description`` sent to the
+# model — keep implementation tokens out of it.
+class PlaybookConsolidationOutput(StrictStructuredOutput):
+    """Output schema for playbook consolidation as a 4-kind tagged union.
 
     Each decision is one of ``UnifyDecision``, ``RejectNewDecision``,
-    ``DifferentiateDecision``, or ``IndependentDecision``; the ``kind`` literal
+    ``DifferentiateDecision``, or ``IndependentDecision``; the ``kind`` field
     selects the concrete shape.
     """
 
@@ -503,7 +521,7 @@ class PlaybookConsolidator(BaseDeduplicator):
         request_id: str,
         agent_version: str,
         user_id: str | None = None,
-    ) -> tuple[list[UserPlaybook], list[int]]:
+    ) -> tuple[list[UserPlaybook], list[int], list[tuple[int, list[int]]]]:
         """
         Consolidate user playbook entries across extractors and against existing entries in DB.
 
@@ -514,7 +532,18 @@ class PlaybookConsolidator(BaseDeduplicator):
             user_id: Optional user ID to scope the existing entry search
 
         Returns:
-            Tuple of (consolidated entries, list of existing entry IDs to delete after save)
+            Tuple of ``(consolidated entries, existing ids to delete after save,
+            merge_groups)``. ``merge_groups`` is a list of
+            ``(survivor_index, source_existing_ids)`` where ``survivor_index``
+            indexes into the returned entries list and identifies the row that
+            supersedes the given existing source ids (one entry per ``unify``
+            decision that archives at least one existing row). Callers persist
+            the entries first (assigning survivor ids), then route each merge
+            group through ``storage.merge_records`` so each source becomes a
+            MERGED tombstone pointing at its survivor. The "existing ids to
+            delete" set still includes ALL archived ids (merge sources +
+            non-merge archives such as ``differentiate``'s split source); the
+            caller subtracts the merge-covered ids to find pure-delete leftovers.
         """
         # Check if mock mode is enabled
         if os.getenv("MOCK_LLM_RESPONSE", "").lower() == "true":
@@ -523,7 +552,7 @@ class PlaybookConsolidator(BaseDeduplicator):
             for result in results:
                 if isinstance(result, list):
                     all_playbooks.extend(result)
-            return all_playbooks, []
+            return all_playbooks, [], []
 
         # Flatten all new entries
         new_playbooks: list[UserPlaybook] = []
@@ -532,7 +561,7 @@ class PlaybookConsolidator(BaseDeduplicator):
                 new_playbooks.extend(result)
 
         if not new_playbooks:
-            return [], []
+            return [], [], []
 
         # Retrieve existing entries via hybrid search
         existing_playbooks = self._retrieve_existing_playbooks(
@@ -555,13 +584,13 @@ class PlaybookConsolidator(BaseDeduplicator):
                 error_type=type(e).__name__,
             ):
                 logger.exception("Failed to identify duplicates")
-            return new_playbooks, []
+            return new_playbooks, [], []
 
         if not dedup_output.decisions:
             logger.info(
                 "No consolidation decisions returned for request %s", request_id
             )
-            return new_playbooks, []
+            return new_playbooks, [], []
 
         logger.info(
             "Received %d consolidation decisions for request %s",
@@ -589,7 +618,7 @@ class PlaybookConsolidator(BaseDeduplicator):
         dedup_output: PlaybookConsolidationOutput,
         request_id: str,
         agent_version: str,  # noqa: ARG002
-    ) -> tuple[list[UserPlaybook], list[int]]:
+    ) -> tuple[list[UserPlaybook], list[int], list[tuple[int, list[int]]]]:
         """
         Build the deduplicated entry list from LLM decisions.
 
@@ -606,7 +635,16 @@ class PlaybookConsolidator(BaseDeduplicator):
             agent_version: Agent version (currently unused, kept for symmetry).
 
         Returns:
-            Tuple of (entries ready to save, existing entry IDs to delete).
+            Tuple of ``(entries ready to save, existing entry IDs to delete,
+            merge_groups)``. ``merge_groups`` carries one
+            ``(survivor_index, source_existing_ids)`` per ``unify`` decision
+            that archives >= 1 existing row, where ``survivor_index`` indexes
+            into the returned entries list (the unified survivor row) and the
+            second element is the existing ids that decision supersedes. Only
+            ``unify`` produces merge groups — it collapses N existing rows into
+            one survivor. ``differentiate`` archives its split source but emits
+            two rows (no single survivor), so its archived id appears in the
+            delete set but NOT in any merge group.
         """
         candidates_by_id = {
             f"NEW-{idx}": playbook for idx, playbook in enumerate(new_playbooks)
@@ -626,10 +664,11 @@ class PlaybookConsolidator(BaseDeduplicator):
         seen_archive: set[int] = set()
         new_rows: list[UserPlaybook] = []
         handled_new_ids: set[str] = set()
+        merge_groups: list[tuple[int, list[int]]] = []
 
         for decision in dedup_output.decisions:
             try:
-                rows, marked_new_ids = self._apply_one(
+                rows, marked_new_ids, merge_source_ids = self._apply_one(
                     decision=decision,
                     candidates_by_id=candidates_by_id,
                     existing_by_id=existing_by_id,
@@ -659,10 +698,17 @@ class PlaybookConsolidator(BaseDeduplicator):
                         existing_id_str,
                     )
                 continue
+            # Record the merge group BEFORE extending: the unified survivor is
+            # the first (and only) row a ``unify`` decision emits, so its index
+            # in the final list is the current length of ``new_rows``.
+            if merge_source_ids:
+                merge_groups.append((len(new_rows), merge_source_ids))
             new_rows.extend(rows)
             handled_new_ids.update(marked_new_ids)
             self._bump_counter(result_counters, decision.kind)
-            self._log_decision(decision, candidates_by_id, existing_by_id)
+            self._log_decision(
+                decision, candidates_by_id, existing_by_id, existing_by_position
+            )
 
         # Safety fallback: add any NEW entries the LLM did not reference, so a
         # misbehaving model cannot silently drop extracted playbooks.
@@ -684,7 +730,7 @@ class PlaybookConsolidator(BaseDeduplicator):
             result_counters.failed_count,
         )
 
-        return new_rows, archive_ids
+        return new_rows, archive_ids, merge_groups
 
     def _apply_one(
         self,
@@ -696,7 +742,7 @@ class PlaybookConsolidator(BaseDeduplicator):
         archive_ids: list[int],
         seen_archive: set[int],
         request_id: str,
-    ) -> tuple[list[UserPlaybook], list[str]]:
+    ) -> tuple[list[UserPlaybook], list[str], list[int]]:
         """Dispatch a single decision to its kind-specific apply method.
 
         Args:
@@ -712,9 +758,14 @@ class PlaybookConsolidator(BaseDeduplicator):
             request_id: Request ID stamped onto newly-built rows.
 
         Returns:
-            Tuple of ``(rows_to_insert, handled_new_ids)`` where the second
-            element is the set of ``"NEW-N"`` candidate ids consumed by this
-            decision (used to suppress the safety fallback).
+            Tuple of ``(rows_to_insert, handled_new_ids, merge_source_ids)``.
+            ``handled_new_ids`` is the set of ``"NEW-N"`` candidate ids consumed
+            by this decision (used to suppress the safety fallback).
+            ``merge_source_ids`` is non-empty ONLY for a ``unify`` decision that
+            collapses >= 1 existing row into its single survivor (the first row
+            in ``rows_to_insert``); for all other kinds it is ``[]`` because they
+            either archive nothing or split into multiple rows with no single
+            survivor.
         """
         if isinstance(decision, UnifyDecision):
             return self._apply_unify(
@@ -729,12 +780,14 @@ class PlaybookConsolidator(BaseDeduplicator):
             return self._apply_reject_new(
                 decision,
                 existing_by_id=existing_by_id,
+                existing_by_position=existing_by_position,
             )
         if isinstance(decision, DifferentiateDecision):
             return self._apply_differentiate(
                 decision,
                 candidates_by_id=candidates_by_id,
                 existing_by_id=existing_by_id,
+                existing_by_position=existing_by_position,
                 archive_ids=archive_ids,
                 seen_archive=seen_archive,
                 request_id=request_id,
@@ -752,7 +805,7 @@ class PlaybookConsolidator(BaseDeduplicator):
         archive_ids: list[int],
         seen_archive: set[int],
         request_id: str,
-    ) -> tuple[list[UserPlaybook], list[str]]:
+    ) -> tuple[list[UserPlaybook], list[str], list[int]]:
         """Collapse / compose NEW (+ 0..N EXISTING) into one row.
 
         Looks up each ``archive_existing_ids`` entry by position
@@ -774,7 +827,11 @@ class PlaybookConsolidator(BaseDeduplicator):
             request_id: Request ID stamped on the unified row.
 
         Returns:
-            Tuple of ([unified_row], [consumed NEW-N ids]).
+            Tuple of ``([unified_row], [consumed NEW-N ids], merge_source_ids)``
+            where ``merge_source_ids`` are the existing ids collapsed into the
+            unified survivor (the returned row). The survivor identity is not
+            known until the caller persists the row and reads its assigned id,
+            so the merge is materialized by the caller, not here.
 
         Raises:
             KeyError: If ``decision.new_id`` does not resolve to a known
@@ -795,11 +852,14 @@ class PlaybookConsolidator(BaseDeduplicator):
                 )
             existing_members.append(existing)
 
+        merge_source_ids: list[int] = []
         for existing in existing_members:
             pid = existing.user_playbook_id
             if pid and pid not in seen_archive:
                 seen_archive.add(pid)
                 archive_ids.append(pid)
+            if pid:
+                merge_source_ids.append(pid)
 
         budget = self._dedup_config.max_unified_content_chars
         content_len = len(decision.content)
@@ -830,43 +890,54 @@ class PlaybookConsolidator(BaseDeduplicator):
             source=candidate.source,
             source_interaction_ids=combined_source_ids,
         )
-        return [unified_row], [decision.new_id]
+        return [unified_row], [decision.new_id], merge_source_ids
 
     def _apply_reject_new(
         self,
         decision: RejectNewDecision,
         *,
         existing_by_id: dict[int, UserPlaybook],
-    ) -> tuple[list[UserPlaybook], list[str]]:
+        existing_by_position: dict[str, UserPlaybook],
+    ) -> tuple[list[UserPlaybook], list[str], list[int]]:
         """No-op apply: the existing row wins and the new candidate is dropped.
 
-        If ``decision.superseded_by_existing_id`` does not resolve to a known
-        existing row, the decision is treated as malformed: we log a warning
-        and return ``([], [])`` so the safety fallback re-inserts the candidate
-        rather than silently dropping extracted data.
+        Resolve the integer against the rendered ``EXISTING-N`` position first,
+        then as a DB ``user_playbook_id`` for backwards compatibility. If it
+        does not resolve to a known existing row, the decision is treated as
+        malformed: we log a warning and return ``([], [])`` so the safety
+        fallback re-inserts the candidate rather than silently dropping
+        extracted data.
 
         Args:
             decision: The ``RejectNewDecision`` to apply.
             existing_by_id: Mapping ``user_playbook_id`` -> existing playbook,
-                used to validate ``decision.superseded_by_existing_id``.
+                used as a fallback for ``decision.superseded_by_existing_id``.
+            existing_by_position: Mapping ``"EXISTING-M"`` -> existing playbook.
 
         Returns:
-            Tuple of ([], [consumed NEW-N id]) when the existing id resolves,
-            or ``([], [])`` when the existing id is unknown.
+            Tuple of ``([], [consumed NEW-N id], [])`` when the existing id
+            resolves, or ``([], [], [])`` when the existing id is unknown.
+            Never produces a merge group — the existing row is kept as-is (no
+            archive, no survivor).
         """
-        if decision.superseded_by_existing_id not in existing_by_id:
+        existing = self._resolve_existing_reference(
+            decision.superseded_by_existing_id,
+            existing_by_position=existing_by_position,
+            existing_by_id=existing_by_id,
+        )
+        if existing is None:
             logger.warning(
                 "event=consolidation_reject_new_invalid new_id=%s existing_id=%d",
                 decision.new_id,
                 decision.superseded_by_existing_id,
             )
-            return [], []
+            return [], [], []
         logger.info(
             "event=consolidation_reject_new new_id=%s existing_id=%d",
             decision.new_id,
             decision.superseded_by_existing_id,
         )
-        return [], [decision.new_id]
+        return [], [decision.new_id], []
 
     def _apply_differentiate(
         self,
@@ -874,10 +945,11 @@ class PlaybookConsolidator(BaseDeduplicator):
         *,
         candidates_by_id: dict[str, UserPlaybook],
         existing_by_id: dict[int, UserPlaybook],
+        existing_by_position: dict[str, UserPlaybook],
         archive_ids: list[int],
         seen_archive: set[int],
         request_id: str,
-    ) -> tuple[list[UserPlaybook], list[str]]:
+    ) -> tuple[list[UserPlaybook], list[str], list[int]]:
         """Archive the existing row and emit two refined rows in its place.
 
         Builds one ``UserPlaybook`` from the candidate's content/polarity with
@@ -889,27 +961,36 @@ class PlaybookConsolidator(BaseDeduplicator):
             decision: The ``DifferentiateDecision`` to apply.
             candidates_by_id: Mapping ``"NEW-N"`` -> candidate playbook.
             existing_by_id: Mapping ``user_playbook_id`` -> existing playbook.
+            existing_by_position: Mapping ``"EXISTING-M"`` -> existing playbook.
             archive_ids: Accumulator mutated with the existing id to archive.
             seen_archive: Dedup set for ``archive_ids``.
             request_id: Request ID stamped on both new rows.
 
         Returns:
-            Tuple of ([refined_new_row, refined_existing_row], [NEW-N id]).
+            Tuple of ``([refined_new_row, refined_existing_row], [NEW-N id],
+            [])``. ``differentiate`` is a SPLIT, not a merge: the existing row
+            is archived but maps to no single survivor, so it produces NO merge
+            group (its archived id is a pure-delete leftover for the caller).
         """
         candidate = candidates_by_id.get(decision.new_id)
         if candidate is None:
             raise KeyError(
                 f"differentiate references unknown NEW id: {decision.new_id}"
             )
-        existing = existing_by_id.get(decision.existing_id)
+        existing = self._resolve_existing_reference(
+            decision.existing_id,
+            existing_by_position=existing_by_position,
+            existing_by_id=existing_by_id,
+        )
         if existing is None:
             raise KeyError(
                 f"differentiate references unknown EXISTING id: {decision.existing_id}"
             )
 
-        if decision.existing_id not in seen_archive:
-            seen_archive.add(decision.existing_id)
-            archive_ids.append(decision.existing_id)
+        existing_db_id = existing.user_playbook_id
+        if existing_db_id and existing_db_id not in seen_archive:
+            seen_archive.add(existing_db_id)
+            archive_ids.append(existing_db_id)
 
         now_ts = int(datetime.now(UTC).timestamp())
         refined_candidate = candidate.model_copy(
@@ -929,14 +1010,14 @@ class PlaybookConsolidator(BaseDeduplicator):
                 "source_interaction_ids": list(existing.source_interaction_ids),
             }
         )
-        return [refined_candidate, refined_existing], [decision.new_id]
+        return [refined_candidate, refined_existing], [decision.new_id], []
 
     def _apply_independent(
         self,
         decision: IndependentDecision,
         *,
         candidates_by_id: dict[str, UserPlaybook],
-    ) -> tuple[list[UserPlaybook], list[str]]:
+    ) -> tuple[list[UserPlaybook], list[str], list[int]]:
         """Insert the new candidate unchanged; no archive.
 
         Args:
@@ -944,12 +1025,13 @@ class PlaybookConsolidator(BaseDeduplicator):
             candidates_by_id: Mapping ``"NEW-N"`` -> candidate playbook.
 
         Returns:
-            Tuple of ([candidate row], [consumed NEW-N id]).
+            Tuple of ``([candidate row], [consumed NEW-N id], [])`` — no archive,
+            so never a merge group.
         """
         candidate = candidates_by_id.get(decision.new_id)
         if candidate is None:
             raise KeyError(f"independent references unknown NEW id: {decision.new_id}")
-        return [candidate], [decision.new_id]
+        return [candidate], [decision.new_id], []
 
     @staticmethod
     def _merge_source_ids(playbooks: list[UserPlaybook]) -> list[int]:
@@ -970,6 +1052,25 @@ class PlaybookConsolidator(BaseDeduplicator):
                     combined.append(sid)
         return combined
 
+    @staticmethod
+    def _resolve_existing_reference(
+        raw_id: int,
+        *,
+        existing_by_position: dict[str, UserPlaybook],
+        existing_by_id: dict[int, UserPlaybook],
+    ) -> UserPlaybook | None:
+        """Resolve an LLM existing-row integer.
+
+        The rendered prompt labels rows as ``EXISTING-N`` and asks the model to
+        emit bare integers, so position is the primary interpretation. DB id is
+        retained as a compatibility fallback for older prompt outputs.
+        """
+        if 0 <= raw_id < len(existing_by_position):
+            existing = existing_by_position.get(f"EXISTING-{raw_id}")
+            if existing is not None:
+                return existing
+        return existing_by_id.get(raw_id)
+
     @staticmethod
     def _bump_counter(result: PlaybookConsolidationResult, kind: str) -> None:
         """Increment the per-kind counter on ``result`` for a successful apply.
@@ -987,6 +1088,7 @@ class PlaybookConsolidator(BaseDeduplicator):
         decision: ConsolidationDecision,
         candidates_by_id: dict[str, UserPlaybook],
         existing_by_id: dict[int, UserPlaybook],
+        existing_by_position: dict[str, UserPlaybook],
     ) -> None:
         """Emit a structured per-decision log line for probe ingest.
 
@@ -1029,7 +1131,11 @@ class PlaybookConsolidator(BaseDeduplicator):
             "existing_id",
             getattr(decision, "superseded_by_existing_id", 0),
         )
-        existing_pb = existing_by_id.get(existing_id_raw)
+        existing_pb = PlaybookConsolidator._resolve_existing_reference(
+            existing_id_raw,
+            existing_by_position=existing_by_position,
+            existing_by_id=existing_by_id,
+        )
         trigger_match = (
             new_pb is not None
             and existing_pb is not None

package/plugin/vendor/reflexio/reflexio/server/services/playbook/{playbook_extractor.py → components/extractor.py}

@@ -10,6 +10,7 @@ from reflexio.models.config_schema import PlaybookConfig
 from reflexio.server.api_endpoints.request_context import RequestContext
 from reflexio.server.llm.litellm_client import LiteLLMClient
 from reflexio.server.llm.model_defaults import ModelRole, resolve_model_name
+from reflexio.server.llm.token_accounting import RunTokenTotals, sum_trace_tokens
 from reflexio.server.services.extraction.outcome import ExtractionOutcome
 from reflexio.server.services.extraction.resumable_agent import (
     run_resumable_extraction_agent,
@@ -35,7 +36,7 @@ from reflexio.server.services.service_utils import (
 from reflexio.server.site_var.site_var_manager import SiteVarManager
 
 if TYPE_CHECKING:
-    from reflexio.server.services.playbook.playbook_generation_service import (
+    from reflexio.server.services.playbook.service import (
         PlaybookGenerationServiceConfig,
     )
 
@@ -79,6 +80,7 @@ class PlaybookExtractor:
         self.service_config: PlaybookGenerationServiceConfig = service_config
         self.agent_context: str = agent_context
         self._last_resumable_run_id: str | None = None
+        self._last_resumable_token_totals: RunTokenTotals | None = None
 
         # Get LLM config overrides from configuration
         config = self.request_context.configurator.get_config()
@@ -223,6 +225,7 @@ class PlaybookExtractor:
             return ExtractionOutcome.completed(
                 user_playbooks,
                 run_id=self._last_resumable_run_id,
+                token_totals=self._last_resumable_token_totals,
             )
         return user_playbooks
 
@@ -318,6 +321,7 @@ class PlaybookExtractor:
             log_label="Playbook extraction",
         )
         self._last_resumable_run_id = result.run_id
+        self._last_resumable_token_totals = sum_trace_tokens(result.trace)
         if not isinstance(result.output, StructuredPlaybookList):
             logger.warning(
                 "Playbook extraction did not finish: %s",

package/plugin/vendor/reflexio/reflexio/server/services/playbook/playbook_edit_apply.py

@@ -0,0 +1,74 @@
+"""Shared atomic supersede primitive for applying a playbook edit.
+
+Extracted from ReflectionService._replace_playbook so online and background
+playbook repair paths share one lifecycle (insert-then-supersede, no orphan).
+"""
+
+from typing import TYPE_CHECKING
+
+from reflexio.models.api_schema.domain.entities import LineageContext, UserPlaybook
+
+if TYPE_CHECKING:
+    from reflexio.server.services.storage.storage_base import BaseStorage
+
+
+def apply_playbook_edit(
+    storage: "BaseStorage",
+    *,
+    incumbent_id: int,
+    new_playbook: UserPlaybook,
+    source: str,
+    request_id: str,
+) -> int:
+    """Insert a replacement playbook then atomically supersede the incumbent.
+
+    Uses ``storage.supersede_record`` (atomic conditional CAS) so a lost race
+    never leaves an orphan CURRENT row:
+
+    - Insert the new playbook as CURRENT.
+    - Call ``supersede_record(incumbent_id → new_id)``, which only succeeds when
+      the incumbent is still CURRENT (``status IS NULL``).
+    - If ``supersede_record`` returns ``False`` (incumbent already gone), delete
+      the just-inserted successor and return ``-1``.
+
+    Args:
+        storage: A BaseStorage instance providing ``save_user_playbooks``,
+            ``supersede_record``, and ``delete_user_playbooks_by_ids``.
+        incumbent_id: ``user_playbook_id`` of the playbook being replaced.
+        new_playbook: The replacement playbook (inserted as CURRENT, i.e.
+            ``status=None``).
+        source: Provenance label stored on the new playbook row and in the
+            lineage event actor field.
+        request_id: Operation-run correlation id for the lineage event. Must be
+            non-empty; use the reflection run id (``ReflectionServiceRequest.request_id``)
+            or another operation-scoped id. Raises ``ValueError`` immediately
+            (before any storage write) when empty, preventing orphaned successor rows.
+
+    Returns:
+        The ``user_playbook_id`` of the newly inserted playbook, or ``-1`` if
+        the incumbent was not CURRENT (no mutation; no orphan left behind).
+
+    Raises:
+        ValueError: If ``request_id`` is empty or None.
+    """
+    if not request_id:
+        raise ValueError(
+            "apply_playbook_edit: request_id must be non-empty (operation-run correlation id)"
+        )
+    new_playbook.source = source
+    storage.save_user_playbooks([new_playbook])
+    new_id: int = new_playbook.user_playbook_id
+
+    ctx = LineageContext(op_kind="revise", actor=source, request_id=request_id)
+    superseded = storage.supersede_record(
+        entity_type="user_playbook",
+        incumbent_id=str(incumbent_id),
+        successor_id=str(new_id),
+        context=ctx,
+    )
+    if not superseded:
+        # lost the race: delete the just-inserted successor so no orphan CURRENT row
+        # remains. It was never live, so this is a rollback — not an audited erasure.
+        storage.delete_user_playbooks_by_ids([new_id], emit_hard_delete=False)
+        return -1
+    return new_id