claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/server/services/lineage/resolve.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from reflexio.models.api_schema.domain.entities import RecordRef
+from reflexio.server.tracing import capture_anomaly
+
+EntityType = Literal["user_playbook", "agent_playbook", "profile"]
+
+_GETTER = {
+    "user_playbook": lambda s, i: s.get_user_playbook_by_id(
+        int(i), include_tombstones=True
+    ),
+    "agent_playbook": lambda s, i: s.get_agent_playbook_by_id(
+        int(i), include_tombstones=True
+    ),
+    "profile": lambda s, i: s.get_profile_by_id(str(i), include_tombstones=True),
+}
+_MAX_HOPS = 8  # Phase A: chains are 1-hop; cap guards malformed pointers
+
+
+def resolve_current(
+    storage: Any, entity_type: EntityType, record_id: Any
+) -> RecordRef | None:
+    """Follow merged_into/superseded_by pointers to the live survivor.
+
+    **Consumer contract:** if the returned ``RecordRef.is_purged`` is ``True``,
+    the survivor's content body has been blanked by ``purge_content`` (GDPR/erasure).
+    Any consumer that dereferences the resolved record's content MUST skip or treat
+    the record as absent when ``is_purged=True`` — reading blank content as if it
+    were valid data is a silent bug.
+
+    Args:
+        storage: Any storage backend exposing get_*_by_id with include_tombstones.
+        entity_type: One of "user_playbook", "agent_playbook", "profile".
+        record_id: The primary key of the record to resolve (int for playbooks, str for profiles).
+
+    Returns:
+        RecordRef pointing to the live survivor (is_purged=True if its body is blank),
+        or None if the record doesn't exist, there's a cycle, or the chain exceeds _MAX_HOPS.
+
+    Raises:
+        ValueError: If ``entity_type`` is not a recognized entity type.
+    """
+    get = _GETTER.get(entity_type)
+    if get is None:
+        raise ValueError(f"unknown entity_type: {entity_type!r}")
+    visited: set[str] = set()
+    cur = get(storage, record_id)
+    if cur is None:
+        return None
+    while True:
+        cur_id = str(_pk(cur, entity_type))
+        if cur_id in visited or len(visited) >= _MAX_HOPS:
+            # A cycle or an over-long chain means a malformed pointer graph;
+            # we return None (callers treat as unresolvable) but surface it to
+            # Sentry so the otherwise-silent breakage is observable.
+            reason = "cycle" if cur_id in visited else "max_hops_exceeded"
+            capture_anomaly(
+                f"lineage.resolve_current.{reason}",
+                entity_type=entity_type,
+                entity_id=str(record_id),
+                hops=len(visited),
+            )
+            return None  # cycle or runaway chain
+        visited.add(cur_id)
+        nxt = cur.merged_into if cur.merged_into is not None else cur.superseded_by
+        if nxt is None:
+            return RecordRef(id=cur_id, is_purged=(not cur.content))
+        nxt_row = get(storage, nxt)
+        if nxt_row is None:
+            return RecordRef(
+                id=cur_id, is_purged=(not cur.content)
+            )  # dangling pointer — stop here
+        cur = nxt_row
+
+
+def _pk(row: Any, entity_type: EntityType) -> Any:
+    """Extract the primary key from a row based on its entity type.
+
+    Args:
+        row: The entity row object.
+        entity_type: One of "user_playbook", "agent_playbook", "profile".
+
+    Returns:
+        The primary key value.
+
+    Raises:
+        ValueError: If ``entity_type`` is not a recognized entity type.
+    """
+    pk = {
+        "user_playbook": "user_playbook_id",
+        "agent_playbook": "agent_playbook_id",
+        "profile": "profile_id",
+    }.get(entity_type)
+    if pk is None:
+        raise ValueError(f"unknown entity_type: {entity_type!r}")
+    return getattr(row, pk)

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

@@ -535,6 +535,32 @@ class OperationStateManager:
             state_key,
         )
 
+    def clear_lock_if_owner(
+        self,
+        request_id: str,
+        scope_id: str | None = None,
+    ) -> bool:
+        """Atomically clear a lock only if ``request_id`` still owns it."""
+        state_key = self._lock_key(scope_id)
+        cleared = self.storage.clear_in_progress_lock_if_owner(
+            state_key,
+            request_id,
+            {
+                "in_progress": False,
+                "current_request_id": None,
+                "pending_request_id": None,
+                "pending_request_queue": [],
+            },
+        )
+        if cleared:
+            logger.debug(
+                "Cleared in-progress lock for %s: state_key=%s, request_id=%s",
+                self.service_name,
+                state_key,
+                request_id,
+            )
+        return cleared
+
     def release_lock_pop_queue(
         self,
         request_id: str,

package/plugin/vendor/reflexio/reflexio/server/services/playbook/README.md

@@ -5,10 +5,10 @@ Description: Playbook extraction, aggregation, and consolidation pipeline
 
 ## Main Entry Points
 
-- **Service Orchestrator**: `playbook_generation_service.py` - Manages playbook extraction lifecycle (regular, rerun, manual modes)
-- **Playbook Extractor**: `playbook_extractor.py` - Extracts user playbooks from interactions via LLM
-- **Playbook Aggregator**: `playbook_aggregator.py` - Clusters similar user playbooks and generates aggregated insights
-- **Playbook Consolidator**: `playbook_consolidator.py` - Reconciles newly extracted playbooks against existing storage via LLM. Decides per pair to merge as duplicates, prefer the new entry, prefer the existing entry, differentiate (split with refined triggers), or keep both as independent
+- **Service Orchestrator**: `service.py` - Manages playbook extraction lifecycle (regular, rerun, manual modes)
+- **Playbook Extractor**: `components/extractor.py` - Extracts user playbooks from interactions via LLM
+- **Playbook Aggregator**: `components/aggregator.py` - Clusters similar user playbooks and generates aggregated insights
+- **Playbook Consolidator**: `components/consolidator.py` - Reconciles newly extracted playbooks against existing storage via LLM. Decides per pair to merge as duplicates, prefer the new entry, prefer the existing entry, differentiate (split with refined triggers), or keep both as independent
 
 ## Supporting Files
 
@@ -16,6 +16,7 @@ Description: Playbook extraction, aggregation, and consolidation pipeline
 |------|---------|
 | `playbook_service_constants.py` | Prompt IDs for all playbook operations |
 | `playbook_service_utils.py` | Request dataclasses, Pydantic output schemas, message construction utilities |
+| `aggregation_prompt_processing.py` | Optional aggregation-boundary interfaces and helpers for prompt preprocessing, contextual prompt guidance, and output post-processing |
 
 ## Architecture
 
@@ -30,7 +31,7 @@ Interactions
           -> AgentPlaybook (aggregated insights) -> Storage
 ```
 
-### Playbook Extraction (`playbook_extractor.py`)
+### Playbook Extraction (`components/extractor.py`)
 
 Extends `BaseGenerationService` extractor pattern. Each extractor:
 1. Checks stride_size threshold before running
@@ -41,20 +42,26 @@ Extends `BaseGenerationService` extractor pattern. Each extractor:
 
 **Tool Analysis**: Reads `tool_can_use` from root `Config` for tool usage analysis and blocking issue detection.
 
-### Playbook Aggregation (`playbook_aggregator.py`)
+### Playbook Aggregation (`components/aggregator.py`)
 
 Triggered manually via `/api/run_playbook_aggregation`. Clusters user playbooks and generates consolidated insights.
 
 **Key Methods**:
 - `get_clusters(user_playbooks, config)` - HDBSCAN/Agglomerative clustering on embeddings
 - `aggregate()` - Full aggregation pipeline with LLM-based consolidation
-- `_build_change_log()` - Builds `PlaybookAggregationChangeLog` with before/after snapshots (added/removed/updated playbooks)
 
-**Change Log**: After each aggregation, saves a `PlaybookAggregationChangeLog` to storage. In full_archive mode, all old playbooks are "removed" and new ones "added". In incremental mode, maps old->new via fingerprints to detect updates. Saving is best-effort (failures logged, don't block aggregation).
+**Optional prompt processing**: deployments can register an
+`AggregationPromptProcessor` via the `AGGREGATION_PROMPT_PROCESSOR` ServiceKey
+(`register_service`). The aggregator applies the processor only at the
+aggregation prompt boundary, carries an opaque per-cluster processing context,
+injects extra prompt guidance only when preprocessing changed prompt input, and
+post-processes generated outputs before storage or model-response logging.
+
+**Change Log**: The legacy `playbook_aggregation_change_logs` table is retired (Track B, 2026-06-24) — the aggregator no longer writes it. The change-log view is reconstructed on demand from `lineage_event` via `reconstruct_playbook_aggregation_change_log` (`lib/_agent_playbook.py`): each run emits `op=aggregate` events (the "added" side) and `status_change→superseded` events from the supersede calls (the "removed" side), grouped by the run's `request_id`. Per-row `updated` pairing is not reconstructed (`updated_agent_playbooks=[]`, a tolerated parity delta).
 
 **Clustering**: Embeds user playbooks -> HDBSCAN clustering -> falls back to Agglomerative if too few clusters
 
-### Playbook Consolidation (`playbook_consolidator.py`)
+### Playbook Consolidation (`components/consolidator.py`)
 
 Consolidates newly extracted playbooks against existing playbooks in the database via LLM semantic matching. For each NEW vs EXISTING pair the LLM returns one of five decision kinds, and the consolidator applies the chosen kind:
 
@@ -70,10 +77,10 @@ A safety fallback inserts any new candidate that no decision consumed, so extrac
 
 | Constant | Prompt ID | Used By |
 |----------|-----------|---------|
-| `PLAYBOOK_EXTRACTION_SHOULD_GENERATE_PROMPT_ID` | `playbook_should_generate` | PlaybookExtractor |
+| `PLAYBOOK_SHOULD_GENERATE_PROMPT_ID` | `playbook_should_generate` | PlaybookExtractor |
 | `PLAYBOOK_EXTRACTION_CONTEXT_PROMPT_ID` | `playbook_extraction_context` | PlaybookExtractor |
 | `PLAYBOOK_EXTRACTION_PROMPT_ID` | `playbook_extraction_main` | PlaybookExtractor |
-| `PLAYBOOK_GENERATION_PROMPT_ID` | `playbook_generation` | PlaybookAggregator |
+| `PLAYBOOK_AGGREGATION_PROMPT_ID` | `playbook_aggregation` | PlaybookAggregator |
 
 ## Key Output Schemas (in `playbook_service_utils.py`)
 

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

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Protocol
+
+from reflexio.server.extensions import ServiceKey
+
+
+@dataclass
+class AggregationPromptProcessingContext:
+    """Per-cluster state shared across aggregation prompt-processing hooks.
+
+    ``changed`` controls whether contextual prompt guidance is requested.
+    ``data`` is an opaque deployment-owned mapping. The aggregator initializes
+    ``agent_version`` and ``org_id`` keys when those values are available.
+    """
+
+    changed: bool = False
+    data: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class PromptPreprocessResult:
+    text: str
+    changed: bool = False
+
+
+@dataclass(frozen=True)
+class PromptPostprocessResult:
+    value: object
+    artifacts_removed: int = 0
+
+
+class AggregationPromptProcessor(Protocol):
+    """Optional deployment hook for the playbook aggregation boundary.
+
+    Implementations may transform prompt text before the aggregation LLM call,
+    provide contextual prompt instructions when preprocessing changed prompt
+    input, and post-process aggregation output before storage or response
+    logging. Deployments supply one by registering it via the
+    ``AGGREGATION_PROMPT_PROCESSOR`` ServiceKey (``register_service``).
+    """
+
+    def preprocess_prompt_text(
+        self,
+        text: str,
+        *,
+        shared_state: dict[str, Any] | None = None,
+        context: AggregationPromptProcessingContext | None = None,
+    ) -> PromptPreprocessResult:
+        """Return text to send to the aggregation prompt."""
+        ...
+
+    def prompt_instructions(
+        self,
+        context: AggregationPromptProcessingContext,
+    ) -> str | None:
+        """Return extra prompt guidance for this aggregation context, if any."""
+        ...
+
+    def postprocess_aggregation_output(
+        self,
+        value: object,
+        *,
+        context: AggregationPromptProcessingContext | None = None,
+    ) -> PromptPostprocessResult:
+        """Return output to store or log after the aggregation LLM call."""
+        ...
+
+
+class PassthroughPromptProcessor:
+    def preprocess_prompt_text(
+        self,
+        text: str,
+        *,
+        shared_state: dict[str, Any] | None = None,  # noqa: ARG002
+        context: AggregationPromptProcessingContext | None = None,  # noqa: ARG002
+    ) -> PromptPreprocessResult:
+        return PromptPreprocessResult(text=text)
+
+    def prompt_instructions(
+        self,
+        context: AggregationPromptProcessingContext,  # noqa: ARG002
+    ) -> str | None:
+        return None
+
+    def postprocess_aggregation_output(
+        self,
+        value: object,
+        *,
+        context: AggregationPromptProcessingContext | None = None,  # noqa: ARG002
+    ) -> PromptPostprocessResult:
+        return PromptPostprocessResult(value=value)
+
+
+# Singleton runtime-service key (round-5 RD-NEC-002): one processor registered at
+# the enterprise composition root; None in local OSS (passthrough, no redaction).
+AGGREGATION_PROMPT_PROCESSOR: ServiceKey[AggregationPromptProcessor] = ServiceKey(
+    "aggregation_prompt_processor"
+)

package/plugin/vendor/reflexio/reflexio/server/services/playbook/components/__init__.py

@@ -0,0 +1,5 @@
+"""Playbook service components.
+
+Import component classes from their concrete modules. Keeping this package
+import-free preserves the lazy consolidator import in the generation service.
+"""