diff --git a/.github/IMPLEMENTATION_SUMMARY.md b/.github/IMPLEMENTATION_SUMMARY.md
new file mode 100644
index 0000000000..d52063ac70
--- /dev/null
+++ b/.github/IMPLEMENTATION_SUMMARY.md
@@ -0,0 +1,283 @@
+# GitHub Actions & Self-Hosted Runners - Implementation Summary
+
+This document summarizes the comprehensive GitHub Actions workflows and self-hosted runner infrastructure implemented for this repository.
+
+## What Was Implemented
+
+### 1. Self-Hosted Runner Management Workflows
+
+#### `self-hosted-runner-setup.yml`
+- **Purpose:** Manual runner management and diagnostics
+- **Features:**
+  - Health checks on demand
+  - Runner information display
+  - System diagnostics (disk, memory, CPU)
+  - Instructions for runner configuration
+- **Trigger:** Manual (workflow_dispatch)
+
+#### `self-hosted-runner-health.yml`
+- **Purpose:** Automated runner health monitoring
+- **Features:**
+  - Scheduled weekly health checks (Mondays 9 AM UTC)
+  - Disk space monitoring with alerts
+  - Memory usage tracking
+  - Verification of required tools (Node.js, Yarn, Docker)
+  - Automatic cleanup of old artifacts
+- **Trigger:** Manual + Weekly schedule
+
+#### `self-hosted-example.yml`
+- **Purpose:** Reference implementation for self-hosted runner usage
+- **Features:**
+  - Dynamic runner selection (GitHub-hosted vs self-hosted)
+  - Mixed strategy (quick checks on GitHub-hosted, heavy builds on self-hosted)
+  - Examples for GPU workloads
+  - Integration test patterns
+  - Job dependency management
+- **Trigger:** Manual with configurable runner type
+
+### 2. Comprehensive Documentation
+
+#### `SELF_HOSTED_RUNNERS.md` (12.8 KB)
+Complete guide covering:
+- When to use self-hosted vs GitHub-hosted runners
+- Prerequisites and hardware requirements
+- Step-by-step setup instructions for Linux/macOS/Windows
+- Runner configuration (labels, groups, environment variables)
+- Security best practices (critical for production use)
+- Monitoring and maintenance procedures
+- Auto-scaling strategies (Kubernetes, cloud providers)
+- Troubleshooting common issues
+- Example workflow patterns
+
+#### `SELF_HOSTED_RUNNERS_QUICKSTART.md` (3.2 KB)
+Quick reference guide with:
+- Condensed setup steps
+- Essential commands
+- Security checklist
+- Common troubleshooting
+- Links to detailed documentation
+
+#### `workflows/README.md` (7.3 KB)
+Central documentation for all workflows:
+- Overview of all workflows in the repository
+- Trigger conditions and timeouts
+- Runner configurations
+- Best practices implementation
+- Usage instructions
+- Troubleshooting guide
+
+#### Updated `WORKFLOWS_BEST_PRACTICES.md`
+Added comprehensive section on:
+- When to use self-hosted runners
+- Self-hosted runner best practices
+- Security considerations
+- Monitoring strategies
+- Fallback patterns
+
+### 3. Enhanced .gitignore
+
+Added GitHub Actions runner-specific entries:
+```gitignore
+# GitHub Actions and Runners
+.github/actions-runner/
+actions-runner/
+_work/
+_diag/
+runner-config.local.yml
+.runner
+.credentials
+.credentials_rsaparams
+runner.env
+.env.runner
+```
+
+This prevents accidentally committing:
+- Runner binaries and configuration
+- Runner credentials
+- Work directories with sensitive data
+- Diagnostic files
+
+## Existing Workflows (Already Implemented)
+
+The repository already had excellent workflows following best practices:
+
+1. **node.js.yml** - Node.js CI (build & lint)
+2. **main.yml** - Unit tests
+3. **e2e-tests.yml** - End-to-end tests with Playwright
+4. **bearer.yml** - Security scanning
+5. **file-size-checker.yml** - Large file detection
+6. **update-algolia.yml** - Search index updates
+
+All existing workflows include:
+- ✅ Latest action versions (checkout@v4, setup-node@v4)
+- ✅ Explicit minimal permissions
+- ✅ Concurrency control
+- ✅ Appropriate timeouts
+- ✅ Efficient caching with Yarn
+
+## Security Highlights
+
+### Critical Security Practices Documented
+
+1. **Never use self-hosted runners for public repositories** ⚠️
+   - Malicious code in forks can compromise runners
+   - Clearly documented with warnings
+
+2. **Run runners as unprivileged users**
+   - Instructions for creating dedicated users
+   - Prevents privilege escalation
+
+3. **Network isolation**
+   - Firewall configuration guidance
+   - Proxy setup instructions
+
+4. **Ephemeral runners**
+   - Disposable runners for sensitive operations
+   - Configuration examples provided
+
+5. **Regular updates**
+   - Automated health monitoring
+   - Update procedures documented
+
+6. **Access control**
+   - Runner groups for organization-level access control
+   - Repository-specific runner configurations
+
+## Usage Patterns
+
+### For GitHub-Hosted Runners (Current Default)
+```yaml
+runs-on: ubuntu-latest
+```
+- All current workflows use this
+- Suitable for most standard operations
+- No additional setup required
+
+### For Self-Hosted Runners (When Configured)
+```yaml
+runs-on: [self-hosted, linux, x64]
+```
+- Opt-in per workflow/job
+- Requires runner setup (see docs)
+- Recommended for resource-intensive jobs
+
+### Mixed Strategy (Recommended)
+```yaml
+jobs:
+  quick-checks:
+    runs-on: ubuntu-latest  # Fast, minimal setup
+  
+  heavy-build:
+    runs-on: [self-hosted, linux]  # Resource-intensive
+```
+
+## Getting Started with Self-Hosted Runners
+
+For users wanting to set up self-hosted runners:
+
+1. **Read the documentation**
+   - Start with `SELF_HOSTED_RUNNERS_QUICKSTART.md`
+   - Review security section in `SELF_HOSTED_RUNNERS.md`
+
+2. **Prepare infrastructure**
+   - Dedicated machine (VM or physical)
+   - Minimum 4 GB RAM, 20 GB disk
+   - Network access to GitHub
+
+3. **Follow setup guide**
+   - Repository Settings → Actions → Runners → New self-hosted runner
+   - Follow GitHub's provided commands
+   - Install required dependencies (Node.js, Yarn)
+
+4. **Test the setup**
+   - Run `self-hosted-runner-setup.yml` workflow
+   - Choose "health-check" action
+   - Verify all checks pass
+
+5. **Update workflows**
+   - Modify `runs-on` in workflows as needed
+   - Use `self-hosted-example.yml` as reference
+   - Test with small changes first
+
+## Monitoring and Maintenance
+
+### Automated Monitoring
+- Weekly health checks via `self-hosted-runner-health.yml`
+- Alerts for disk space, memory issues
+- Runner process verification
+
+### Manual Checks
+- On-demand via `self-hosted-runner-setup.yml`
+- Health check action
+- Runner information display
+
+### Maintenance Schedule
+- **Weekly:** Check runner status, review logs
+- **Monthly:** Update runner version, clean artifacts
+- **Quarterly:** Security audit, OS updates
+
+## Benefits
+
+### Current Setup (GitHub-Hosted)
+- ✅ Zero maintenance
+- ✅ Automatic updates
+- ✅ Isolated environments
+- ✅ Suitable for public repositories
+
+### With Self-Hosted Runners (When Configured)
+- ✅ Custom hardware/software
+- ✅ Network access to private resources
+- ✅ Cost optimization for high volumes
+- ✅ More resources (CPU, memory, disk)
+- ✅ Reduced queue times
+
+## File Structure
+
+```
+.github/
+├── workflows/
+│   ├── README.md                           # All workflows documentation
+│   ├── self-hosted-runner-setup.yml        # Manual runner management
+│   ├── self-hosted-runner-health.yml       # Automated health monitoring
+│   ├── self-hosted-example.yml             # Example implementation
+│   ├── node.js.yml                         # Existing: Build & lint
+│   ├── main.yml                            # Existing: Unit tests
+│   ├── e2e-tests.yml                       # Existing: E2E tests
+│   ├── bearer.yml                          # Existing: Security scan
+│   ├── file-size-checker.yml               # Existing: File size check
+│   └── update-algolia.yml                  # Existing: Search updates
+├── actions/
+│   └── setup-node-yarn/                    # Existing: Composite action
+├── WORKFLOWS_BEST_PRACTICES.md             # Enhanced: Added self-hosted section
+├── SELF_HOSTED_RUNNERS.md                  # New: Complete guide
+└── SELF_HOSTED_RUNNERS_QUICKSTART.md       # New: Quick reference
+```
+
+## Next Steps
+
+### Immediate (No Self-Hosted Runners Yet)
+- ✅ All workflows work with GitHub-hosted runners
+- ✅ Documentation is ready for future self-hosted setup
+- ✅ Example workflows demonstrate patterns
+- ✅ Monitoring infrastructure in place
+
+### When Ready to Add Self-Hosted Runners
+1. Review security requirements
+2. Provision hardware/VMs
+3. Follow setup guide
+4. Test with example workflow
+5. Uncomment self-hosted jobs in health monitoring
+6. Gradually migrate resource-intensive jobs
+
+## Conclusion
+
+This implementation provides:
+
+1. **Complete self-hosted runner infrastructure** ready to use when needed
+2. **Comprehensive documentation** covering all aspects of setup, security, and maintenance
+3. **Automated monitoring** to ensure runner health
+4. **Example workflows** demonstrating best practices
+5. **Enhanced security** through improved .gitignore
+6. **Flexibility** to use GitHub-hosted or self-hosted runners per workflow/job
+
+The repository now has enterprise-grade CI/CD infrastructure with clear paths for scaling as needs grow.
diff --git a/.github/SELF_HOSTED_RUNNERS.md b/.github/SELF_HOSTED_RUNNERS.md
new file mode 100644
index 0000000000..13408a4a32
--- /dev/null
+++ b/.github/SELF_HOSTED_RUNNERS.md
@@ -0,0 +1,523 @@
+# Self-Hosted Runners Guide
+
+This guide provides comprehensive instructions for setting up, configuring, and managing self-hosted GitHub Actions runners for the repository.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [When to Use Self-Hosted Runners](#when-to-use-self-hosted-runners)
+- [Prerequisites](#prerequisites)
+- [Setting Up Self-Hosted Runners](#setting-up-self-hosted-runners)
+- [Runner Configuration](#runner-configuration)
+- [Security Best Practices](#security-best-practices)
+- [Monitoring and Maintenance](#monitoring-and-maintenance)
+- [Scaling Runners](#scaling-runners)
+- [Troubleshooting](#troubleshooting)
+
+## Overview
+
+Self-hosted runners give you more control over the hardware, operating system, and software tools used in your CI/CD workflows. They're particularly useful for:
+
+- Resource-intensive builds
+- Access to specific hardware or software
+- Network restrictions requiring on-premises execution
+- Cost optimization for high-volume workflows
+- Custom security requirements
+
+## When to Use Self-Hosted Runners
+
+### Use Self-Hosted Runners For:
+
+- **Long-running jobs** that exceed GitHub-hosted runner time limits
+- **Large builds** requiring more CPU, memory, or disk space
+- **Private network access** when workflows need internal resources
+- **Custom software/hardware** not available on GitHub-hosted runners
+- **Cost optimization** when running many workflows
+- **GPU workloads** or specialized hardware requirements
+
+### Use GitHub-Hosted Runners For:
+
+- **Standard builds** with common requirements
+- **Public repositories** to reduce maintenance burden
+- **Occasional workflows** with low resource usage
+- **Security-sensitive operations** benefiting from GitHub's isolation
+
+## Prerequisites
+
+Before setting up self-hosted runners, ensure you have:
+
+- [ ] Repository admin access or organization owner permissions
+- [ ] A dedicated machine (physical or virtual) for the runner
+- [ ] Supported operating system (Linux, macOS, or Windows)
+- [ ] Minimum hardware requirements:
+  - 2 CPU cores (4+ recommended)
+  - 4 GB RAM (8+ GB recommended for builds)
+  - 20 GB free disk space (50+ GB recommended)
+- [ ] Stable network connectivity
+- [ ] Administrative access to install software
+
+## Setting Up Self-Hosted Runners
+
+### Step 1: Add a Self-Hosted Runner
+
+#### For Repository-Level Runners:
+
+1. Go to your repository on GitHub
+2. Click **Settings** → **Actions** → **Runners**
+3. Click **New self-hosted runner**
+4. Select the operating system and architecture
+5. Follow the provided installation commands
+
+#### For Organization-Level Runners:
+
+1. Go to your organization on GitHub
+2. Click **Settings** → **Actions** → **Runners**
+3. Click **New runner** → **New self-hosted runner**
+4. Select the operating system and architecture
+5. Follow the provided installation commands
+
+### Step 2: Download and Configure
+
+#### Linux/macOS
+
+```bash
+# Create a folder for the runner
+mkdir actions-runner && cd actions-runner
+
+# Download the latest runner package
+curl -o actions-runner-linux-x64-2.311.0.tar.gz -L \
+  https://github.com/actions/runner/releases/download/v2.311.0/actions-runner-linux-x64-2.311.0.tar.gz
+
+# Extract the installer
+tar xzf ./actions-runner-linux-x64-2.311.0.tar.gz
+
+# Configure the runner
+./config.sh --url https://github.com/YOUR-ORG/YOUR-REPO \
+  --token YOUR-REGISTRATION-TOKEN
+
+# Optional: Configure runner as a service
+sudo ./svc.sh install
+sudo ./svc.sh start
+```
+
+#### Windows
+
+```powershell
+# Create a folder under the drive root
+mkdir actions-runner; cd actions-runner
+
+# Download the latest runner package
+Invoke-WebRequest -Uri https://github.com/actions/runner/releases/download/v2.311.0/actions-runner-win-x64-2.311.0.zip -OutFile actions-runner-win-x64-2.311.0.zip
+
+# Extract the installer
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+[System.IO.Compression.ZipFile]::ExtractToDirectory("$PWD/actions-runner-win-x64-2.311.0.zip", "$PWD")
+
+# Configure the runner
+./config.cmd --url https://github.com/YOUR-ORG/YOUR-REPO --token YOUR-REGISTRATION-TOKEN
+
+# Install and start the service
+./svc.cmd install
+./svc.cmd start
+```
+
+### Step 3: Install Dependencies
+
+Install required software for your workflows:
+
+```bash
+# Example for Node.js project
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
+nvm install 24
+nvm use 24
+
+# Enable Corepack for Yarn
+corepack enable
+
+# Install Docker (if needed)
+curl -fsSL https://get.docker.com -o get-docker.sh
+sudo sh get-docker.sh
+
+# Add runner user to docker group
+sudo usermod -aG docker $USER
+```
+
+## Runner Configuration
+
+### Runner Labels
+
+Labels help route jobs to specific runners. Configure labels during setup:
+
+```bash
+./config.sh --url https://github.com/YOUR-ORG/YOUR-REPO \
+  --token YOUR-TOKEN \
+  --labels linux,x64,gpu,high-memory
+```
+
+Common label patterns:
+- OS: `linux`, `windows`, `macos`
+- Architecture: `x64`, `arm64`
+- Capabilities: `gpu`, `docker`, `kubernetes`
+- Environment: `prod`, `staging`, `dev`
+- Performance: `high-memory`, `high-cpu`
+
+### Runner Groups (Organization Only)
+
+Organize runners into groups for access control:
+
+1. Go to **Organization Settings** → **Actions** → **Runner groups**
+2. Create groups (e.g., `Production`, `Development`, `GPU`)
+3. Add runners to appropriate groups
+4. Configure repository access per group
+
+### Environment Variables
+
+Set environment variables for all jobs:
+
+```bash
+# Create .env file in runner directory
+cat > .env << EOF
+RUNNER_ALLOW_RUNASROOT=1
+RUNNER_NAME=my-runner-01
+CUSTOM_ENV_VAR=value
+EOF
+
+# Load in config
+./config.sh --url ... --token ... --env .env
+```
+
+## Security Best Practices
+
+### Critical Security Measures
+
+1. **Never use self-hosted runners for public repositories**
+   - Malicious code in forks can compromise runners
+   - GitHub-hosted runners are isolated for public repos
+
+2. **Run runners as unprivileged users**
+   ```bash
+   # Create dedicated user
+   sudo useradd -m -s /bin/bash github-runner
+   sudo su - github-runner
+   # Continue setup as this user
+   ```
+
+3. **Restrict network access**
+   - Use firewall rules to limit outbound connections
+   - Whitelist only required domains
+   - Consider using a proxy
+
+4. **Keep runners updated**
+   ```bash
+   # Check for updates
+   ./run.sh --check
+   
+   # The runner auto-updates, but verify manually:
+   ./config.sh --check
+   ```
+
+5. **Use secrets securely**
+   - Store secrets in GitHub Secrets, not in runner config
+   - Limit secret access to specific runners via runner groups
+   - Regularly rotate secrets
+
+6. **Monitor runner activity**
+   - Enable audit logs
+   - Monitor for suspicious activity
+   - Review job logs regularly
+
+7. **Isolate runners**
+   - Use containers or VMs for job execution
+   - Don't share runners across trust boundaries
+   - Consider ephemeral runners for sensitive operations
+
+### Runner Isolation with Docker
+
+Run jobs in containers for isolation:
+
+```yaml
+jobs:
+  build:
+    runs-on: [self-hosted, linux]
+    container:
+      image: node:24
+      options: --cpus 2 --memory 4g
+    steps:
+      - uses: actions/checkout@v4
+      - run: yarn install
+      - run: yarn build
+```
+
+### Ephemeral Runners
+
+For maximum security, use ephemeral runners that are destroyed after each job:
+
+```bash
+# Start runner in ephemeral mode
+./run.sh --once
+
+# Or configure as service with auto-deregistration
+./config.sh --url ... --token ... --ephemeral
+```
+
+## Monitoring and Maintenance
+
+### Health Monitoring
+
+Use the provided workflows to monitor runner health:
+
+1. **Self-Hosted Runner Health Monitor** (`self-hosted-runner-health.yml`)
+   - Scheduled weekly checks
+   - Monitors disk space, memory, CPU
+   - Alerts on issues
+
+2. **Self-Hosted Runner Setup** (`self-hosted-runner-setup.yml`)
+   - Manual health checks
+   - Runner information display
+   - On-demand diagnostics
+
+### Maintenance Tasks
+
+#### Weekly Tasks
+
+- [ ] Check runner status in GitHub UI
+- [ ] Review workflow run times
+- [ ] Check disk space usage
+- [ ] Review security logs
+
+#### Monthly Tasks
+
+- [ ] Update runner version
+- [ ] Update dependencies (Node.js, Docker, etc.)
+- [ ] Review and update runner labels
+- [ ] Clean up old caches and artifacts
+
+#### Quarterly Tasks
+
+- [ ] Review security configurations
+- [ ] Update OS and security patches
+- [ ] Review runner group assignments
+- [ ] Audit runner access logs
+
+### Automated Cleanup
+
+Add cleanup to workflows:
+
+```yaml
+jobs:
+  cleanup:
+    runs-on: [self-hosted, linux]
+    steps:
+      - name: Clean workspace
+        run: |
+          rm -rf _work/*
+          docker system prune -af --volumes
+```
+
+Or run periodic cleanup:
+
+```bash
+# Crontab entry for nightly cleanup
+0 2 * * * /home/github-runner/cleanup.sh
+
+# cleanup.sh
+#!/bin/bash
+find /home/github-runner/_work -type f -mtime +7 -delete
+docker system prune -af --filter "until=168h"
+```
+
+## Scaling Runners
+
+### Horizontal Scaling
+
+Add multiple runners for increased capacity:
+
+```bash
+# Runner 1
+./config.sh --name runner-01 --labels linux,x64,pool-1
+./svc.sh install runner-01
+./svc.sh start runner-01
+
+# Runner 2
+./config.sh --name runner-02 --labels linux,x64,pool-1
+./svc.sh install runner-02
+./svc.sh start runner-02
+```
+
+### Auto-Scaling
+
+Use auto-scaling solutions for dynamic capacity:
+
+#### Using Kubernetes
+
+- **Actions Runner Controller (ARC)**
+  - https://github.com/actions/actions-runner-controller
+  - Kubernetes-native auto-scaling
+
+```bash
+helm repo add actions-runner-controller https://actions-runner-controller.github.io/actions-runner-controller
+helm install actions-runner-controller/actions-runner-controller \
+  --namespace actions-runner-system \
+  --create-namespace \
+  --set authSecret.github_token=YOUR_GITHUB_TOKEN
+```
+
+#### Using Cloud Providers
+
+- **AWS**: Use Auto Scaling Groups with custom AMIs
+- **Azure**: Use Scale Sets with runner images
+- **GCP**: Use Managed Instance Groups
+
+### Load Balancing
+
+Distribute work across runners:
+
+```yaml
+jobs:
+  build:
+    runs-on: [self-hosted, linux, pool-1]  # Multiple runners with same labels
+    strategy:
+      matrix:
+        shard: [1, 2, 3, 4]
+    steps:
+      - run: yarn test --shard=${{ matrix.shard }}/4
+```
+
+## Troubleshooting
+
+### Common Issues
+
+#### Runner Not Connecting
+
+```bash
+# Check runner status
+./run.sh --check
+
+# View logs
+journalctl -u actions.runner.*.service -f
+
+# Check network connectivity
+curl -I https://api.github.com
+```
+
+#### Out of Disk Space
+
+```bash
+# Check disk usage
+df -h
+
+# Clean Docker
+docker system prune -af --volumes
+
+# Clean old workflows
+rm -rf _work/_tool/*
+rm -rf _work/_temp/*
+```
+
+#### Permission Issues
+
+```bash
+# Fix ownership
+sudo chown -R github-runner:github-runner /home/github-runner/actions-runner
+
+# Fix permissions
+chmod +x run.sh config.sh
+```
+
+#### Runner Service Won't Start
+
+```bash
+# Check service status
+sudo systemctl status actions.runner.*.service
+
+# View service logs
+sudo journalctl -u actions.runner.*.service -n 100
+
+# Restart service
+sudo systemctl restart actions.runner.*.service
+```
+
+### Debug Mode
+
+Enable debug logging:
+
+```bash
+# Set environment variable
+export ACTIONS_RUNNER_DEBUG=true
+export ACTIONS_STEP_DEBUG=true
+
+# Or in workflow
+env:
+  ACTIONS_RUNNER_DEBUG: true
+  ACTIONS_STEP_DEBUG: true
+```
+
+### Getting Help
+
+- GitHub Actions documentation: https://docs.github.com/en/actions
+- Runner repository: https://github.com/actions/runner
+- Community forum: https://github.community/c/code-to-cloud/52
+
+## Workflow Examples
+
+### Using Self-Hosted Runners
+
+```yaml
+name: Build on Self-Hosted
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    # Use self-hosted runner
+    runs-on: [self-hosted, linux, x64]
+    
+    steps:
+      - uses: actions/checkout@v4
+      - run: yarn install
+      - run: yarn build
+```
+
+### Mixed Runners
+
+```yaml
+jobs:
+  # Fast check on GitHub-hosted
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: yarn lint
+
+  # Heavy build on self-hosted
+  build:
+    runs-on: [self-hosted, linux, high-cpu]
+    steps:
+      - uses: actions/checkout@v4
+      - run: yarn build
+
+  # Tests on self-hosted with GPU
+  test-gpu:
+    runs-on: [self-hosted, linux, gpu]
+    steps:
+      - uses: actions/checkout@v4
+      - run: yarn test:gpu
+```
+
+### Fallback to GitHub-Hosted
+
+```yaml
+jobs:
+  build:
+    # Try self-hosted, fallback to GitHub-hosted
+    runs-on: ${{ contains(github.event.pull_request.labels.*.name, 'use-self-hosted') && 'self-hosted' || 'ubuntu-latest' }}
+    steps:
+      - uses: actions/checkout@v4
+      - run: yarn build
+```
+
+## Conclusion
+
+Self-hosted runners provide flexibility and control but require careful setup and maintenance. Follow this guide to ensure your runners are secure, reliable, and efficient.
+
+For questions or issues, refer to the [GitHub Actions documentation](https://docs.github.com/en/actions) or contact your repository administrators.
diff --git a/.github/SELF_HOSTED_RUNNERS_QUICKSTART.md b/.github/SELF_HOSTED_RUNNERS_QUICKSTART.md
new file mode 100644
index 0000000000..334ba71a88
--- /dev/null
+++ b/.github/SELF_HOSTED_RUNNERS_QUICKSTART.md
@@ -0,0 +1,141 @@
+# Quick Start: Self-Hosted Runners
+
+This is a quick reference guide for setting up self-hosted runners. For complete documentation, see [SELF_HOSTED_RUNNERS.md](SELF_HOSTED_RUNNERS.md).
+
+## Prerequisites
+
+- Repository admin access
+- Linux/macOS/Windows machine with:
+  - 4+ GB RAM
+  - 20+ GB disk space
+  - Network connectivity to GitHub
+
+## Setup Steps
+
+### 1. Navigate to Runner Settings
+
+**For Repository:**
+1. Go to repository → Settings → Actions → Runners
+2. Click "New self-hosted runner"
+
+**For Organization:**
+1. Go to organization → Settings → Actions → Runners
+2. Click "New runner" → "New self-hosted runner"
+
+### 2. Download and Configure (Linux/macOS)
+
+```bash
+# Create directory
+mkdir actions-runner && cd actions-runner
+
+# Download (check GitHub UI for latest version)
+curl -o actions-runner-linux-x64-2.311.0.tar.gz -L \
+  https://github.com/actions/runner/releases/download/v2.311.0/actions-runner-linux-x64-2.311.0.tar.gz
+
+# Extract
+tar xzf ./actions-runner-linux-x64-2.311.0.tar.gz
+
+# Configure (use token from GitHub UI)
+./config.sh --url https://github.com/YOUR-ORG/YOUR-REPO --token YOUR-TOKEN
+
+# Install as service
+sudo ./svc.sh install
+sudo ./svc.sh start
+```
+
+### 3. Install Required Software
+
+```bash
+# Node.js (via nvm)
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
+nvm install 24
+nvm use 24
+
+# Yarn (via Corepack)
+corepack enable
+
+# Docker (optional)
+curl -fsSL https://get.docker.com -o get-docker.sh
+sudo sh get-docker.sh
+```
+
+### 4. Add Labels
+
+Configure labels during setup or add later:
+```bash
+./config.sh --url ... --token ... --labels linux,x64,docker
+```
+
+### 5. Use in Workflows
+
+Update workflow files to use your runner:
+
+```yaml
+jobs:
+  build:
+    runs-on: [self-hosted, linux, x64]
+    steps:
+      - uses: actions/checkout@v4
+      - run: yarn build
+```
+
+## Testing
+
+Use the provided workflows to test your setup:
+
+```bash
+# Manual test via GitHub UI:
+# Actions → Self-Hosted Runner Setup → Run workflow → Select "health-check"
+```
+
+## Security Checklist
+
+- [ ] **Never use on public repositories**
+- [ ] Run as non-root user
+- [ ] Use runner groups for access control
+- [ ] Keep runner software updated
+- [ ] Monitor runner logs
+- [ ] Use ephemeral runners for sensitive workloads
+
+## Monitoring
+
+The repository includes automated monitoring:
+
+- **Weekly health checks**: `self-hosted-runner-health.yml` (Mondays 9 AM UTC)
+- **Manual checks**: `self-hosted-runner-setup.yml` (on-demand)
+
+## Common Issues
+
+**Runner offline:**
+```bash
+sudo systemctl status actions.runner.*.service
+sudo systemctl restart actions.runner.*.service
+```
+
+**Out of disk space:**
+```bash
+# Clean Docker
+docker system prune -af --volumes
+
+# Clean old builds
+rm -rf _work/_tool/*
+rm -rf _work/_temp/*
+```
+
+**Permission errors:**
+```bash
+sudo chown -R $USER:$USER /path/to/actions-runner
+chmod +x run.sh config.sh
+```
+
+## Resources
+
+- [Complete documentation](SELF_HOSTED_RUNNERS.md)
+- [Best practices](WORKFLOWS_BEST_PRACTICES.md)
+- [GitHub docs](https://docs.github.com/en/actions/hosting-your-own-runners)
+
+## Need Help?
+
+- Check logs: `journalctl -u actions.runner.*.service -f`
+- Review runner status in GitHub UI
+- See troubleshooting in [SELF_HOSTED_RUNNERS.md](SELF_HOSTED_RUNNERS.md)
diff --git a/.github/WORKFLOWS_BEST_PRACTICES.md b/.github/WORKFLOWS_BEST_PRACTICES.md
index 2162c95880..45dcf67840 100644
--- a/.github/WORKFLOWS_BEST_PRACTICES.md
+++ b/.github/WORKFLOWS_BEST_PRACTICES.md
@@ -171,8 +171,64 @@ When creating a new workflow, ensure you:
 - Monitor workflow run times and adjust timeouts if needed
 - Check GitHub's changelog for Actions updates
 
+## Self-Hosted Runners
+
+### When to Use Self-Hosted Runners
+
+Self-hosted runners provide additional control and can be beneficial for:
+
+- **Resource-intensive builds**: Jobs requiring more CPU, memory, or disk space than GitHub-hosted runners provide
+- **Long-running jobs**: Tasks that exceed GitHub-hosted runner time limits
+- **Custom hardware/software**: Access to specific tools, hardware (GPUs), or software not available on GitHub-hosted runners
+- **Network requirements**: Access to internal resources or private networks
+- **Cost optimization**: High-volume workflows that would be more cost-effective on owned infrastructure
+
+### Self-Hosted Runner Best Practices
+
+1. **Security First**
+   - **Never use self-hosted runners for public repositories** (risk of malicious code execution)
+   - Run runners as unprivileged users
+   - Use runner groups for access control
+   - Enable ephemeral runners for sensitive operations
+   - Regularly update runner software and dependencies
+
+2. **Use Appropriate Labels**
+   ```yaml
+   runs-on: [self-hosted, linux, x64, high-memory]
+   ```
+   - Include OS, architecture, and capability labels
+   - Create meaningful labels for routing jobs
+
+3. **Monitor Runner Health**
+   - Use provided health check workflows
+   - Monitor disk space, memory, and CPU usage
+   - Set up alerting for runner failures
+   - Review logs regularly
+
+4. **Maintain Runners**
+   - Regular updates of runner software
+   - Clean up old caches and artifacts
+   - Monitor for security updates
+   - Schedule maintenance windows
+
+5. **Fallback Strategy**
+   ```yaml
+   runs-on: ${{ github.event_name == 'schedule' && 'self-hosted' || 'ubuntu-latest' }}
+   ```
+   - Consider fallback to GitHub-hosted runners
+   - Use labels to route specific jobs
+
+### Available Self-Hosted Runner Workflows
+
+- **self-hosted-runner-setup.yml**: Manual runner management and health checks
+- **self-hosted-runner-health.yml**: Automated health monitoring (weekly schedule)
+
+For detailed setup instructions, see [SELF_HOSTED_RUNNERS.md](SELF_HOSTED_RUNNERS.md).
+
 ## Resources
 
 - [GitHub Actions Documentation](https://docs.github.com/en/actions)
 - [GitHub Actions Best Practices](https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions)
 - [Workflow Syntax Reference](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions)
+- [Self-Hosted Runners Guide](SELF_HOSTED_RUNNERS.md)
+- [Self-Hosted Runners Documentation](https://docs.github.com/en/actions/hosting-your-own-runners)
diff --git a/.github/workflows/README.md b/.github/workflows/README.md
new file mode 100644
index 0000000000..4c3abad9d0
--- /dev/null
+++ b/.github/workflows/README.md
@@ -0,0 +1,247 @@
+# GitHub Actions Workflows
+
+This directory contains all GitHub Actions workflows for the repository. Each workflow is designed with best practices including proper permissions, timeouts, and concurrency control.
+
+## Core Workflows
+
+### CI/CD Workflows
+
+#### `node.js.yml` - Node.js CI
+**Triggers:** Push and Pull Requests to master  
+**Purpose:** Builds and lints the codebase  
+**Runner:** GitHub-hosted (ubuntu-latest)  
+**Timeout:** 30 minutes
+
+Runs on every push and PR to ensure code quality through linting and building.
+
+#### `main.yml` - Unit Tests
+**Triggers:** Push and Pull Requests to master  
+**Purpose:** Runs Jest unit tests  
+**Runner:** GitHub-hosted (ubuntu-latest)  
+**Timeout:** 20 minutes
+
+Executes the test suite to validate code changes.
+
+#### `e2e-tests.yml` - E2E Tests
+**Triggers:** Push and Pull Requests to master  
+**Purpose:** Runs end-to-end tests with Playwright  
+**Runner:** GitHub-hosted (ubuntu-latest)  
+**Timeout:** 60 minutes
+
+Comprehensive E2E testing including:
+- MetaMask extension preparation
+- Foundry installation for smart contract testing
+- Playwright browser installation
+- Full application build and test
+
+### Quality & Security Workflows
+
+#### `bearer.yml` - Bearer Security Scanning
+**Triggers:** Push, Pull Requests, and Weekly Schedule (Thursday 4:41 AM)  
+**Purpose:** Scans code for security vulnerabilities  
+**Runner:** GitHub-hosted (ubuntu-latest)  
+**Timeout:** 15 minutes  
+**Permissions:** `contents: read`, `security-events: write`, `actions: read`
+
+Uses Bearer CLI to scan for security issues and uploads results to GitHub Security.
+
+#### `file-size-checker.yml` - File Size Checker
+**Triggers:** Pull Request opened or synchronized  
+**Purpose:** Validates file sizes to prevent large files in git  
+**Runner:** GitHub-hosted (ubuntu-latest)  
+**Timeout:** 10 minutes  
+**Permissions:** `contents: read`, `pull-requests: write`, `statuses: write`
+
+Checks for:
+- Files over 40MB (blocks merge)
+- Files over 10MB (warns)
+
+### Maintenance Workflows
+
+#### `update-algolia.yml` - Update Algolia Search
+**Triggers:** Manual dispatch and Weekday Schedule (8:05 AM)  
+**Purpose:** Updates Algolia search indices  
+**Runner:** GitHub-hosted (ubuntu-latest)  
+**Timeout:** 20 minutes
+
+Keeps search functionality up to date with latest content.
+
+## Self-Hosted Runner Workflows
+
+### `self-hosted-runner-setup.yml` - Self-Hosted Runner Setup
+**Triggers:** Manual dispatch  
+**Purpose:** Manages and checks self-hosted runners  
+**Runner:** GitHub-hosted (ubuntu-latest)  
+**Timeout:** 10 minutes
+
+Provides tools for:
+- Health checks
+- Runner information display
+- Runner list viewing
+
+**Usage:**
+```bash
+# Trigger via GitHub UI: Actions → Self-Hosted Runner Setup → Run workflow
+# Select action: health-check, list-runners, or runner-info
+```
+
+### `self-hosted-runner-health.yml` - Self-Hosted Runner Health Monitor
+**Triggers:** Manual dispatch and Weekly Schedule (Monday 9 AM)  
+**Purpose:** Automated health monitoring for runners  
+**Runner:** GitHub-hosted (ubuntu-latest)  
+**Timeout:** 5-10 minutes
+
+Monitors:
+- Disk space usage
+- Memory availability
+- CPU resources
+- Docker status
+- Runner processes
+
+**Note:** Self-hosted jobs are commented out. Uncomment when self-hosted runners are configured.
+
+### `self-hosted-example.yml` - Build with Self-Hosted (Example)
+**Triggers:** Manual dispatch  
+**Purpose:** Demonstrates self-hosted runner usage patterns  
+**Runner:** Configurable (GitHub-hosted by default)  
+**Timeout:** 10-30 minutes
+
+Shows:
+- Dynamic runner selection
+- Mixed runner strategies (GitHub-hosted for quick checks, self-hosted for heavy builds)
+- GPU job examples
+- Integration test patterns
+
+**Usage:**
+```bash
+# Trigger via GitHub UI: Actions → Build with Self-Hosted (Example) → Run workflow
+# Check "Use self-hosted runners" to test with self-hosted runners
+```
+
+## Workflow Features
+
+### Best Practices Implemented
+
+All workflows include:
+
+1. **Explicit Permissions**: Minimal permissions following principle of least privilege
+2. **Concurrency Control**: Prevents multiple simultaneous runs on same branch
+3. **Timeouts**: Prevents runaway jobs from consuming resources
+4. **Latest Actions**: Uses latest stable versions (checkout@v4, setup-node@v4)
+5. **Caching**: Optimized dependency caching with Yarn
+
+### Composite Actions
+
+#### `setup-node-yarn`
+**Location:** `.github/actions/setup-node-yarn/action.yml`  
+**Purpose:** Reusable Node.js and Yarn setup
+
+Features:
+- Node.js installation with specified version
+- Yarn caching
+- Corepack enablement
+- Dependency installation
+
+Usage:
+```yaml
+- name: Setup Node.js with Yarn
+  uses: ./.github/actions/setup-node-yarn
+  with:
+    node-version: 24.x
+```
+
+## Adding New Workflows
+
+When creating new workflows, follow these guidelines:
+
+1. **Use the template structure:**
+   ```yaml
+   name: Workflow Name
+   
+   on:
+     push:
+       branches: [master]
+   
+   permissions:
+     contents: read
+   
+   concurrency:
+     group: ${{ github.workflow }}-${{ github.ref }}
+     cancel-in-progress: true
+   
+   jobs:
+     job-name:
+       runs-on: ubuntu-latest
+       timeout-minutes: 30
+       steps:
+         - uses: actions/checkout@v4
+         - name: Step name
+           run: command
+   ```
+
+2. **Choose appropriate runners:**
+   - GitHub-hosted: For standard builds, public repos, occasional jobs
+   - Self-hosted: For resource-intensive, long-running, or specialized jobs
+
+3. **Set reasonable timeouts:**
+   - Lint/Type checks: 10 minutes
+   - Unit tests: 20 minutes
+   - Builds: 30 minutes
+   - E2E tests: 60 minutes
+
+4. **Use proper permissions:**
+   - Start with `contents: read`
+   - Add only required permissions
+
+5. **Document the workflow:**
+   - Add clear name and comments
+   - Update this README
+   - Update WORKFLOWS_BEST_PRACTICES.md if introducing new patterns
+
+## Documentation
+
+For detailed information, see:
+
+- [WORKFLOWS_BEST_PRACTICES.md](../WORKFLOWS_BEST_PRACTICES.md) - Comprehensive best practices guide
+- [SELF_HOSTED_RUNNERS.md](../SELF_HOSTED_RUNNERS.md) - Self-hosted runner setup and management
+- [GitHub Actions Documentation](https://docs.github.com/en/actions)
+
+## Workflow Status
+
+Check workflow status:
+- **GitHub UI**: Actions tab in repository
+- **Badge**: Add to README:
+  ```markdown
+  ![CI](https://github.com/YOUR-ORG/YOUR-REPO/workflows/Node.js%20CI/badge.svg)
+  ```
+
+## Troubleshooting
+
+### Common Issues
+
+**Workflow not triggering:**
+- Check branch names in trigger configuration
+- Verify file paths don't have syntax errors
+- Check repository settings for Actions enablement
+
+**Job timeouts:**
+- Review timeout values
+- Check for hanging processes
+- Consider breaking into smaller jobs
+
+**Permission errors:**
+- Review required permissions in workflow
+- Check repository/organization settings
+- Verify token scopes for external actions
+
+**Self-hosted runner not found:**
+- Verify runner is online and connected
+- Check runner labels match workflow configuration
+- Review runner group access for repository
+
+### Getting Help
+
+- Review workflow run logs in GitHub UI
+- Check [GitHub Community Forums](https://github.community/)
+- See [GitHub Actions Documentation](https://docs.github.com/en/actions)
+- For self-hosted runner issues, see [SELF_HOSTED_RUNNERS.md](../SELF_HOSTED_RUNNERS.md)
diff --git a/.github/workflows/self-hosted-example.yml b/.github/workflows/self-hosted-example.yml
new file mode 100644
index 0000000000..7a4088364c
--- /dev/null
+++ b/.github/workflows/self-hosted-example.yml
@@ -0,0 +1,185 @@
+name: Build with Self-Hosted (Example)
+
+# This is an EXAMPLE workflow demonstrating self-hosted runner usage
+# It's currently configured to use GitHub-hosted runners
+# To enable self-hosted runners, update the 'runs-on' configuration
+
+on:
+  workflow_dispatch:
+    inputs:
+      use-self-hosted:
+        description: 'Use self-hosted runners'
+        required: false
+        type: boolean
+        default: false
+  # Uncomment to enable on push/PR
+  # push:
+  #   branches: [master]
+  # pull_request:
+  #   branches: [master]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # Quick checks on GitHub-hosted runners (fast, minimal cost)
+  quick-checks:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        
+      - name: Setup Node.js with Yarn
+        uses: ./.github/actions/setup-node-yarn
+        with:
+          node-version: 24.x
+          
+      - name: Lint
+        run: yarn lint
+        
+      - name: Type check
+        run: yarn workspace @app/web tsc --noEmit
+
+  # Heavy build job (candidate for self-hosted runners)
+  build:
+    # Dynamic runner selection based on input
+    runs-on: ${{ inputs.use-self-hosted && '[self-hosted, linux, x64]' || 'ubuntu-latest' }}
+    timeout-minutes: 30
+    needs: quick-checks
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        
+      - name: Display runner info
+        run: |
+          echo "Runner: ${{ runner.name }}"
+          echo "OS: ${{ runner.os }}"
+          echo "Architecture: ${{ runner.arch }}"
+          echo "Using self-hosted: ${{ inputs.use-self-hosted }}"
+        
+      - name: Setup Node.js with Yarn
+        uses: ./.github/actions/setup-node-yarn
+        with:
+          node-version: 24.x
+          
+      - name: Build
+        run: yarn build
+        
+      - name: Cache build output
+        if: success()
+        uses: actions/cache/save@v4
+        with:
+          path: |
+            apps/*/dist
+            apps/*/build
+            apps/*/.next
+          key: build-${{ github.sha }}
+
+  # Resource-intensive tests (good candidate for self-hosted)
+  test:
+    # To enable self-hosted, change to: runs-on: [self-hosted, linux, x64, high-memory]
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    needs: build
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        
+      - name: Setup Node.js with Yarn
+        uses: ./.github/actions/setup-node-yarn
+        with:
+          node-version: 24.x
+          
+      - name: Restore build cache
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            apps/*/dist
+            apps/*/build
+            apps/*/.next
+          key: build-${{ github.sha }}
+          
+      - name: Run tests
+        run: yarn test
+
+  # Example: GPU-accelerated job (requires self-hosted with GPU)
+  # gpu-job:
+  #   runs-on: [self-hosted, linux, gpu]
+  #   timeout-minutes: 20
+  #   if: inputs.use-self-hosted
+  #   
+  #   steps:
+  #     - name: Checkout code
+  #       uses: actions/checkout@v4
+  #       
+  #     - name: Check GPU availability
+  #       run: |
+  #         nvidia-smi || echo "No GPU available"
+  #         
+  #     - name: Run GPU-accelerated tasks
+  #       run: |
+  #         echo "This job would run GPU-accelerated workloads"
+
+  # Example: Database integration tests (requires network access)
+  # integration-tests:
+  #   runs-on: [self-hosted, linux, x64]
+  #   timeout-minutes: 20
+  #   if: inputs.use-self-hosted
+  #   
+  #   services:
+  #     postgres:
+  #       image: postgres:15
+  #       env:
+  #         POSTGRES_PASSWORD: postgres
+  #       options: >-
+  #         --health-cmd pg_isready
+  #         --health-interval 10s
+  #         --health-timeout 5s
+  #         --health-retries 5
+  #   
+  #   steps:
+  #     - name: Checkout code
+  #       uses: actions/checkout@v4
+  #       
+  #     - name: Setup Node.js with Yarn
+  #       uses: ./.github/actions/setup-node-yarn
+  #       with:
+  #         node-version: 24.x
+  #         
+  #     - name: Run integration tests
+  #       env:
+  #         DATABASE_URL: postgresql://postgres:postgres@localhost:5432/test
+  #       run: yarn test:integration
+
+  summary:
+    runs-on: ubuntu-latest
+    needs: [quick-checks, build, test]
+    if: always()
+    timeout-minutes: 5
+    
+    steps:
+      - name: Summary
+        run: |
+          echo "## Workflow Summary" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "- Quick checks: ${{ needs.quick-checks.result }}" >> $GITHUB_STEP_SUMMARY
+          echo "- Build: ${{ needs.build.result }}" >> $GITHUB_STEP_SUMMARY
+          echo "- Test: ${{ needs.test.result }}" >> $GITHUB_STEP_SUMMARY
+          echo "" >> $GITHUB_STEP_SUMMARY
+          echo "Used self-hosted runners: ${{ inputs.use-self-hosted }}" >> $GITHUB_STEP_SUMMARY
+          
+          if [ "${{ needs.quick-checks.result }}" == "success" ] && \
+             [ "${{ needs.build.result }}" == "success" ] && \
+             [ "${{ needs.test.result }}" == "success" ]; then
+            echo "✅ All jobs completed successfully" >> $GITHUB_STEP_SUMMARY
+          else
+            echo "❌ Some jobs failed" >> $GITHUB_STEP_SUMMARY
+          fi
diff --git a/.github/workflows/self-hosted-runner-health.yml b/.github/workflows/self-hosted-runner-health.yml
new file mode 100644
index 0000000000..c0d9243b88
--- /dev/null
+++ b/.github/workflows/self-hosted-runner-health.yml
@@ -0,0 +1,153 @@
+name: Self-Hosted Runner Health Monitor
+
+# This workflow monitors the health of self-hosted runners
+# and can be scheduled to run periodically
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Run health check every Monday at 9 AM UTC
+    - cron: '0 9 * * 1'
+
+permissions:
+  contents: read
+  issues: write  # To create issues if runners are unhealthy
+
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: false
+
+jobs:
+  # Job for GitHub-hosted runners (as baseline/fallback)
+  github-hosted-check:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        
+      - name: GitHub-Hosted Runner Status
+        run: |
+          echo "=== GitHub-Hosted Runner Check ==="
+          echo "✅ GitHub-hosted runners are available"
+          echo "Runner: ${{ runner.name }}"
+          echo "OS: ${{ runner.os }}"
+          echo "Architecture: ${{ runner.arch }}"
+
+  # Example self-hosted runner health check
+  # To enable this, uncomment and ensure you have self-hosted runners configured
+  # self-hosted-check:
+  #   runs-on: [self-hosted, linux]
+  #   timeout-minutes: 10
+  #   
+  #   steps:
+  #     - name: Checkout repository
+  #       uses: actions/checkout@v4
+  #       
+  #     - name: Self-Hosted Runner Health Check
+  #       run: |
+  #         echo "=== Self-Hosted Runner Health Check ==="
+  #         echo "Runner: ${{ runner.name }}"
+  #         echo "OS: ${{ runner.os }}"
+  #         echo "Architecture: ${{ runner.arch }}"
+  #         echo ""
+  #         echo "System Resources:"
+  #         echo "Disk Space:"
+  #         df -h
+  #         echo ""
+  #         echo "Memory:"
+  #         free -h
+  #         echo ""
+  #         echo "CPU:"
+  #         nproc
+  #         lscpu | grep "Model name"
+  #         echo ""
+  #         echo "Docker Status (if applicable):"
+  #         if command -v docker &> /dev/null; then
+  #           docker --version
+  #           docker ps -a --format "table {{.Names}}\t{{.Status}}\t{{.Image}}"
+  #         else
+  #           echo "Docker not installed"
+  #         fi
+  #         echo ""
+  #         echo "Runner Process:"
+  #         ps aux | grep -i "Runner.Listener" | grep -v grep || echo "Runner process not found in ps output"
+  #         echo ""
+  #         echo "✅ Health check completed"
+  #     
+  #     - name: Check Disk Space
+  #       run: |
+  #         # Check if disk space is below 20%
+  #         DISK_USAGE=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//')
+  #         echo "Disk usage: ${DISK_USAGE}%"
+  #         
+  #         if [ "$DISK_USAGE" -gt 80 ]; then
+  #           echo "⚠️ WARNING: Disk usage is above 80%"
+  #           echo "::warning::Disk usage is at ${DISK_USAGE}%. Consider cleaning up."
+  #         else
+  #           echo "✅ Disk usage is healthy"
+  #         fi
+  #     
+  #     - name: Check Memory
+  #       run: |
+  #         # Check available memory
+  #         AVAILABLE_MEM=$(free -m | awk 'NR==2 {print $7}')
+  #         TOTAL_MEM=$(free -m | awk 'NR==2 {print $2}')
+  #         MEM_PERCENT=$((100 * AVAILABLE_MEM / TOTAL_MEM))
+  #         
+  #         echo "Available memory: ${AVAILABLE_MEM}MB / ${TOTAL_MEM}MB (${MEM_PERCENT}% free)"
+  #         
+  #         if [ "$MEM_PERCENT" -lt 20 ]; then
+  #           echo "⚠️ WARNING: Available memory is below 20%"
+  #           echo "::warning::Available memory is at ${MEM_PERCENT}%. Runner may need more resources."
+  #         else
+  #           echo "✅ Memory is healthy"
+  #         fi
+  #     
+  #     - name: Verify Node.js
+  #       run: |
+  #         echo "Node.js version:"
+  #         if command -v node &> /dev/null; then
+  #           node --version
+  #         else
+  #           echo "⚠️ Node.js not found"
+  #         fi
+  #     
+  #     - name: Verify Yarn
+  #       run: |
+  #         echo "Yarn version:"
+  #         if command -v yarn &> /dev/null; then
+  #           yarn --version
+  #         else
+  #           echo "⚠️ Yarn not found"
+  #         fi
+  #     
+  #     - name: Clean Up Old Workflows
+  #       run: |
+  #         echo "Cleaning up old workflow artifacts..."
+  #         # Clean up old build artifacts older than 7 days
+  #         find ${{ runner.temp }} -type f -mtime +7 -delete 2>/dev/null || true
+  #         echo "✅ Cleanup completed"
+
+  report:
+    runs-on: ubuntu-latest
+    needs: [github-hosted-check]
+    # Uncomment to wait for self-hosted check: needs: [github-hosted-check, self-hosted-check]
+    if: always()
+    timeout-minutes: 5
+    
+    steps:
+      - name: Report Status
+        run: |
+          echo "=== Runner Health Report ==="
+          echo "GitHub-hosted runners: ${{ needs.github-hosted-check.result }}"
+          # Uncomment when self-hosted runners are configured
+          # echo "Self-hosted runners: ${{ needs.self-hosted-check.result }}"
+          echo ""
+          if [ "${{ needs.github-hosted-check.result }}" == "success" ]; then
+            echo "✅ All monitored runners are healthy"
+          else
+            echo "❌ Some runners reported issues"
+            echo "::error::Runner health check failed"
+          fi
diff --git a/.github/workflows/self-hosted-runner-setup.yml b/.github/workflows/self-hosted-runner-setup.yml
new file mode 100644
index 0000000000..208a0e33a8
--- /dev/null
+++ b/.github/workflows/self-hosted-runner-setup.yml
@@ -0,0 +1,110 @@
+name: Self-Hosted Runner Setup
+
+# This workflow helps manage self-hosted runners
+# It provides instructions and can be used to verify runner configuration
+
+on:
+  workflow_dispatch:
+    inputs:
+      runner-name:
+        description: 'Name of the runner to check'
+        required: false
+        type: string
+      action:
+        description: 'Action to perform'
+        required: true
+        type: choice
+        options:
+          - health-check
+          - list-runners
+          - runner-info
+        default: 'health-check'
+
+permissions:
+  contents: read
+  actions: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  runner-management:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Runner Health Check
+        if: inputs.action == 'health-check'
+        run: |
+          echo "=== Self-Hosted Runner Health Check ==="
+          echo "Runner: ${{ runner.name }}"
+          echo "OS: ${{ runner.os }}"
+          echo "Architecture: ${{ runner.arch }}"
+          echo "Temp Directory: ${{ runner.temp }}"
+          echo "Tool Cache: ${{ runner.tool_cache }}"
+          echo ""
+          echo "System Information:"
+          uname -a
+          echo ""
+          echo "Disk Space:"
+          df -h
+          echo ""
+          echo "Memory:"
+          free -h
+          echo ""
+          echo "CPU Info:"
+          nproc
+          echo ""
+          echo "✅ Health check completed successfully"
+
+      - name: Display Runner Info
+        if: inputs.action == 'runner-info'
+        run: |
+          echo "=== Runner Information ==="
+          echo "Runner Name: ${{ runner.name }}"
+          echo "Runner OS: ${{ runner.os }}"
+          echo "Runner Architecture: ${{ runner.arch }}"
+          echo "Workflow: ${{ github.workflow }}"
+          echo "Event: ${{ github.event_name }}"
+          echo "Repository: ${{ github.repository }}"
+          
+      - name: List Runners Information
+        if: inputs.action == 'list-runners'
+        run: |
+          echo "=== Configured Runner Labels ==="
+          echo "This workflow can run on:"
+          echo "  - ubuntu-latest (GitHub-hosted)"
+          echo "  - self-hosted (Self-hosted runners)"
+          echo ""
+          echo "To use self-hosted runners in your workflows, add:"
+          echo "  runs-on: self-hosted"
+          echo ""
+          echo "Or for specific labels:"
+          echo "  runs-on: [self-hosted, linux, x64]"
+
+  # Example job demonstrating self-hosted runner usage
+  example-self-hosted-job:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    if: github.event.inputs.action == 'runner-info'
+    
+    steps:
+      - name: Example Self-Hosted Runner Job
+        run: |
+          echo "=== Self-Hosted Runner Example ==="
+          echo "This is an example job that would run on a self-hosted runner."
+          echo ""
+          echo "To use this with actual self-hosted runners, change:"
+          echo "  runs-on: ubuntu-latest"
+          echo "to:"
+          echo "  runs-on: self-hosted"
+          echo ""
+          echo "Or use specific labels:"
+          echo "  runs-on: [self-hosted, linux, x64]"
+          echo "  runs-on: [self-hosted, linux, ARM64]"
+          echo "  runs-on: [self-hosted, windows, x64]"
+          echo "  runs-on: [self-hosted, macOS, x64]"
diff --git a/.gitignore b/.gitignore
index bfbad40023..bb3b6c241b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -186,6 +186,18 @@ vault-password*.txt
 **/ansible/vault-pass
 **/.ansible-vault
 
+# GitHub Actions and Runners
+.github/actions-runner/
+actions-runner/
+_work/
+_diag/
+runner-config.local.yml
+.runner
+.credentials
+.credentials_rsaparams
+runner.env
+.env.runner
+
 # IDE and editor files
 .vscode/
 .vscode/settings.local.json