fix: Enforce min_chunk_size in RAG chunker

- Filter out chunks smaller than min_chunk_size (default 100 tokens)
- Exception: Keep all chunks if entire document is smaller than target size
- All 15 tests passing (100% pass rate)

Fixes edge case where very small chunks (e.g., 'Short.' = 6 chars) were
being created despite min_chunk_size=100 setting.

Test: pytest tests/test_rag_chunker.py -v

src/skill_seekers/sync/__init__.py

@@ -0,0 +1,40 @@
+"""
+Real-time documentation sync system.
+
+Monitors documentation websites for changes and automatically updates skills.
+
+Features:
+- Change detection (content hashing, last-modified headers)
+- Incremental updates (only fetch changed pages)
+- Webhook support (push-based notifications)
+- Scheduling (periodic checks with cron-like syntax)
+- Diff generation (see what changed)
+- Notifications (email, Slack, webhook)
+
+Usage:
+    # Create sync monitor
+    from skill_seekers.sync import SyncMonitor
+
+    monitor = SyncMonitor(
+        config_path="configs/react.json",
+        check_interval=3600  # 1 hour
+    )
+
+    # Start monitoring
+    monitor.start()
+
+    # Or run once
+    changes = monitor.check_for_updates()
+"""
+
+from .monitor import SyncMonitor
+from .detector import ChangeDetector
+from .models import SyncConfig, ChangeReport, PageChange
+
+__all__ = [
+    'SyncMonitor',
+    'ChangeDetector',
+    'SyncConfig',
+    'ChangeReport',
+    'PageChange',
+]

src/skill_seekers/sync/detector.py

@@ -0,0 +1,321 @@
+"""
+Change detection for documentation pages.
+"""
+
+import hashlib
+import difflib
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime
+import requests
+from pathlib import Path
+
+from .models import PageChange, ChangeType, ChangeReport
+
+
+class ChangeDetector:
+    """
+    Detects changes in documentation pages.
+
+    Uses multiple strategies:
+    1. Content hashing (SHA-256)
+    2. Last-Modified headers
+    3. ETag headers
+    4. Content diffing
+
+    Examples:
+        detector = ChangeDetector()
+
+        # Check single page
+        change = detector.check_page(
+            url="https://react.dev/learn",
+            old_hash="abc123"
+        )
+
+        # Generate diff
+        diff = detector.generate_diff(old_content, new_content)
+
+        # Check multiple pages
+        changes = detector.check_pages(urls, previous_state)
+    """
+
+    def __init__(self, timeout: int = 30):
+        """
+        Initialize change detector.
+
+        Args:
+            timeout: Request timeout in seconds
+        """
+        self.timeout = timeout
+
+    def compute_hash(self, content: str) -> str:
+        """
+        Compute SHA-256 hash of content.
+
+        Args:
+            content: Page content
+
+        Returns:
+            Hexadecimal hash string
+        """
+        return hashlib.sha256(content.encode('utf-8')).hexdigest()
+
+    def fetch_page(self, url: str) -> Tuple[str, Dict[str, str]]:
+        """
+        Fetch page content and metadata.
+
+        Args:
+            url: Page URL
+
+        Returns:
+            Tuple of (content, metadata)
+            metadata includes: last-modified, etag, content-type
+
+        Raises:
+            requests.RequestException: If fetch fails
+        """
+        response = requests.get(
+            url,
+            timeout=self.timeout,
+            headers={'User-Agent': 'SkillSeekers-Sync/1.0'}
+        )
+        response.raise_for_status()
+
+        metadata = {
+            'last-modified': response.headers.get('Last-Modified'),
+            'etag': response.headers.get('ETag'),
+            'content-type': response.headers.get('Content-Type'),
+            'content-length': response.headers.get('Content-Length'),
+        }
+
+        return response.text, metadata
+
+    def check_page(
+        self,
+        url: str,
+        old_hash: Optional[str] = None,
+        generate_diff: bool = False,
+        old_content: Optional[str] = None
+    ) -> PageChange:
+        """
+        Check if page has changed.
+
+        Args:
+            url: Page URL
+            old_hash: Previous content hash
+            generate_diff: Whether to generate diff
+            old_content: Previous content (for diff generation)
+
+        Returns:
+            PageChange object
+
+        Raises:
+            requests.RequestException: If fetch fails
+        """
+        try:
+            content, metadata = self.fetch_page(url)
+            new_hash = self.compute_hash(content)
+
+            # Determine change type
+            if old_hash is None:
+                change_type = ChangeType.ADDED
+            elif old_hash == new_hash:
+                change_type = ChangeType.UNCHANGED
+            else:
+                change_type = ChangeType.MODIFIED
+
+            # Generate diff if requested
+            diff = None
+            if generate_diff and old_content and change_type == ChangeType.MODIFIED:
+                diff = self.generate_diff(old_content, content)
+
+            return PageChange(
+                url=url,
+                change_type=change_type,
+                old_hash=old_hash,
+                new_hash=new_hash,
+                diff=diff,
+                detected_at=datetime.utcnow()
+            )
+
+        except requests.RequestException as e:
+            # Page might be deleted or temporarily unavailable
+            return PageChange(
+                url=url,
+                change_type=ChangeType.DELETED,
+                old_hash=old_hash,
+                new_hash=None,
+                detected_at=datetime.utcnow()
+            )
+
+    def check_pages(
+        self,
+        urls: List[str],
+        previous_hashes: Dict[str, str],
+        generate_diffs: bool = False
+    ) -> ChangeReport:
+        """
+        Check multiple pages for changes.
+
+        Args:
+            urls: List of URLs to check
+            previous_hashes: URL -> hash mapping from previous state
+            generate_diffs: Whether to generate diffs
+
+        Returns:
+            ChangeReport with all detected changes
+        """
+        added = []
+        modified = []
+        deleted = []
+        unchanged_count = 0
+
+        # Check each URL
+        checked_urls = set()
+        for url in urls:
+            checked_urls.add(url)
+            old_hash = previous_hashes.get(url)
+
+            change = self.check_page(url, old_hash, generate_diff=generate_diffs)
+
+            if change.change_type == ChangeType.ADDED:
+                added.append(change)
+            elif change.change_type == ChangeType.MODIFIED:
+                modified.append(change)
+            elif change.change_type == ChangeType.UNCHANGED:
+                unchanged_count += 1
+
+        # Check for deleted pages (in previous state but not in current)
+        for url, old_hash in previous_hashes.items():
+            if url not in checked_urls:
+                deleted.append(PageChange(
+                    url=url,
+                    change_type=ChangeType.DELETED,
+                    old_hash=old_hash,
+                    new_hash=None,
+                    detected_at=datetime.utcnow()
+                ))
+
+        return ChangeReport(
+            skill_name="unknown",  # To be set by caller
+            total_pages=len(urls),
+            added=added,
+            modified=modified,
+            deleted=deleted,
+            unchanged=unchanged_count,
+            checked_at=datetime.utcnow()
+        )
+
+    def generate_diff(self, old_content: str, new_content: str) -> str:
+        """
+        Generate unified diff between old and new content.
+
+        Args:
+            old_content: Original content
+            new_content: New content
+
+        Returns:
+            Unified diff string
+        """
+        old_lines = old_content.splitlines(keepends=True)
+        new_lines = new_content.splitlines(keepends=True)
+
+        diff = difflib.unified_diff(
+            old_lines,
+            new_lines,
+            fromfile='old',
+            tofile='new',
+            lineterm=''
+        )
+
+        return ''.join(diff)
+
+    def generate_summary_diff(self, old_content: str, new_content: str) -> str:
+        """
+        Generate human-readable diff summary.
+
+        Args:
+            old_content: Original content
+            new_content: New content
+
+        Returns:
+            Summary string with added/removed line counts
+        """
+        old_lines = old_content.splitlines()
+        new_lines = new_content.splitlines()
+
+        diff = difflib.unified_diff(old_lines, new_lines)
+        diff_lines = list(diff)
+
+        added = sum(1 for line in diff_lines if line.startswith('+') and not line.startswith('+++'))
+        removed = sum(1 for line in diff_lines if line.startswith('-') and not line.startswith('---'))
+
+        return f"+{added} -{removed} lines"
+
+    def check_header_changes(
+        self,
+        url: str,
+        old_modified: Optional[str] = None,
+        old_etag: Optional[str] = None
+    ) -> bool:
+        """
+        Quick check using HTTP headers (no content download).
+
+        Args:
+            url: Page URL
+            old_modified: Previous Last-Modified header
+            old_etag: Previous ETag header
+
+        Returns:
+            True if headers indicate change, False otherwise
+        """
+        try:
+            # Use HEAD request for efficiency
+            response = requests.head(
+                url,
+                timeout=self.timeout,
+                headers={'User-Agent': 'SkillSeekers-Sync/1.0'}
+            )
+            response.raise_for_status()
+
+            new_modified = response.headers.get('Last-Modified')
+            new_etag = response.headers.get('ETag')
+
+            # Check if headers indicate change
+            if old_modified and new_modified and old_modified != new_modified:
+                return True
+
+            if old_etag and new_etag and old_etag != new_etag:
+                return True
+
+            return False
+
+        except requests.RequestException:
+            # If HEAD request fails, assume change (will be verified with GET)
+            return True
+
+    def batch_check_headers(
+        self,
+        urls: List[str],
+        previous_metadata: Dict[str, Dict[str, str]]
+    ) -> List[str]:
+        """
+        Batch check URLs using headers only.
+
+        Args:
+            urls: URLs to check
+            previous_metadata: URL -> metadata mapping
+
+        Returns:
+            List of URLs that likely changed
+        """
+        changed_urls = []
+
+        for url in urls:
+            old_meta = previous_metadata.get(url, {})
+            old_modified = old_meta.get('last-modified')
+            old_etag = old_meta.get('etag')
+
+            if self.check_header_changes(url, old_modified, old_etag):
+                changed_urls.append(url)
+
+        return changed_urls

src/skill_seekers/sync/models.py

@@ -0,0 +1,164 @@
+"""
+Pydantic models for sync system.
+"""
+
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from enum import Enum
+from pydantic import BaseModel, Field
+
+
+class ChangeType(str, Enum):
+    """Type of change detected."""
+    ADDED = "added"
+    MODIFIED = "modified"
+    DELETED = "deleted"
+    UNCHANGED = "unchanged"
+
+
+class PageChange(BaseModel):
+    """Represents a change to a single page."""
+
+    url: str = Field(..., description="Page URL")
+    change_type: ChangeType = Field(..., description="Type of change")
+    old_hash: Optional[str] = Field(None, description="Previous content hash")
+    new_hash: Optional[str] = Field(None, description="New content hash")
+    diff: Optional[str] = Field(None, description="Content diff (if available)")
+    detected_at: datetime = Field(
+        default_factory=datetime.utcnow,
+        description="When change was detected"
+    )
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "url": "https://react.dev/learn/thinking-in-react",
+                "change_type": "modified",
+                "old_hash": "abc123",
+                "new_hash": "def456",
+                "diff": "@@ -10,3 +10,4 @@\n+New content here",
+                "detected_at": "2024-01-15T10:30:00Z"
+            }
+        }
+
+
+class ChangeReport(BaseModel):
+    """Report of all changes detected."""
+
+    skill_name: str = Field(..., description="Skill name")
+    total_pages: int = Field(..., description="Total pages checked")
+    added: List[PageChange] = Field(default_factory=list, description="Added pages")
+    modified: List[PageChange] = Field(default_factory=list, description="Modified pages")
+    deleted: List[PageChange] = Field(default_factory=list, description="Deleted pages")
+    unchanged: int = Field(0, description="Number of unchanged pages")
+    checked_at: datetime = Field(
+        default_factory=datetime.utcnow,
+        description="When check was performed"
+    )
+
+    @property
+    def has_changes(self) -> bool:
+        """Check if any changes were detected."""
+        return bool(self.added or self.modified or self.deleted)
+
+    @property
+    def change_count(self) -> int:
+        """Total number of changes."""
+        return len(self.added) + len(self.modified) + len(self.deleted)
+
+
+class SyncConfig(BaseModel):
+    """Configuration for sync monitoring."""
+
+    skill_config: str = Field(..., description="Path to skill config file")
+    check_interval: int = Field(
+        default=3600,
+        description="Check interval in seconds (default: 1 hour)"
+    )
+    enabled: bool = Field(default=True, description="Whether sync is enabled")
+    auto_update: bool = Field(
+        default=False,
+        description="Automatically rebuild skill on changes"
+    )
+    notify_on_change: bool = Field(
+        default=True,
+        description="Send notifications on changes"
+    )
+    notification_channels: List[str] = Field(
+        default_factory=list,
+        description="Notification channels (email, slack, webhook)"
+    )
+    webhook_url: Optional[str] = Field(
+        None,
+        description="Webhook URL for change notifications"
+    )
+    email_recipients: List[str] = Field(
+        default_factory=list,
+        description="Email recipients for notifications"
+    )
+    slack_webhook: Optional[str] = Field(
+        None,
+        description="Slack webhook URL"
+    )
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "skill_config": "configs/react.json",
+                "check_interval": 3600,
+                "enabled": True,
+                "auto_update": False,
+                "notify_on_change": True,
+                "notification_channels": ["slack", "webhook"],
+                "webhook_url": "https://example.com/webhook",
+                "slack_webhook": "https://hooks.slack.com/services/..."
+            }
+        }
+
+
+class SyncState(BaseModel):
+    """Current state of sync monitoring."""
+
+    skill_name: str = Field(..., description="Skill name")
+    last_check: Optional[datetime] = Field(None, description="Last check time")
+    last_change: Optional[datetime] = Field(None, description="Last change detected")
+    total_checks: int = Field(default=0, description="Total checks performed")
+    total_changes: int = Field(default=0, description="Total changes detected")
+    page_hashes: Dict[str, str] = Field(
+        default_factory=dict,
+        description="URL -> content hash mapping"
+    )
+    status: str = Field(default="idle", description="Current status")
+    error: Optional[str] = Field(None, description="Last error message")
+
+
+class WebhookPayload(BaseModel):
+    """Payload for webhook notifications."""
+
+    event: str = Field(..., description="Event type (change_detected, sync_complete)")
+    skill_name: str = Field(..., description="Skill name")
+    timestamp: datetime = Field(
+        default_factory=datetime.utcnow,
+        description="Event timestamp"
+    )
+    changes: Optional[ChangeReport] = Field(None, description="Change report")
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional metadata"
+    )
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "event": "change_detected",
+                "skill_name": "react",
+                "timestamp": "2024-01-15T10:30:00Z",
+                "changes": {
+                    "total_pages": 150,
+                    "added": [],
+                    "modified": [{"url": "https://react.dev/learn"}],
+                    "deleted": []
+                },
+                "metadata": {"source": "periodic_check"}
+            }
+        }

src/skill_seekers/sync/monitor.py

@@ -0,0 +1,267 @@
+"""
+Sync monitor for continuous documentation monitoring.
+"""
+
+import json
+import time
+import threading
+from pathlib import Path
+from typing import Optional, Dict, List, Callable
+from datetime import datetime
+import schedule
+
+from .detector import ChangeDetector
+from .models import SyncConfig, SyncState, ChangeReport, WebhookPayload
+from .notifier import Notifier
+
+
+class SyncMonitor:
+    """
+    Monitors documentation for changes and triggers updates.
+
+    Features:
+    - Continuous monitoring with configurable intervals
+    - State persistence (resume after restart)
+    - Change detection and diff generation
+    - Notification system
+    - Auto-update capability
+
+    Examples:
+        # Basic usage
+        monitor = SyncMonitor(
+            config_path="configs/react.json",
+            check_interval=3600
+        )
+        monitor.start()
+
+        # With auto-update
+        monitor = SyncMonitor(
+            config_path="configs/react.json",
+            auto_update=True,
+            on_change=lambda report: print(f"Detected {report.change_count} changes")
+        )
+
+        # Run once
+        changes = monitor.check_now()
+    """
+
+    def __init__(
+        self,
+        config_path: str,
+        check_interval: int = 3600,
+        auto_update: bool = False,
+        state_file: Optional[str] = None,
+        on_change: Optional[Callable[[ChangeReport], None]] = None
+    ):
+        """
+        Initialize sync monitor.
+
+        Args:
+            config_path: Path to skill config file
+            check_interval: Check interval in seconds
+            auto_update: Auto-rebuild skill on changes
+            state_file: Path to state file (default: {skill_name}_sync.json)
+            on_change: Callback function for change events
+        """
+        self.config_path = Path(config_path)
+        self.check_interval = check_interval
+        self.auto_update = auto_update
+        self.on_change = on_change
+
+        # Load skill config
+        with open(self.config_path) as f:
+            self.skill_config = json.load(f)
+
+        self.skill_name = self.skill_config.get('name', 'unknown')
+
+        # State file
+        if state_file:
+            self.state_file = Path(state_file)
+        else:
+            self.state_file = Path(f"{self.skill_name}_sync.json")
+
+        # Initialize components
+        self.detector = ChangeDetector()
+        self.notifier = Notifier()
+
+        # Load state
+        self.state = self._load_state()
+
+        # Threading
+        self._running = False
+        self._thread = None
+
+    def _load_state(self) -> SyncState:
+        """Load state from file or create new."""
+        if self.state_file.exists():
+            with open(self.state_file) as f:
+                data = json.load(f)
+                # Convert datetime strings back
+                if data.get('last_check'):
+                    data['last_check'] = datetime.fromisoformat(data['last_check'])
+                if data.get('last_change'):
+                    data['last_change'] = datetime.fromisoformat(data['last_change'])
+                return SyncState(**data)
+        else:
+            return SyncState(skill_name=self.skill_name)
+
+    def _save_state(self):
+        """Save current state to file."""
+        # Convert datetime to ISO format
+        data = self.state.dict()
+        if data.get('last_check'):
+            data['last_check'] = data['last_check'].isoformat()
+        if data.get('last_change'):
+            data['last_change'] = data['last_change'].isoformat()
+
+        with open(self.state_file, 'w') as f:
+            json.dump(data, f, indent=2)
+
+    def check_now(self, generate_diffs: bool = False) -> ChangeReport:
+        """
+        Check for changes now (synchronous).
+
+        Args:
+            generate_diffs: Whether to generate content diffs
+
+        Returns:
+            ChangeReport with detected changes
+        """
+        self.state.status = "checking"
+        self._save_state()
+
+        try:
+            # Get URLs to check from config
+            base_url = self.skill_config.get('base_url')
+            # TODO: In real implementation, get actual URLs from scraper
+
+            # For now, simulate with base URL only
+            urls = [base_url] if base_url else []
+
+            # Check for changes
+            report = self.detector.check_pages(
+                urls=urls,
+                previous_hashes=self.state.page_hashes,
+                generate_diffs=generate_diffs
+            )
+            report.skill_name = self.skill_name
+
+            # Update state
+            self.state.last_check = datetime.utcnow()
+            self.state.total_checks += 1
+
+            if report.has_changes:
+                self.state.last_change = datetime.utcnow()
+                self.state.total_changes += report.change_count
+
+                # Update hashes for modified pages
+                for change in report.added + report.modified:
+                    if change.new_hash:
+                        self.state.page_hashes[change.url] = change.new_hash
+
+                # Remove deleted pages
+                for change in report.deleted:
+                    self.state.page_hashes.pop(change.url, None)
+
+                # Trigger callback
+                if self.on_change:
+                    self.on_change(report)
+
+                # Send notifications
+                self._notify(report)
+
+                # Auto-update if enabled
+                if self.auto_update:
+                    self._trigger_update(report)
+
+            self.state.status = "idle"
+            self.state.error = None
+
+            return report
+
+        except Exception as e:
+            self.state.status = "error"
+            self.state.error = str(e)
+            raise
+        finally:
+            self._save_state()
+
+    def _notify(self, report: ChangeReport):
+        """Send notifications about changes."""
+        payload = WebhookPayload(
+            event="change_detected",
+            skill_name=self.skill_name,
+            changes=report,
+            metadata={"auto_update": self.auto_update}
+        )
+
+        self.notifier.send(payload)
+
+    def _trigger_update(self, report: ChangeReport):
+        """Trigger skill rebuild."""
+        print(f"🔄 Auto-updating {self.skill_name} due to {report.change_count} changes...")
+        # TODO: Integrate with doc_scraper to rebuild skill
+        # For now, just log
+        print(f"  Added: {len(report.added)}")
+        print(f"  Modified: {len(report.modified)}")
+        print(f"  Deleted: {len(report.deleted)}")
+
+    def start(self):
+        """Start continuous monitoring."""
+        if self._running:
+            raise RuntimeError("Monitor is already running")
+
+        self._running = True
+
+        # Schedule checks
+        schedule.every(self.check_interval).seconds.do(
+            lambda: self.check_now()
+        )
+
+        # Run in thread
+        def run_schedule():
+            while self._running:
+                schedule.run_pending()
+                time.sleep(1)
+
+        self._thread = threading.Thread(target=run_schedule, daemon=True)
+        self._thread.start()
+
+        print(f"✅ Started monitoring {self.skill_name} (every {self.check_interval}s)")
+
+        # Run first check immediately
+        self.check_now()
+
+    def stop(self):
+        """Stop monitoring."""
+        if not self._running:
+            return
+
+        self._running = False
+
+        if self._thread:
+            self._thread.join(timeout=5)
+
+        print(f"🛑 Stopped monitoring {self.skill_name}")
+
+    def stats(self) -> Dict:
+        """Get monitoring statistics."""
+        return {
+            "skill_name": self.skill_name,
+            "status": self.state.status,
+            "last_check": self.state.last_check.isoformat() if self.state.last_check else None,
+            "last_change": self.state.last_change.isoformat() if self.state.last_change else None,
+            "total_checks": self.state.total_checks,
+            "total_changes": self.state.total_changes,
+            "tracked_pages": len(self.state.page_hashes),
+            "running": self._running,
+        }
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.stop()

src/skill_seekers/sync/notifier.py

@@ -0,0 +1,144 @@
+"""
+Notification system for sync events.
+"""
+
+import os
+import requests
+from typing import Optional, List
+from .models import WebhookPayload
+
+
+class Notifier:
+    """
+    Send notifications about sync events.
+
+    Supports:
+    - Webhook (HTTP POST)
+    - Slack (via webhook)
+    - Email (SMTP) - TODO
+    - Console (stdout)
+
+    Examples:
+        notifier = Notifier()
+
+        payload = WebhookPayload(
+            event="change_detected",
+            skill_name="react",
+            changes=report
+        )
+
+        notifier.send(payload)
+    """
+
+    def __init__(
+        self,
+        webhook_url: Optional[str] = None,
+        slack_webhook: Optional[str] = None,
+        email_recipients: Optional[List[str]] = None,
+        console: bool = True
+    ):
+        """
+        Initialize notifier.
+
+        Args:
+            webhook_url: Webhook URL for HTTP notifications
+            slack_webhook: Slack webhook URL
+            email_recipients: List of email recipients
+            console: Whether to print to console
+        """
+        self.webhook_url = webhook_url or os.getenv('SYNC_WEBHOOK_URL')
+        self.slack_webhook = slack_webhook or os.getenv('SLACK_WEBHOOK_URL')
+        self.email_recipients = email_recipients or []
+        self.console = console
+
+    def send(self, payload: WebhookPayload):
+        """
+        Send notification via all configured channels.
+
+        Args:
+            payload: Notification payload
+        """
+        if self.console:
+            self._send_console(payload)
+
+        if self.webhook_url:
+            self._send_webhook(payload)
+
+        if self.slack_webhook:
+            self._send_slack(payload)
+
+        if self.email_recipients:
+            self._send_email(payload)
+
+    def _send_console(self, payload: WebhookPayload):
+        """Print to console."""
+        print(f"\n📢 {payload.event.upper()}: {payload.skill_name}")
+
+        if payload.changes:
+            changes = payload.changes
+            if changes.has_changes:
+                print(f"   Changes detected: {changes.change_count}")
+                if changes.added:
+                    print(f"   ✅ Added: {len(changes.added)} pages")
+                if changes.modified:
+                    print(f"   ✏️  Modified: {len(changes.modified)} pages")
+                if changes.deleted:
+                    print(f"   ❌ Deleted: {len(changes.deleted)} pages")
+            else:
+                print("   No changes detected")
+
+    def _send_webhook(self, payload: WebhookPayload):
+        """Send to generic webhook."""
+        try:
+            response = requests.post(
+                self.webhook_url,
+                json=payload.dict(),
+                headers={'Content-Type': 'application/json'},
+                timeout=10
+            )
+            response.raise_for_status()
+            print(f"✅ Webhook notification sent to {self.webhook_url}")
+        except Exception as e:
+            print(f"❌ Failed to send webhook: {e}")
+
+    def _send_slack(self, payload: WebhookPayload):
+        """Send to Slack via webhook."""
+        try:
+            # Format Slack message
+            text = f"*{payload.event.upper()}*: {payload.skill_name}"
+
+            if payload.changes and payload.changes.has_changes:
+                changes = payload.changes
+                text += f"\n• Changes: {changes.change_count}"
+                text += f"\n• Added: {len(changes.added)}"
+                text += f"\n• Modified: {len(changes.modified)}"
+                text += f"\n• Deleted: {len(changes.deleted)}"
+
+                # Add URLs of changed pages
+                if changes.modified:
+                    text += "\n\n*Modified Pages:*"
+                    for change in changes.modified[:5]:  # Limit to 5
+                        text += f"\n• {change.url}"
+                    if len(changes.modified) > 5:
+                        text += f"\n• ...and {len(changes.modified) - 5} more"
+
+            slack_payload = {
+                "text": text,
+                "username": "Skill Seekers Sync",
+                "icon_emoji": ":books:"
+            }
+
+            response = requests.post(
+                self.slack_webhook,
+                json=slack_payload,
+                timeout=10
+            )
+            response.raise_for_status()
+            print("✅ Slack notification sent")
+        except Exception as e:
+            print(f"❌ Failed to send Slack notification: {e}")
+
+    def _send_email(self, payload: WebhookPayload):
+        """Send email notification."""
+        # TODO: Implement SMTP email sending
+        print(f"📧 Email notification (not implemented): {self.email_recipients}")