RGI

class SituationAnalyzer:
    """Station ②: assemble cross-system context → factor vector.
    Q-routed investigation — decides WHICH evidence and WHEN to stop."""

    async def assemble(self, entity_id: str) -> SituationContext:
        graph_ctx = await self._graph_store.get_context(entity_id)
        erp_ctx = await self._sap_connector.get_entity(entity_id)
        process_ctx = await self._celonis_connector.get_activities(entity_id)
        ctx = SituationContext(graph=graph_ctx, erp=erp_ctx, process=process_ctx)
        ctx.factors = self._extract_factors(ctx)
        ctx.category = self._classify(ctx.factors)
        return ctx

    def select_investigation(self, v, category) -> List[str]:
        """Q-routed: precision × leverage × discriminative.
        System reads the most informative evidence first."""
        q_values = {
            j: self._precision(j,v,category) * self._leverage(j,v,category)
               * self._discriminative(j,v,category)
            for j in self._available_factors
        }
        # Sorted by Q — top factors read first, stop when marginal Q drops
        return sorted(q_values, key=q_values.get, reverse=True)

class ConservationGate:
    """Station ⑧: three layers, all fixed at deployment approval.
    Learning cannot alter them. The gate protects the geometry."""

    def check(self, old_centroids, new_centroids, category) -> GateResult:
        α = self._current_phase()
        V = self.tensor_volume  # d × c × a

        # Layer 1: sufficient verified volume (α·q·V must exceed θ_min)
        if α * self._q * V < self.θ_min:
            return GateResult(passed=False, reason="insufficient_volume")

        # Displacement ceiling: centroid shift must stay within bounds
        disp = np.linalg.norm(new_centroids[category] - old_centroids[category])
        max_disp = 23.53 / (α * V)
        if disp > max_disp:
            return GateResult(passed=False, reason="displacement_exceeded")

        # Layer 2: per-factor displacement (no single factor drifts too far)
        for j in range(len(new_centroids[category])):
            δ_j = abs(new_centroids[category][j] - old_centroids[category][j])
            if δ_j > 0.7 * disp:  # m_rel = 0.7×
                return GateResult(passed=False, reason=f"per_factor_{j}")

        # Layer 3: rate of change (sudden shifts trigger pause)
        rate_short = self._rate(window=20)
        rate_long = self._rate(window=self._q)
        if rate_short > 1.15 * rate_long:  # short-window 15% above long = regime shift
            return GateResult(passed=False, reason="rate_of_change")

        return GateResult(passed=True, displacement=disp)

    # Per-deployment floors (not global):
    # SOC: 0.764 (20:1)  DataOps: 0.669 (10:1)  S2P: 0.769 (5:1)
    # Purchasing: 0.655 (3:1)  Trading: 0.766 (2:1)

class GraphStore(Protocol):
    """45-method protocol. THE storage abstraction.
    3 backends: InMemory (test), SQLite (dev), AGE (prod).
    258 dedicated tests. Zero DecisionStore imports."""

    # Decision lifecycle
    def save_decision(self, decision: Decision) -> str: ...
    def save_outcome(self, decision_id: str, outcome: Outcome) -> None: ...
    def get_decisions(self, category: str, limit: int) -> List[Decision]: ...

    # Centroid geometry (judgment memory)
    def save_centroids(self, category: str, centroids: np.ndarray) -> None: ...
    def get_centroids(self, category: str) -> Optional[np.ndarray]: ...

    # Cross-graph attention (discovery)
    def get_context(self, entity_id: str) -> GraphContext: ...
    def traverse(self, start: str, edge_types: List[str],
                 max_depth: int = 3) -> List[Path]: ...

    # Evolution (AgentEvolver)
    def save_evolution(self, domain: str, key: str, payload: dict) -> None: ...
    def get_evolution_log(self, domain: str) -> List[EvolutionEntry]: ...