truthound-dashboard 1.4.4__py3-none-any.whl → 1.5.1__py3-none-any.whl

truthound_dashboard/core/notifications/channels.py

@@ -1,29 +1,39 @@
-"""Notification channel implementations.
-
-This module provides concrete implementations of notification channels
-for various notification services:
-
-- Slack: Incoming webhooks
-- Email: SMTP
-- Webhook: Generic HTTP endpoints
-- Discord: Discord webhooks
-- Telegram: Telegram Bot API
-- PagerDuty: Events API v2
-- OpsGenie: Alert API
-- Teams: Microsoft Teams webhooks
-- GitHub: Issues/Discussions API
-
-Each channel is registered with the ChannelRegistry and can be
-instantiated dynamically based on channel type.
+"""Notification channel implementations using truthound library.
+
+This module provides channel implementations that wrap truthound's
+checkpoint.actions module for notification delivery.
+
+Available channels (from truthound.checkpoint.actions):
+- Slack: SlackNotification
+- Email: EmailNotification
+- Teams: TeamsNotification
+- Discord: DiscordNotification
+- Telegram: TelegramNotification
+- PagerDuty: PagerDutyAction
+- Webhook: WebhookAction
+
+Each channel is registered with the ChannelRegistry and delegates
+actual notification delivery to the corresponding truthound action.
 """
 
 from __future__ import annotations
 
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
+import asyncio
+import logging
+from dataclasses import dataclass
 from typing import Any
 
-import httpx
+from truthound.checkpoint.actions import (
+    SlackNotification,
+    EmailNotification,
+    TeamsNotification,
+    DiscordNotification,
+    TelegramNotification,
+    PagerDutyAction,
+    OpsGenieAction,
+    WebhookAction,
+    GitHubAction,
+)
 
 from .base import (
     BaseNotificationChannel,
@@ -38,22 +48,114 @@ from .events import (
     ValidationFailedEvent,
 )
 
+logger = logging.getLogger(__name__)
+
+
+def _build_checkpoint_result_mock(event: NotificationEvent | None) -> Any:
+    """Build a mock CheckpointResult for truthound actions.
+
+    truthound actions expect a CheckpointResult object. We create a
+    minimal mock that provides the necessary attributes.
+    """
+    @dataclass
+    class MockStatistics:
+        total_issues: int = 0
+        critical_issues: int = 0
+        high_issues: int = 0
+        medium_issues: int = 0
+        low_issues: int = 0
+        info_issues: int = 0
+        pass_rate: float = 100.0
+
+    @dataclass
+    class MockValidationResult:
+        statistics: MockStatistics
+        error: str | None = None
+
+    @dataclass
+    class MockCheckpointResult:
+        checkpoint_name: str
+        run_id: str
+        status: str
+        data_asset: str
+        validation_result: MockValidationResult
+        duration_ms: float = 0.0
+
+        def summary(self) -> str:
+            return f"{self.checkpoint_name}: {self.status}"
+
+    if event is None:
+        return MockCheckpointResult(
+            checkpoint_name="test",
+            run_id="test-run",
+            status="success",
+            data_asset="test",
+            validation_result=MockValidationResult(statistics=MockStatistics()),
+        )
+
+    # Extract data from event
+    data = event.data or {}
+
+    if isinstance(event, ValidationFailedEvent):
+        return MockCheckpointResult(
+            checkpoint_name=event.source_name or "validation",
+            run_id=data.get("validation_id", "unknown"),
+            status="failure",
+            data_asset=event.source_name or "unknown",
+            validation_result=MockValidationResult(
+                statistics=MockStatistics(
+                    total_issues=data.get("total_issues", 0),
+                    critical_issues=1 if data.get("has_critical") else 0,
+                    high_issues=1 if data.get("has_high") else 0,
+                )
+            ),
+        )
+    elif isinstance(event, DriftDetectedEvent):
+        return MockCheckpointResult(
+            checkpoint_name=f"drift_{event.source_name or 'unknown'}",
+            run_id=data.get("comparison_id", "unknown"),
+            status="warning",
+            data_asset=event.source_name or "unknown",
+            validation_result=MockValidationResult(statistics=MockStatistics()),
+        )
+    elif isinstance(event, ScheduleFailedEvent):
+        return MockCheckpointResult(
+            checkpoint_name=data.get("schedule_name", "schedule"),
+            run_id=data.get("run_id", "unknown"),
+            status="error",
+            data_asset=event.source_name or "unknown",
+            validation_result=MockValidationResult(
+                statistics=MockStatistics(),
+                error=data.get("error_message"),
+            ),
+        )
+    else:
+        return MockCheckpointResult(
+            checkpoint_name=event.event_type,
+            run_id="dashboard-event",
+            status="info",
+            data_asset=event.source_name or "unknown",
+            validation_result=MockValidationResult(statistics=MockStatistics()),
+        )
+
 
 @ChannelRegistry.register("slack")
 class SlackChannel(BaseNotificationChannel):
-    """Slack notification channel using incoming webhooks.
+    """Slack notification channel using truthound.checkpoint.actions.SlackNotification.
 
     Configuration:
-        webhook_url: Slack incoming webhook URL
+        webhook_url: Slack incoming webhook URL (required)
         channel: Optional channel override
         username: Optional username override
         icon_emoji: Optional emoji icon (e.g., ":robot:")
+        mention_on_failure: List of user IDs to mention on failure
 
     Example config:
         {
             "webhook_url": "https://hooks.slack.com/services/...",
             "username": "Truthound Bot",
-            "icon_emoji": ":bar_chart:"
+            "icon_emoji": ":bar_chart:",
+            "channel": "#data-quality"
         }
     """
 
@@ -83,156 +185,67 @@ class SlackChannel(BaseNotificationChannel):
                 "required": False,
                 "description": "Emoji icon (e.g., :robot:)",
             },
+            "mention_on_failure": {
+                "type": "array",
+                "required": False,
+                "description": "User IDs to mention on failure",
+            },
         }
 
+    def _create_action(self) -> SlackNotification:
+        """Create truthound SlackNotification action."""
+        return SlackNotification(
+            webhook_url=self.config["webhook_url"],
+            channel=self.config.get("channel"),
+            username=self.config.get("username", "Truthound Dashboard"),
+            icon_emoji=self.config.get("icon_emoji", ":bar_chart:"),
+            mention_on_failure=self.config.get("mention_on_failure", []),
+            include_details=True,
+            notify_on="always",  # Dashboard handles when to send
+        )
+
     async def send(
         self,
         message: str,
         event: NotificationEvent | None = None,
         **kwargs: Any,
     ) -> bool:
-        """Send notification to Slack.
-
-        Args:
-            message: Message text (supports Slack markdown).
-            event: Optional triggering event.
-            **kwargs: Additional Slack message options.
-
-        Returns:
-            True if message was sent successfully.
-        """
-        webhook_url = self.config["webhook_url"]
-
-        # Build payload
-        payload: dict[str, Any] = {
-            "text": message,
-        }
-
-        # Add blocks for rich formatting
-        blocks = self._build_blocks(message, event)
-        if blocks:
-            payload["blocks"] = blocks
-
-        # Add optional overrides
-        if self.config.get("channel"):
-            payload["channel"] = self.config["channel"]
-        if self.config.get("username"):
-            payload["username"] = self.config["username"]
-        if self.config.get("icon_emoji"):
-            payload["icon_emoji"] = self.config["icon_emoji"]
-
-        # Merge any additional kwargs
-        payload.update(kwargs)
-
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(webhook_url, json=payload)
-            return response.status_code == 200
-
-    def _build_blocks(
-        self,
-        message: str,
-        event: NotificationEvent | None,
-    ) -> list[dict[str, Any]]:
-        """Build Slack blocks for rich message formatting."""
-        blocks = []
-
-        # Main message section
-        blocks.append(
-            {
-                "type": "section",
-                "text": {"type": "mrkdwn", "text": message},
-            }
-        )
+        """Send notification to Slack using truthound library."""
+        try:
+            action = self._create_action()
+            mock_result = _build_checkpoint_result_mock(event)
 
-        # Add context for specific event types
-        if isinstance(event, ValidationFailedEvent):
-            context_elements = [
-                {"type": "mrkdwn", "text": f"*Severity:* {event.severity}"},
-                {"type": "mrkdwn", "text": f"*Issues:* {event.total_issues}"},
-            ]
-            if event.validation_id:
-                context_elements.append(
-                    {"type": "mrkdwn", "text": f"*ID:* `{event.validation_id[:8]}...`"}
-                )
-            blocks.append({"type": "context", "elements": context_elements})
-
-        elif isinstance(event, DriftDetectedEvent):
-            context_elements = [
-                {
-                    "type": "mrkdwn",
-                    "text": f"*Drift:* {event.drifted_columns}/{event.total_columns} columns",
-                },
-                {
-                    "type": "mrkdwn",
-                    "text": f"*Percentage:* {event.drift_percentage:.1f}%",
-                },
-            ]
-            blocks.append({"type": "context", "elements": context_elements})
-
-        return blocks
+            # truthound actions are sync, run in executor
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, action.execute, mock_result)
+            return True
+        except Exception as e:
+            logger.error(f"Slack notification failed: {e}")
+            return False
 
     def format_message(self, event: NotificationEvent) -> str:
-        """Format message for Slack with mrkdwn syntax."""
-        if isinstance(event, ValidationFailedEvent):
-            emoji = ":rotating_light:" if event.has_critical else ":warning:"
-            return (
-                f"{emoji} *Validation Failed*\n\n"
-                f"*Source:* {event.source_name or 'Unknown'}\n"
-                f"*Severity:* {event.severity}\n"
-                f"*Total Issues:* {event.total_issues}"
-            )
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return (
-                f":clock1: *Scheduled Validation Failed*\n\n"
-                f"*Schedule:* {event.schedule_name}\n"
-                f"*Source:* {event.source_name or 'Unknown'}\n"
-                f"*Error:* {event.error_message or 'Validation failed'}"
-            )
-
-        elif isinstance(event, DriftDetectedEvent):
-            emoji = ":chart_with_upwards_trend:" if event.has_high_drift else ":chart_with_downwards_trend:"
-            return (
-                f"{emoji} *Drift Detected*\n\n"
-                f"*Baseline:* {event.baseline_source_name}\n"
-                f"*Current:* {event.current_source_name}\n"
-                f"*Drifted Columns:* {event.drifted_columns}/{event.total_columns} "
-                f"({event.drift_percentage:.1f}%)"
-            )
-
-        elif isinstance(event, TestNotificationEvent):
-            return (
-                f":white_check_mark: *Test Notification*\n\n"
-                f"This is a test from truthound-dashboard.\n"
-                f"Channel: {event.channel_name}"
-            )
-
-        return self._default_format(event)
+        """Format message for Slack."""
+        if isinstance(event, TestNotificationEvent):
+            return f"✅ *Test Notification* from truthound-dashboard\nChannel: {event.channel_name}"
+        return super().format_message(event)
 
 
 @ChannelRegistry.register("email")
 class EmailChannel(BaseNotificationChannel):
-    """Email notification channel using SMTP.
+    """Email notification channel using truthound.checkpoint.actions.EmailNotification.
 
     Configuration:
-        smtp_host: SMTP server hostname
+        smtp_host: SMTP server host (required)
         smtp_port: SMTP server port (default: 587)
-        smtp_username: SMTP authentication username
+        smtp_user: SMTP authentication user
         smtp_password: SMTP authentication password
-        from_email: Sender email address
-        recipients: List of recipient email addresses
-        use_tls: Whether to use TLS (default: True)
-
-    Example config:
-        {
-            "smtp_host": "smtp.gmail.com",
-            "smtp_port": 587,
-            "smtp_username": "user@gmail.com",
-            "smtp_password": "app-password",
-            "from_email": "alerts@example.com",
-            "recipients": ["admin@example.com"],
-            "use_tls": true
-        }
+        use_tls: Use TLS (default: true)
+        use_ssl: Use SSL (default: false)
+        from_address: Sender email address (required)
+        to_addresses: List of recipient addresses (required)
+        cc_addresses: List of CC addresses
+        provider: Email provider (smtp, sendgrid, ses)
+        api_key: API key for SendGrid/SES
     """
 
     channel_type = "email"
@@ -243,346 +256,169 @@ class EmailChannel(BaseNotificationChannel):
         return {
             "smtp_host": {
                 "type": "string",
-                "required": True,
-                "description": "SMTP server hostname",
+                "required": False,
+                "description": "SMTP server host",
             },
             "smtp_port": {
                 "type": "integer",
                 "required": False,
-                "default": 587,
-                "description": "SMTP server port",
+                "description": "SMTP server port (default: 587)",
             },
-            "smtp_username": {
+            "smtp_user": {
                 "type": "string",
                 "required": False,
-                "description": "SMTP authentication username",
+                "description": "SMTP authentication user",
             },
             "smtp_password": {
                 "type": "string",
                 "required": False,
-                "secret": True,
                 "description": "SMTP authentication password",
             },
-            "from_email": {
+            "use_tls": {
+                "type": "boolean",
+                "required": False,
+                "description": "Use TLS encryption",
+            },
+            "use_ssl": {
+                "type": "boolean",
+                "required": False,
+                "description": "Use SSL encryption",
+            },
+            "from_address": {
                 "type": "string",
                 "required": True,
                 "description": "Sender email address",
             },
-            "recipients": {
+            "to_addresses": {
                 "type": "array",
                 "required": True,
-                "items": {"type": "string"},
                 "description": "List of recipient email addresses",
             },
-            "use_tls": {
-                "type": "boolean",
+            "cc_addresses": {
+                "type": "array",
                 "required": False,
-                "default": True,
-                "description": "Use TLS encryption",
+                "description": "List of CC email addresses",
+            },
+            "provider": {
+                "type": "string",
+                "required": False,
+                "description": "Email provider: smtp, sendgrid, ses",
+            },
+            "api_key": {
+                "type": "string",
+                "required": False,
+                "description": "API key for SendGrid/SES",
             },
         }
 
+    def _create_action(self) -> EmailNotification:
+        """Create truthound EmailNotification action."""
+        return EmailNotification(
+            smtp_host=self.config.get("smtp_host", "localhost"),
+            smtp_port=self.config.get("smtp_port", 587),
+            smtp_user=self.config.get("smtp_user"),
+            smtp_password=self.config.get("smtp_password"),
+            use_tls=self.config.get("use_tls", True),
+            use_ssl=self.config.get("use_ssl", False),
+            from_address=self.config["from_address"],
+            to_addresses=self.config["to_addresses"],
+            cc_addresses=self.config.get("cc_addresses", []),
+            provider=self.config.get("provider", "smtp"),
+            api_key=self.config.get("api_key"),
+            include_html=True,
+            notify_on="always",
+        )
+
     async def send(
         self,
         message: str,
         event: NotificationEvent | None = None,
-        subject: str | None = None,
         **kwargs: Any,
     ) -> bool:
-        """Send notification via email.
-
-        Args:
-            message: Email body text.
-            event: Optional triggering event (used for subject).
-            subject: Optional subject override.
-            **kwargs: Additional options.
-
-        Returns:
-            True if email was sent successfully.
-        """
+        """Send notification via Email using truthound library."""
         try:
-            import aiosmtplib
-        except ImportError:
-            raise ImportError(
-                "aiosmtplib is required for email notifications. "
-                "Install with: pip install aiosmtplib"
-            )
-
-        # Build subject
-        if subject is None:
-            subject = self._build_subject(event)
-
-        # Create message
-        msg = MIMEMultipart("alternative")
-        msg["Subject"] = subject
-        msg["From"] = self.config["from_email"]
-        msg["To"] = ", ".join(self.config["recipients"])
-
-        # Plain text version
-        text_part = MIMEText(message, "plain")
-        msg.attach(text_part)
-
-        # HTML version
-        html_content = self._build_html(message, event)
-        html_part = MIMEText(html_content, "html")
-        msg.attach(html_part)
-
-        # Send
-        await aiosmtplib.send(
-            msg,
-            hostname=self.config["smtp_host"],
-            port=self.config.get("smtp_port", 587),
-            username=self.config.get("smtp_username"),
-            password=self.config.get("smtp_password"),
-            use_tls=self.config.get("use_tls", True),
-        )
-
-        return True
-
-    def _build_subject(self, event: NotificationEvent | None) -> str:
-        """Build email subject from event."""
-        if event is None:
-            return "[Truthound] Notification"
-
-        if isinstance(event, ValidationFailedEvent):
-            severity = event.severity
-            return f"[Truthound] {severity} - Validation Failed: {event.source_name}"
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return f"[Truthound] Schedule Failed: {event.schedule_name}"
-
-        elif isinstance(event, DriftDetectedEvent):
-            return f"[Truthound] Drift Detected: {event.baseline_source_name} → {event.current_source_name}"
-
-        elif isinstance(event, TestNotificationEvent):
-            return "[Truthound] Test Notification"
-
-        return f"[Truthound] {event.event_type}"
-
-    def _build_html(self, message: str, event: NotificationEvent | None) -> str:
-        """Build HTML email body."""
-        # Convert newlines to <br> for simple HTML
-        html_message = message.replace("\n", "<br>")
-
-        return f"""
-        <!DOCTYPE html>
-        <html>
-        <head>
-            <style>
-                body {{ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; }}
-                .container {{ max-width: 600px; margin: 0 auto; padding: 20px; }}
-                .header {{ background: #fd9e4b; color: white; padding: 15px; border-radius: 5px 5px 0 0; }}
-                .content {{ background: #f9f9f9; padding: 20px; border: 1px solid #ddd; border-top: none; }}
-                .footer {{ font-size: 12px; color: #666; margin-top: 20px; }}
-            </style>
-        </head>
-        <body>
-            <div class="container">
-                <div class="header">
-                    <h2 style="margin: 0;">Truthound Dashboard</h2>
-                </div>
-                <div class="content">
-                    <p>{html_message}</p>
-                </div>
-                <div class="footer">
-                    <p>This notification was sent by Truthound Dashboard.</p>
-                </div>
-            </div>
-        </body>
-        </html>
-        """
-
-    def format_message(self, event: NotificationEvent) -> str:
-        """Format message for email (plain text)."""
-        if isinstance(event, ValidationFailedEvent):
-            return (
-                f"Validation Failed\n\n"
-                f"Source: {event.source_name or 'Unknown'}\n"
-                f"Severity: {event.severity}\n"
-                f"Total Issues: {event.total_issues}\n"
-                f"Validation ID: {event.validation_id}\n\n"
-                f"Please check the dashboard for details."
-            )
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return (
-                f"Scheduled Validation Failed\n\n"
-                f"Schedule: {event.schedule_name}\n"
-                f"Source: {event.source_name or 'Unknown'}\n"
-                f"Error: {event.error_message or 'Validation failed'}\n\n"
-                f"Please check the dashboard for details."
-            )
-
-        elif isinstance(event, DriftDetectedEvent):
-            return (
-                f"Drift Detected\n\n"
-                f"Baseline: {event.baseline_source_name}\n"
-                f"Current: {event.current_source_name}\n"
-                f"Drifted Columns: {event.drifted_columns}/{event.total_columns} "
-                f"({event.drift_percentage:.1f}%)\n\n"
-                f"Please check the dashboard for details."
-            )
-
-        elif isinstance(event, TestNotificationEvent):
-            return (
-                f"Test Notification\n\n"
-                f"This is a test notification from truthound-dashboard.\n"
-                f"Channel: {event.channel_name}\n\n"
-                f"If you received this, your email channel is configured correctly."
-            )
-
-        return self._default_format(event)
+            action = self._create_action()
+            mock_result = _build_checkpoint_result_mock(event)
 
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, action.execute, mock_result)
+            return True
+        except Exception as e:
+            logger.error(f"Email notification failed: {e}")
+            return False
 
-@ChannelRegistry.register("webhook")
-class WebhookChannel(BaseNotificationChannel):
-    """Generic webhook notification channel.
 
-    Sends JSON payloads to any HTTP endpoint.
+@ChannelRegistry.register("teams")
+class TeamsChannel(BaseNotificationChannel):
+    """Microsoft Teams notification channel using truthound.checkpoint.actions.TeamsNotification.
 
     Configuration:
-        url: Webhook endpoint URL
-        method: HTTP method (default: POST)
-        headers: Optional custom headers
-        include_event_data: Whether to include full event data (default: True)
-
-    Example config:
-        {
-            "url": "https://example.com/webhook",
-            "method": "POST",
-            "headers": {
-                "Authorization": "Bearer token",
-                "X-Custom-Header": "value"
-            }
-        }
+        webhook_url: Teams incoming webhook URL (required)
+        channel: Channel name for display
+        include_details: Include detailed information
     """
 
-    channel_type = "webhook"
+    channel_type = "teams"
 
     @classmethod
     def get_config_schema(cls) -> dict[str, Any]:
-        """Get Webhook channel configuration schema."""
+        """Get Teams channel configuration schema."""
         return {
-            "url": {
+            "webhook_url": {
                 "type": "string",
                 "required": True,
-                "description": "Webhook endpoint URL",
+                "description": "Teams incoming webhook URL",
             },
-            "method": {
+            "channel": {
                 "type": "string",
                 "required": False,
-                "default": "POST",
-                "description": "HTTP method (GET, POST, PUT)",
-            },
-            "headers": {
-                "type": "object",
-                "required": False,
-                "description": "Custom HTTP headers",
+                "description": "Channel name for display",
             },
-            "include_event_data": {
+            "include_details": {
                 "type": "boolean",
                 "required": False,
-                "default": True,
-                "description": "Include full event data in payload",
+                "description": "Include detailed statistics",
             },
         }
 
+    def _create_action(self) -> TeamsNotification:
+        """Create truthound TeamsNotification action."""
+        return TeamsNotification(
+            webhook_url=self.config["webhook_url"],
+            channel=self.config.get("channel"),
+            include_details=self.config.get("include_details", True),
+            notify_on="always",
+        )
+
     async def send(
         self,
         message: str,
         event: NotificationEvent | None = None,
-        payload: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> bool:
-        """Send notification via webhook.
-
-        Args:
-            message: Message text.
-            event: Optional triggering event.
-            payload: Optional custom payload (overrides default).
-            **kwargs: Additional options.
-
-        Returns:
-            True if webhook call was successful.
-        """
-        url = self.config["url"]
-        method = self.config.get("method", "POST").upper()
-        headers = self.config.get("headers", {})
-
-        # Build payload
-        if payload is None:
-            payload = self._build_payload(message, event)
-
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            if method == "GET":
-                response = await client.get(url, headers=headers, params=payload)
-            elif method == "PUT":
-                response = await client.put(url, headers=headers, json=payload)
-            else:  # Default to POST
-                response = await client.post(url, headers=headers, json=payload)
-
-            # Consider 2xx responses as success
-            return 200 <= response.status_code < 300
-
-    def _build_payload(
-        self,
-        message: str,
-        event: NotificationEvent | None,
-    ) -> dict[str, Any]:
-        """Build webhook payload."""
-        payload: dict[str, Any] = {
-            "message": message,
-            "channel_id": self.channel_id,
-            "channel_name": self.name,
-        }
-
-        if event and self.config.get("include_event_data", True):
-            payload["event"] = event.to_dict()
-            payload["event_type"] = event.event_type
-
-        return payload
-
-    def format_message(self, event: NotificationEvent) -> str:
-        """Format message for webhook (plain text)."""
-        if isinstance(event, ValidationFailedEvent):
-            return (
-                f"Validation failed for {event.source_name or 'Unknown'}: "
-                f"{event.total_issues} issues ({event.severity})"
-            )
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return (
-                f"Schedule '{event.schedule_name}' failed for "
-                f"{event.source_name or 'Unknown'}"
-            )
-
-        elif isinstance(event, DriftDetectedEvent):
-            return (
-                f"Drift detected: {event.drifted_columns}/{event.total_columns} columns "
-                f"({event.drift_percentage:.1f}%)"
-            )
-
-        elif isinstance(event, TestNotificationEvent):
-            return f"Test notification from truthound-dashboard"
+        """Send notification to Teams using truthound library."""
+        try:
+            action = self._create_action()
+            mock_result = _build_checkpoint_result_mock(event)
 
-        return self._default_format(event)
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, action.execute, mock_result)
+            return True
+        except Exception as e:
+            logger.error(f"Teams notification failed: {e}")
+            return False
 
 
 @ChannelRegistry.register("discord")
 class DiscordChannel(BaseNotificationChannel):
-    """Discord notification channel using webhooks.
+    """Discord notification channel using truthound.checkpoint.actions.DiscordNotification.
 
     Configuration:
-        webhook_url: Discord webhook URL
-        username: Optional bot username override
-        avatar_url: Optional avatar URL
-
-    Example config:
-        {
-            "webhook_url": "https://discord.com/api/webhooks/...",
-            "username": "Truthound Bot",
-            "avatar_url": "https://example.com/avatar.png"
-        }
+        webhook_url: Discord webhook URL (required)
+        username: Bot display name
+        avatar_url: Bot avatar URL
+        embed_color: Embed color (hex integer)
+        include_mentions: List of mentions (@here, role IDs, etc.)
     """
 
     channel_type = "discord"
@@ -599,135 +435,64 @@ class DiscordChannel(BaseNotificationChannel):
             "username": {
                 "type": "string",
                 "required": False,
-                "description": "Bot username override",
+                "description": "Bot display name",
             },
             "avatar_url": {
                 "type": "string",
                 "required": False,
                 "description": "Bot avatar URL",
             },
+            "embed_color": {
+                "type": "integer",
+                "required": False,
+                "description": "Embed color (hex integer)",
+            },
+            "include_mentions": {
+                "type": "array",
+                "required": False,
+                "description": "List of mentions (@here, role IDs, etc.)",
+            },
         }
 
+    def _create_action(self) -> DiscordNotification:
+        """Create truthound DiscordNotification action."""
+        return DiscordNotification(
+            webhook_url=self.config["webhook_url"],
+            username=self.config.get("username", "Truthound Bot"),
+            avatar_url=self.config.get("avatar_url"),
+            embed_color=self.config.get("embed_color"),
+            include_mentions=self.config.get("include_mentions", []),
+            notify_on="always",
+        )
+
     async def send(
         self,
         message: str,
         event: NotificationEvent | None = None,
         **kwargs: Any,
     ) -> bool:
-        """Send notification to Discord.
-
-        Args:
-            message: Message text (supports Discord markdown).
-            event: Optional triggering event.
-            **kwargs: Additional Discord message options.
-
-        Returns:
-            True if message was sent successfully.
-        """
-        webhook_url = self.config["webhook_url"]
-
-        # Build payload with embeds for rich formatting
-        payload: dict[str, Any] = {"content": message}
-
-        # Add embeds for specific events
-        embeds = self._build_embeds(event)
-        if embeds:
-            payload["embeds"] = embeds
-
-        # Add optional overrides
-        if self.config.get("username"):
-            payload["username"] = self.config["username"]
-        if self.config.get("avatar_url"):
-            payload["avatar_url"] = self.config["avatar_url"]
-
-        payload.update(kwargs)
-
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(webhook_url, json=payload)
-            # Discord returns 204 on success
-            return response.status_code in (200, 204)
-
-    def _build_embeds(
-        self,
-        event: NotificationEvent | None,
-    ) -> list[dict[str, Any]]:
-        """Build Discord embeds for rich message formatting."""
-        if event is None:
-            return []
-
-        embed: dict[str, Any] = {
-            "timestamp": event.timestamp.isoformat(),
-            "footer": {"text": "Truthound Dashboard"},
-        }
-
-        if isinstance(event, ValidationFailedEvent):
-            embed["title"] = "🚨 Validation Failed"
-            embed["color"] = 0xFF0000 if event.has_critical else 0xFFA500
-            embed["fields"] = [
-                {"name": "Source", "value": event.source_name or "Unknown", "inline": True},
-                {"name": "Severity", "value": event.severity, "inline": True},
-                {"name": "Issues", "value": str(event.total_issues), "inline": True},
-            ]
-        elif isinstance(event, DriftDetectedEvent):
-            embed["title"] = "📊 Drift Detected"
-            embed["color"] = 0xFFA500
-            embed["fields"] = [
-                {"name": "Baseline", "value": event.baseline_source_name, "inline": True},
-                {"name": "Current", "value": event.current_source_name, "inline": True},
-                {"name": "Drift", "value": f"{event.drift_percentage:.1f}%", "inline": True},
-            ]
-        elif isinstance(event, ScheduleFailedEvent):
-            embed["title"] = "⏰ Schedule Failed"
-            embed["color"] = 0xFF6B6B
-            embed["fields"] = [
-                {"name": "Schedule", "value": event.schedule_name, "inline": True},
-                {"name": "Source", "value": event.source_name or "Unknown", "inline": True},
-            ]
-            if event.error_message:
-                embed["fields"].append({"name": "Error", "value": event.error_message[:1024], "inline": False})
-        elif isinstance(event, TestNotificationEvent):
-            embed["title"] = "✅ Test Notification"
-            embed["color"] = 0x00FF00
-            embed["description"] = f"Channel: {event.channel_name}"
-        else:
-            return []
-
-        return [embed]
-
-    def format_message(self, event: NotificationEvent) -> str:
-        """Format message for Discord."""
-        if isinstance(event, ValidationFailedEvent):
-            emoji = "🚨" if event.has_critical else "⚠️"
-            return f"{emoji} **Validation Failed** for `{event.source_name or 'Unknown'}`"
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return f"⏰ **Schedule Failed**: `{event.schedule_name}`"
-
-        elif isinstance(event, DriftDetectedEvent):
-            return f"📊 **Drift Detected**: {event.drift_percentage:.1f}% drift"
-
-        elif isinstance(event, TestNotificationEvent):
-            return f"✅ **Test Notification** from truthound-dashboard"
+        """Send notification to Discord using truthound library."""
+        try:
+            action = self._create_action()
+            mock_result = _build_checkpoint_result_mock(event)
 
-        return self._default_format(event)
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, action.execute, mock_result)
+            return True
+        except Exception as e:
+            logger.error(f"Discord notification failed: {e}")
+            return False
 
 
 @ChannelRegistry.register("telegram")
 class TelegramChannel(BaseNotificationChannel):
-    """Telegram notification channel using Bot API.
+    """Telegram notification channel using truthound.checkpoint.actions.TelegramNotification.
 
     Configuration:
-        bot_token: Telegram Bot API token
-        chat_id: Target chat/group/channel ID
-        parse_mode: Message parse mode (HTML or MarkdownV2)
-        disable_notification: Send silently (default: False)
-
-    Example config:
-        {
-            "bot_token": "123456789:ABCdefGHIjklMNOpqrsTUVwxyz",
-            "chat_id": "-1001234567890",
-            "parse_mode": "HTML"
-        }
+        bot_token: Telegram Bot Token (required)
+        chat_id: Channel/Group ID (required)
+        parse_mode: Parse mode (Markdown or HTML)
+        disable_notification: Silent notification
     """
 
     channel_type = "telegram"
@@ -739,125 +504,69 @@ class TelegramChannel(BaseNotificationChannel):
             "bot_token": {
                 "type": "string",
                 "required": True,
-                "secret": True,
-                "description": "Telegram Bot API token",
+                "description": "Telegram Bot Token",
             },
             "chat_id": {
                 "type": "string",
                 "required": True,
-                "description": "Target chat/group/channel ID",
+                "description": "Channel/Group ID",
             },
             "parse_mode": {
                 "type": "string",
                 "required": False,
-                "default": "HTML",
-                "description": "Message parse mode (HTML or MarkdownV2)",
+                "description": "Parse mode: Markdown or HTML",
             },
             "disable_notification": {
                 "type": "boolean",
                 "required": False,
-                "default": False,
-                "description": "Send message silently",
+                "description": "Silent notification",
             },
         }
 
+    def _create_action(self) -> TelegramNotification:
+        """Create truthound TelegramNotification action."""
+        return TelegramNotification(
+            bot_token=self.config["bot_token"],
+            chat_id=self.config["chat_id"],
+            parse_mode=self.config.get("parse_mode", "Markdown"),
+            disable_notification=self.config.get("disable_notification", False),
+            notify_on="always",
+        )
+
     async def send(
         self,
         message: str,
         event: NotificationEvent | None = None,
         **kwargs: Any,
     ) -> bool:
-        """Send notification via Telegram Bot API.
-
-        Args:
-            message: Message text (supports HTML or Markdown).
-            event: Optional triggering event.
-            **kwargs: Additional Telegram API options.
-
-        Returns:
-            True if message was sent successfully.
-        """
-        bot_token = self.config["bot_token"]
-        chat_id = self.config["chat_id"]
-        api_url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
-
-        payload: dict[str, Any] = {
-            "chat_id": chat_id,
-            "text": message,
-            "parse_mode": self.config.get("parse_mode", "HTML"),
-        }
-
-        if self.config.get("disable_notification"):
-            payload["disable_notification"] = True
-
-        payload.update(kwargs)
+        """Send notification to Telegram using truthound library."""
+        try:
+            action = self._create_action()
+            mock_result = _build_checkpoint_result_mock(event)
 
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(api_url, json=payload)
-            result = response.json()
-            return result.get("ok", False)
-
-    def format_message(self, event: NotificationEvent) -> str:
-        """Format message for Telegram with HTML."""
-        if isinstance(event, ValidationFailedEvent):
-            emoji = "🚨" if event.has_critical else "⚠️"
-            return (
-                f"{emoji} <b>Validation Failed</b>\n\n"
-                f"<b>Source:</b> {event.source_name or 'Unknown'}\n"
-                f"<b>Severity:</b> {event.severity}\n"
-                f"<b>Issues:</b> {event.total_issues}"
-            )
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return (
-                f"⏰ <b>Schedule Failed</b>\n\n"
-                f"<b>Schedule:</b> {event.schedule_name}\n"
-                f"<b>Source:</b> {event.source_name or 'Unknown'}\n"
-                f"<b>Error:</b> {event.error_message or 'Validation failed'}"
-            )
-
-        elif isinstance(event, DriftDetectedEvent):
-            return (
-                f"📊 <b>Drift Detected</b>\n\n"
-                f"<b>Baseline:</b> {event.baseline_source_name}\n"
-                f"<b>Current:</b> {event.current_source_name}\n"
-                f"<b>Drift:</b> {event.drifted_columns}/{event.total_columns} columns "
-                f"({event.drift_percentage:.1f}%)"
-            )
-
-        elif isinstance(event, TestNotificationEvent):
-            return (
-                f"✅ <b>Test Notification</b>\n\n"
-                f"This is a test from truthound-dashboard.\n"
-                f"<b>Channel:</b> {event.channel_name}"
-            )
-
-        return self._default_format(event)
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, action.execute, mock_result)
+            return True
+        except Exception as e:
+            logger.error(f"Telegram notification failed: {e}")
+            return False
 
 
 @ChannelRegistry.register("pagerduty")
 class PagerDutyChannel(BaseNotificationChannel):
-    """PagerDuty notification channel using Events API v2.
+    """PagerDuty notification channel using truthound.checkpoint.actions.PagerDutyAction.
 
     Configuration:
-        routing_key: PagerDuty Events API v2 routing/integration key
-        severity: Default severity (critical, error, warning, info)
-        component: Optional component name
-        group: Optional logical grouping
-        class_type: Optional class/type of event
-
-    Example config:
-        {
-            "routing_key": "your-32-char-routing-key",
-            "severity": "error",
-            "component": "data-quality"
-        }
+        routing_key: PagerDuty Events API v2 routing key (required)
+        severity: Alert severity (critical, error, warning, info)
+        component: Affected component name
+        group: Alert grouping key
+        class_type: Alert class
+        custom_details: Additional details to include
     """
 
     channel_type = "pagerduty"
 
-    EVENTS_API_URL = "https://events.pagerduty.com/v2/enqueue"
-
     @classmethod
     def get_config_schema(cls) -> dict[str, Any]:
         """Get PagerDuty channel configuration schema."""
@@ -865,519 +574,240 @@ class PagerDutyChannel(BaseNotificationChannel):
             "routing_key": {
                 "type": "string",
                 "required": True,
-                "secret": True,
                 "description": "PagerDuty Events API v2 routing key",
             },
             "severity": {
                 "type": "string",
                 "required": False,
-                "default": "error",
-                "description": "Default severity (critical, error, warning, info)",
+                "description": "Alert severity: critical, error, warning, info",
             },
             "component": {
                 "type": "string",
                 "required": False,
-                "description": "Component name",
+                "description": "Affected component name",
             },
             "group": {
                 "type": "string",
                 "required": False,
-                "description": "Logical grouping",
+                "description": "Alert grouping key",
             },
             "class_type": {
                 "type": "string",
                 "required": False,
-                "description": "Event class/type",
+                "description": "Alert class/type",
+            },
+            "custom_details": {
+                "type": "object",
+                "required": False,
+                "description": "Additional custom details",
             },
         }
 
+    def _create_action(self) -> PagerDutyAction:
+        """Create truthound PagerDutyAction."""
+        return PagerDutyAction(
+            routing_key=self.config["routing_key"],
+            severity=self.config.get("severity", "error"),
+            component=self.config.get("component"),
+            group=self.config.get("group"),
+            class_type=self.config.get("class_type"),
+            custom_details=self.config.get("custom_details", {}),
+            notify_on="always",
+        )
+
     async def send(
         self,
         message: str,
         event: NotificationEvent | None = None,
-        action: str = "trigger",
-        dedup_key: str | None = None,
         **kwargs: Any,
     ) -> bool:
-        """Send event to PagerDuty.
-
-        Args:
-            message: Alert summary.
-            event: Optional triggering event.
-            action: Event action (trigger, acknowledge, resolve).
-            dedup_key: Optional deduplication key.
-            **kwargs: Additional PagerDuty event options.
-
-        Returns:
-            True if event was accepted.
-        """
-        routing_key = self.config["routing_key"]
-
-        # Determine severity from event
-        severity = self._determine_severity(event)
-
-        # Build payload
-        payload: dict[str, Any] = {
-            "routing_key": routing_key,
-            "event_action": action,
-            "payload": {
-                "summary": message[:1024],  # PagerDuty limit
-                "severity": severity,
-                "source": "truthound-dashboard",
-                "timestamp": event.timestamp.isoformat() if event else None,
-            },
-        }
-
-        # Add optional fields
-        if dedup_key:
-            payload["dedup_key"] = dedup_key
-        elif event:
-            # Generate dedup key from event
-            payload["dedup_key"] = f"truthound-{event.event_type}-{event.source_id or 'global'}"
-
-        if self.config.get("component"):
-            payload["payload"]["component"] = self.config["component"]
-        if self.config.get("group"):
-            payload["payload"]["group"] = self.config["group"]
-        if self.config.get("class_type"):
-            payload["payload"]["class"] = self.config["class_type"]
-
-        # Add custom details
-        if event:
-            payload["payload"]["custom_details"] = event.to_dict()
-
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(self.EVENTS_API_URL, json=payload)
-            return response.status_code == 202
-
-    def _determine_severity(self, event: NotificationEvent | None) -> str:
-        """Determine PagerDuty severity from event."""
-        default_severity = self.config.get("severity", "error")
-
-        if event is None:
-            return default_severity
-
-        if isinstance(event, ValidationFailedEvent):
-            if event.has_critical:
-                return "critical"
-            elif event.has_high:
-                return "error"
-            return "warning"
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return "error"
-
-        elif isinstance(event, DriftDetectedEvent):
-            return "warning" if event.has_high_drift else "info"
-
-        elif isinstance(event, TestNotificationEvent):
-            return "info"
-
-        return default_severity
-
-    def format_message(self, event: NotificationEvent) -> str:
-        """Format message for PagerDuty alert summary."""
-        if isinstance(event, ValidationFailedEvent):
-            return (
-                f"Validation failed for {event.source_name or 'Unknown'}: "
-                f"{event.total_issues} {event.severity} issues"
-            )
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return f"Scheduled validation failed: {event.schedule_name}"
-
-        elif isinstance(event, DriftDetectedEvent):
-            return (
-                f"Data drift detected: {event.drifted_columns}/{event.total_columns} columns "
-                f"({event.drift_percentage:.1f}%)"
-            )
-
-        elif isinstance(event, TestNotificationEvent):
-            return f"Test alert from truthound-dashboard ({event.channel_name})"
+        """Send notification to PagerDuty using truthound library."""
+        try:
+            action = self._create_action()
+            mock_result = _build_checkpoint_result_mock(event)
 
-        return self._default_format(event)
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, action.execute, mock_result)
+            return True
+        except Exception as e:
+            logger.error(f"PagerDuty notification failed: {e}")
+            return False
 
 
-@ChannelRegistry.register("opsgenie")
-class OpsGenieChannel(BaseNotificationChannel):
-    """OpsGenie notification channel using Alert API.
+@ChannelRegistry.register("webhook")
+class WebhookChannel(BaseNotificationChannel):
+    """Generic webhook notification channel using truthound.checkpoint.actions.WebhookAction.
 
     Configuration:
-        api_key: OpsGenie API key
-        priority: Default priority (P1-P5)
-        tags: Optional list of tags
-        team: Optional team name
-        responders: Optional list of responders
-
-    Example config:
-        {
-            "api_key": "your-opsgenie-api-key",
-            "priority": "P3",
-            "tags": ["data-quality", "automated"],
-            "team": "data-platform"
-        }
+        url: Webhook URL (required)
+        method: HTTP method (GET, POST, PUT, PATCH)
+        headers: Custom HTTP headers
+        timeout: Request timeout in seconds
+        include_result: Include full result in payload
     """
 
-    channel_type = "opsgenie"
-
-    API_URL = "https://api.opsgenie.com/v2/alerts"
+    channel_type = "webhook"
 
     @classmethod
     def get_config_schema(cls) -> dict[str, Any]:
-        """Get OpsGenie channel configuration schema."""
+        """Get Webhook channel configuration schema."""
         return {
-            "api_key": {
+            "url": {
                 "type": "string",
                 "required": True,
-                "secret": True,
-                "description": "OpsGenie API key",
+                "description": "Webhook URL",
             },
-            "priority": {
+            "method": {
                 "type": "string",
                 "required": False,
-                "default": "P3",
-                "description": "Default priority (P1-P5)",
+                "description": "HTTP method: GET, POST, PUT, PATCH",
             },
-            "tags": {
-                "type": "array",
+            "headers": {
+                "type": "object",
                 "required": False,
-                "items": {"type": "string"},
-                "description": "Alert tags",
+                "description": "Custom HTTP headers",
             },
-            "team": {
-                "type": "string",
+            "timeout": {
+                "type": "integer",
                 "required": False,
-                "description": "Team name",
+                "description": "Request timeout in seconds",
             },
-            "responders": {
-                "type": "array",
+            "include_result": {
+                "type": "boolean",
                 "required": False,
-                "items": {"type": "object"},
-                "description": "List of responders",
+                "description": "Include full result in payload",
             },
         }
 
+    def _create_action(self) -> WebhookAction:
+        """Create truthound WebhookAction."""
+        return WebhookAction(
+            url=self.config["url"],
+            method=self.config.get("method", "POST"),
+            headers=self.config.get("headers", {}),
+            timeout=self.config.get("timeout", 30),
+            include_result=self.config.get("include_result", True),
+            notify_on="always",
+        )
+
     async def send(
         self,
         message: str,
         event: NotificationEvent | None = None,
-        alias: str | None = None,
         **kwargs: Any,
     ) -> bool:
-        """Send alert to OpsGenie.
-
-        Args:
-            message: Alert message.
-            event: Optional triggering event.
-            alias: Optional unique alert identifier.
-            **kwargs: Additional OpsGenie alert options.
-
-        Returns:
-            True if alert was created.
-        """
-        api_key = self.config["api_key"]
-
-        # Determine priority from event
-        priority = self._determine_priority(event)
-
-        # Build payload
-        payload: dict[str, Any] = {
-            "message": message[:130],  # OpsGenie message limit
-            "priority": priority,
-            "source": "truthound-dashboard",
-        }
-
-        # Add alias for deduplication
-        if alias:
-            payload["alias"] = alias
-        elif event:
-            payload["alias"] = f"truthound-{event.event_type}-{event.source_id or 'global'}"
-
-        # Add description with full details
-        if event:
-            payload["description"] = self._build_description(event)
-
-        # Add optional fields
-        tags = list(self.config.get("tags", [])) + ["truthound"]
-        payload["tags"] = tags
-
-        if self.config.get("team"):
-            payload["responders"] = [{"type": "team", "name": self.config["team"]}]
-        elif self.config.get("responders"):
-            payload["responders"] = self.config["responders"]
-
-        # Add details
-        if event:
-            payload["details"] = {
-                "event_type": event.event_type,
-                "source_id": event.source_id,
-                "source_name": event.source_name,
-                "timestamp": event.timestamp.isoformat(),
-            }
-
-        headers = {
-            "Authorization": f"GenieKey {api_key}",
-            "Content-Type": "application/json",
-        }
-
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(self.API_URL, json=payload, headers=headers)
-            return response.status_code == 202
-
-    def _determine_priority(self, event: NotificationEvent | None) -> str:
-        """Determine OpsGenie priority from event."""
-        default_priority = self.config.get("priority", "P3")
-
-        if event is None:
-            return default_priority
-
-        if isinstance(event, ValidationFailedEvent):
-            if event.has_critical:
-                return "P1"
-            elif event.has_high:
-                return "P2"
-            return "P3"
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return "P2"
-
-        elif isinstance(event, DriftDetectedEvent):
-            return "P3" if event.has_high_drift else "P4"
-
-        elif isinstance(event, TestNotificationEvent):
-            return "P5"
-
-        return default_priority
-
-    def _build_description(self, event: NotificationEvent) -> str:
-        """Build detailed description for OpsGenie alert."""
-        if isinstance(event, ValidationFailedEvent):
-            return (
-                f"Validation failed for source: {event.source_name or 'Unknown'}\n\n"
-                f"Severity: {event.severity}\n"
-                f"Total Issues: {event.total_issues}\n"
-                f"Critical Issues: {event.has_critical}\n"
-                f"High Severity Issues: {event.has_high}\n"
-                f"Validation ID: {event.validation_id}"
-            )
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return (
-                f"Scheduled validation failed\n\n"
-                f"Schedule: {event.schedule_name}\n"
-                f"Source: {event.source_name or 'Unknown'}\n"
-                f"Error: {event.error_message or 'Validation failed'}"
-            )
-
-        elif isinstance(event, DriftDetectedEvent):
-            return (
-                f"Data drift detected between datasets\n\n"
-                f"Baseline: {event.baseline_source_name}\n"
-                f"Current: {event.current_source_name}\n"
-                f"Drifted Columns: {event.drifted_columns}/{event.total_columns}\n"
-                f"Drift Percentage: {event.drift_percentage:.1f}%"
-            )
-
-        return f"Event type: {event.event_type}"
-
-    def format_message(self, event: NotificationEvent) -> str:
-        """Format message for OpsGenie alert (short)."""
-        if isinstance(event, ValidationFailedEvent):
-            return f"Validation failed: {event.source_name or 'Unknown'} ({event.severity})"
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return f"Schedule failed: {event.schedule_name}"
-
-        elif isinstance(event, DriftDetectedEvent):
-            return f"Drift detected: {event.drift_percentage:.1f}%"
-
-        elif isinstance(event, TestNotificationEvent):
-            return f"Test alert: {event.channel_name}"
+        """Send notification via Webhook using truthound library."""
+        try:
+            action = self._create_action()
+            mock_result = _build_checkpoint_result_mock(event)
 
-        return self._default_format(event)
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, action.execute, mock_result)
+            return True
+        except Exception as e:
+            logger.error(f"Webhook notification failed: {e}")
+            return False
 
 
-@ChannelRegistry.register("teams")
-class TeamsChannel(BaseNotificationChannel):
-    """Microsoft Teams notification channel using webhooks.
+@ChannelRegistry.register("opsgenie")
+class OpsGenieChannel(BaseNotificationChannel):
+    """OpsGenie notification channel using truthound.checkpoint.actions.OpsGenieAction.
 
     Configuration:
-        webhook_url: Teams incoming webhook URL
-        theme_color: Optional accent color (hex without #)
-
-    Example config:
-        {
-            "webhook_url": "https://outlook.office.com/webhook/...",
-            "theme_color": "fd9e4b"
-        }
+        api_key: OpsGenie API key (required)
+        region: OpsGenie region (us or eu)
+        priority: Alert priority (P1-P5)
+        auto_priority: Automatic priority mapping
+        tags: Alert tags
+        auto_close_on_success: Automatically close on success
     """
 
-    channel_type = "teams"
+    channel_type = "opsgenie"
 
     @classmethod
     def get_config_schema(cls) -> dict[str, Any]:
-        """Get Teams channel configuration schema."""
+        """Get OpsGenie channel configuration schema."""
         return {
-            "webhook_url": {
+            "api_key": {
                 "type": "string",
                 "required": True,
-                "description": "Teams incoming webhook URL",
+                "description": "OpsGenie API key",
             },
-            "theme_color": {
+            "region": {
                 "type": "string",
                 "required": False,
-                "default": "fd9e4b",
-                "description": "Accent color (hex without #)",
+                "description": "OpsGenie region: us or eu",
+            },
+            "priority": {
+                "type": "string",
+                "required": False,
+                "description": "Alert priority: P1, P2, P3, P4, P5",
+            },
+            "auto_priority": {
+                "type": "boolean",
+                "required": False,
+                "description": "Automatic priority mapping based on validation results",
+            },
+            "tags": {
+                "type": "array",
+                "required": False,
+                "description": "Alert tags",
+            },
+            "auto_close_on_success": {
+                "type": "boolean",
+                "required": False,
+                "description": "Automatically close on success",
             },
         }
 
+    def _create_action(self) -> OpsGenieAction:
+        """Create truthound OpsGenieAction."""
+        return OpsGenieAction(
+            api_key=self.config["api_key"],
+            region=self.config.get("region", "us"),
+            priority=self.config.get("priority", "P3"),
+            auto_priority=self.config.get("auto_priority", True),
+            tags=self.config.get("tags", []),
+            auto_close_on_success=self.config.get("auto_close_on_success", True),
+            notify_on="always",
+        )
+
     async def send(
         self,
         message: str,
         event: NotificationEvent | None = None,
         **kwargs: Any,
     ) -> bool:
-        """Send notification to Microsoft Teams.
-
-        Args:
-            message: Message text.
-            event: Optional triggering event.
-            **kwargs: Additional Teams message options.
-
-        Returns:
-            True if message was sent successfully.
-        """
-        webhook_url = self.config["webhook_url"]
-
-        # Build Adaptive Card payload
-        payload = self._build_card(message, event)
-
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(webhook_url, json=payload)
-            return response.status_code == 200
-
-    def _build_card(
-        self,
-        message: str,
-        event: NotificationEvent | None,
-    ) -> dict[str, Any]:
-        """Build Teams Adaptive Card payload."""
-        theme_color = self.config.get("theme_color", "fd9e4b")
-
-        # Build card content
-        card: dict[str, Any] = {
-            "@type": "MessageCard",
-            "@context": "http://schema.org/extensions",
-            "themeColor": theme_color,
-            "summary": message[:150],
-            "sections": [],
-        }
-
-        # Build sections based on event type
-        if isinstance(event, ValidationFailedEvent):
-            card["title"] = "🚨 Validation Failed"
-            card["sections"].append({
-                "activityTitle": event.source_name or "Unknown Source",
-                "activitySubtitle": f"Severity: {event.severity}",
-                "facts": [
-                    {"name": "Total Issues", "value": str(event.total_issues)},
-                    {"name": "Critical", "value": "Yes" if event.has_critical else "No"},
-                    {"name": "High", "value": "Yes" if event.has_high else "No"},
-                    {"name": "Validation ID", "value": event.validation_id[:8] + "..."},
-                ],
-                "markdown": True,
-            })
-
-        elif isinstance(event, ScheduleFailedEvent):
-            card["title"] = "⏰ Schedule Failed"
-            card["sections"].append({
-                "activityTitle": event.schedule_name,
-                "activitySubtitle": event.source_name or "Unknown Source",
-                "facts": [
-                    {"name": "Error", "value": event.error_message or "Validation failed"},
-                ],
-                "markdown": True,
-            })
-
-        elif isinstance(event, DriftDetectedEvent):
-            card["title"] = "📊 Drift Detected"
-            card["sections"].append({
-                "activityTitle": "Data Drift Analysis",
-                "facts": [
-                    {"name": "Baseline", "value": event.baseline_source_name},
-                    {"name": "Current", "value": event.current_source_name},
-                    {"name": "Drifted Columns", "value": f"{event.drifted_columns}/{event.total_columns}"},
-                    {"name": "Drift %", "value": f"{event.drift_percentage:.1f}%"},
-                ],
-                "markdown": True,
-            })
-
-        elif isinstance(event, TestNotificationEvent):
-            card["title"] = "✅ Test Notification"
-            card["sections"].append({
-                "activityTitle": "truthound-dashboard",
-                "activitySubtitle": f"Channel: {event.channel_name}",
-                "text": "This is a test notification.",
-                "markdown": True,
-            })
-
-        else:
-            card["title"] = "Truthound Notification"
-            card["sections"].append({
-                "text": message,
-                "markdown": True,
-            })
-
-        return card
-
-    def format_message(self, event: NotificationEvent) -> str:
-        """Format message for Teams."""
-        if isinstance(event, ValidationFailedEvent):
-            return (
-                f"Validation failed for {event.source_name or 'Unknown'}: "
-                f"{event.total_issues} issues ({event.severity})"
-            )
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return f"Schedule '{event.schedule_name}' failed"
-
-        elif isinstance(event, DriftDetectedEvent):
-            return (
-                f"Drift detected: {event.drifted_columns} columns "
-                f"({event.drift_percentage:.1f}%)"
-            )
-
-        elif isinstance(event, TestNotificationEvent):
-            return "Test notification from truthound-dashboard"
+        """Send notification to OpsGenie using truthound library."""
+        try:
+            action = self._create_action()
+            mock_result = _build_checkpoint_result_mock(event)
 
-        return self._default_format(event)
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, action.execute, mock_result)
+            return True
+        except Exception as e:
+            logger.error(f"OpsGenie notification failed: {e}")
+            return False
 
 
 @ChannelRegistry.register("github")
 class GitHubChannel(BaseNotificationChannel):
-    """GitHub notification channel for creating issues.
+    """GitHub notification channel using truthound.checkpoint.actions.GitHubAction.
 
-    Configuration:
-        token: GitHub personal access token
-        owner: Repository owner
-        repo: Repository name
-        labels: Optional list of labels to apply
-        assignees: Optional list of assignees
+    Creates GitHub issues or check runs for notifications.
 
-    Example config:
-        {
-            "token": "ghp_xxxxxxxxxxxxxxxxxxxx",
-            "owner": "myorg",
-            "repo": "data-quality",
-            "labels": ["data-quality", "automated"],
-            "assignees": ["data-team-lead"]
-        }
+    Configuration:
+        token: GitHub personal access token (required)
+        owner: Repository owner (required)
+        repo: Repository name (required)
+        labels: Issue labels
+        assignees: Issue assignees
+        create_check_run: Create check run instead of issue
     """
 
     channel_type = "github"
 
-    API_URL = "https://api.github.com"
-
     @classmethod
     def get_config_schema(cls) -> dict[str, Any]:
         """Get GitHub channel configuration schema."""
@@ -1385,7 +815,6 @@ class GitHubChannel(BaseNotificationChannel):
             "token": {
                 "type": "string",
                 "required": True,
-                "secret": True,
                 "description": "GitHub personal access token",
             },
             "owner": {
@@ -1401,176 +830,45 @@ class GitHubChannel(BaseNotificationChannel):
             "labels": {
                 "type": "array",
                 "required": False,
-                "items": {"type": "string"},
-                "description": "Labels to apply to issues",
+                "description": "Issue labels",
             },
             "assignees": {
                 "type": "array",
                 "required": False,
-                "items": {"type": "string"},
-                "description": "Users to assign",
+                "description": "Issue assignees",
+            },
+            "create_check_run": {
+                "type": "boolean",
+                "required": False,
+                "description": "Create check run instead of issue",
             },
         }
 
+    def _create_action(self) -> GitHubAction:
+        """Create truthound GitHubAction."""
+        return GitHubAction(
+            token=self.config["token"],
+            repo=f"{self.config['owner']}/{self.config['repo']}",
+            create_check_run=self.config.get("create_check_run", False),
+            labels=self.config.get("labels", ["data-quality"]),
+            assignees=self.config.get("assignees", []),
+            notify_on="always",
+        )
+
     async def send(
         self,
         message: str,
         event: NotificationEvent | None = None,
-        title: str | None = None,
         **kwargs: Any,
     ) -> bool:
-        """Create GitHub issue for notification.
-
-        Args:
-            message: Issue body.
-            event: Optional triggering event.
-            title: Optional title override.
-            **kwargs: Additional issue options.
-
-        Returns:
-            True if issue was created.
-        """
-        token = self.config["token"]
-        owner = self.config["owner"]
-        repo = self.config["repo"]
-
-        # Build issue title
-        if title is None:
-            title = self._build_title(event)
-
-        # Build issue body
-        body = self._build_body(message, event)
-
-        # Build payload
-        payload: dict[str, Any] = {
-            "title": title,
-            "body": body,
-        }
-
-        # Add optional fields
-        labels = list(self.config.get("labels", [])) + ["truthound-alert"]
-        payload["labels"] = labels
-
-        if self.config.get("assignees"):
-            payload["assignees"] = self.config["assignees"]
-
-        headers = {
-            "Authorization": f"Bearer {token}",
-            "Accept": "application/vnd.github.v3+json",
-        }
-
-        url = f"{self.API_URL}/repos/{owner}/{repo}/issues"
-
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(url, json=payload, headers=headers)
-            return response.status_code == 201
-
-    def _build_title(self, event: NotificationEvent | None) -> str:
-        """Build issue title from event."""
-        if event is None:
-            return "[Truthound] Alert"
-
-        if isinstance(event, ValidationFailedEvent):
-            return f"[Truthound] Validation Failed: {event.source_name or 'Unknown'}"
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return f"[Truthound] Schedule Failed: {event.schedule_name}"
-
-        elif isinstance(event, DriftDetectedEvent):
-            return f"[Truthound] Drift Detected: {event.baseline_source_name}"
-
-        elif isinstance(event, TestNotificationEvent):
-            return f"[Truthound] Test Issue: {event.channel_name}"
-
-        return f"[Truthound] {event.event_type}"
-
-    def _build_body(self, message: str, event: NotificationEvent | None) -> str:
-        """Build issue body with markdown formatting."""
-        body_parts = [
-            "## Truthound Dashboard Alert",
-            "",
-            message,
-            "",
-        ]
-
-        if event:
-            body_parts.extend([
-                "## Details",
-                "",
-                f"- **Event Type:** `{event.event_type}`",
-                f"- **Timestamp:** {event.timestamp.isoformat()}",
-            ])
-
-            if event.source_id:
-                body_parts.append(f"- **Source ID:** `{event.source_id}`")
-            if event.source_name:
-                body_parts.append(f"- **Source Name:** {event.source_name}")
-
-            if isinstance(event, ValidationFailedEvent):
-                body_parts.extend([
-                    "",
-                    "### Validation Summary",
-                    "",
-                    f"| Metric | Value |",
-                    f"|--------|-------|",
-                    f"| Severity | {event.severity} |",
-                    f"| Total Issues | {event.total_issues} |",
-                    f"| Critical | {'Yes' if event.has_critical else 'No'} |",
-                    f"| High | {'Yes' if event.has_high else 'No'} |",
-                    f"| Validation ID | `{event.validation_id}` |",
-                ])
-
-            elif isinstance(event, DriftDetectedEvent):
-                body_parts.extend([
-                    "",
-                    "### Drift Summary",
-                    "",
-                    f"| Metric | Value |",
-                    f"|--------|-------|",
-                    f"| Baseline | {event.baseline_source_name} |",
-                    f"| Current | {event.current_source_name} |",
-                    f"| Drifted Columns | {event.drifted_columns}/{event.total_columns} |",
-                    f"| Drift % | {event.drift_percentage:.1f}% |",
-                ])
-
-        body_parts.extend([
-            "",
-            "---",
-            "_This issue was automatically created by truthound-dashboard._",
-        ])
-
-        return "\n".join(body_parts)
-
-    def format_message(self, event: NotificationEvent) -> str:
-        """Format message for GitHub issue body."""
-        if isinstance(event, ValidationFailedEvent):
-            return (
-                f"A validation failure has been detected.\n\n"
-                f"**Source:** {event.source_name or 'Unknown'}\n"
-                f"**Severity:** {event.severity}\n"
-                f"**Total Issues:** {event.total_issues}"
-            )
-
-        elif isinstance(event, ScheduleFailedEvent):
-            return (
-                f"A scheduled validation has failed.\n\n"
-                f"**Schedule:** {event.schedule_name}\n"
-                f"**Source:** {event.source_name or 'Unknown'}\n"
-                f"**Error:** {event.error_message or 'Validation failed'}"
-            )
-
-        elif isinstance(event, DriftDetectedEvent):
-            return (
-                f"Data drift has been detected between datasets.\n\n"
-                f"**Baseline:** {event.baseline_source_name}\n"
-                f"**Current:** {event.current_source_name}\n"
-                f"**Drift:** {event.drift_percentage:.1f}%"
-            )
-
-        elif isinstance(event, TestNotificationEvent):
-            return (
-                f"This is a test issue created by truthound-dashboard.\n\n"
-                f"**Channel:** {event.channel_name}"
-            )
-
-        return self._default_format(event)
+        """Send notification to GitHub using truthound library."""
+        try:
+            action = self._create_action()
+            mock_result = _build_checkpoint_result_mock(event)
+
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, action.execute, mock_result)
+            return True
+        except Exception as e:
+            logger.error(f"GitHub notification failed: {e}")
+            return False