Sync copilot-agent-gateway and core services from local

Adds upstream gateway (intelligent multi-model routing with adaptive
learning) and core Next.js service (API gateway, health endpoints,
UI components). Gateway placed in src/gateway/upstream/ to preserve
existing TypeScript architecture.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/core-app/.gitignore

@@ -0,0 +1,35 @@
+# Dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# Testing
+/coverage
+
+# Next.js
+/.next/
+/out/
+
+# Production
+/build
+.next
+
+# Misc
+.DS_Store
+*.pem
+
+# Debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Local env files
+.env
+.env*.local
+
+# Vercel
+.vercel
+
+# TypeScript
+*.tsbuildinfo
+next-env.d.ts

src/core-app/Dockerfile

@@ -0,0 +1,54 @@
+# Multi-stage build for Next.js app
+FROM node:20-alpine AS base
+
+# Install dependencies only when needed
+FROM base AS deps
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+
+# Copy package files
+COPY package.json package-lock.json* ./
+RUN npm ci
+
+# Rebuild the source code only when needed
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+
+# Set build-time environment variables
+ARG SERVICE_NAME=blackroad-service
+ARG SERVICE_ENV=production
+ARG SERVICE_VERSION=0.0.1
+ENV SERVICE_NAME=$SERVICE_NAME
+ENV SERVICE_ENV=$SERVICE_ENV
+ENV SERVICE_VERSION=$SERVICE_VERSION
+ENV NEXT_TELEMETRY_DISABLED=1
+ENV BUILD_TIME=$( date -u +"%Y-%m-%dT%H:%M:%SZ" )
+
+# Build the application
+RUN npm run build
+
+# Production image, copy all the files and run next
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV NEXT_TELEMETRY_DISABLED=1
+
+RUN addgroup --system --gid 1001 nodejs
+RUN adduser --system --uid 1001 nextjs
+
+# Copy built application
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
+COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
+
+USER nextjs
+
+EXPOSE 3000
+
+ENV PORT=3000
+ENV HOSTNAME="0.0.0.0"
+
+CMD ["node", "server.js"]

src/core-app/README.md

@@ -0,0 +1,232 @@
+# BlackRoad Web Service Template
+
+Universal Next.js 14 template for BlackRoad infrastructure services. This template provides a production-ready foundation for deploying web services to Cloudflare Pages or Railway.
+
+## Features
+
+- **Next.js 14** with App Router
+- **TypeScript** for type safety
+- **Health check endpoints** (`/api/health`, `/api/version`, `/api/ready`)
+- **Railway-ready** with `railway.json` configuration
+- **Docker support** with multi-stage builds
+- **Standalone output** for optimal performance
+- **Environment variable** management
+
+## Quick Start
+
+### 1. Local Development
+
+```bash
+# Copy environment variables
+cp .env.example .env
+
+# Edit .env and set your service name
+# SERVICE_NAME=your-service-name
+# NEXT_PUBLIC_APP_NAME=Your Service Name
+
+# Install dependencies
+npm install
+
+# Run development server
+npm run dev
+```
+
+Visit `http://localhost:3000` to see your service running.
+
+### 2. Build for Production
+
+```bash
+npm run build
+npm start
+```
+
+### 3. Type Checking
+
+```bash
+npm run type-check
+```
+
+## API Endpoints
+
+All services include these standard endpoints:
+
+- **`GET /api/health`** - Health check endpoint
+  - Returns: `{ status: "ok", service: "...", timestamp: "...", uptime: ... }`
+
+- **`GET /api/version`** - Version information
+  - Returns: `{ version: "...", service: "...", environment: "...", node_version: "...", build_time: "..." }`
+
+- **`GET /api/ready`** - Readiness probe for orchestration
+  - Returns: `{ ready: true, service: "..." }`
+
+## Deployment
+
+### Deploy to Railway
+
+1. **Create a new Railway project** or use an existing one
+2. **Connect your repository** to Railway
+3. **Set environment variables** in Railway dashboard:
+   ```
+   SERVICE_NAME=your-service-name
+   SERVICE_ENV=production
+   NEXT_PUBLIC_APP_NAME=Your Service Name
+   NEXT_PUBLIC_BASE_URL=https://your-service.railway.app
+   ```
+4. **Railway will automatically**:
+   - Detect the `railway.json` configuration
+   - Build using Nixpacks
+   - Run health checks on `/api/health`
+   - Deploy your service
+
+### Deploy to Cloudflare Pages
+
+1. **Connect your repository** to Cloudflare Pages
+2. **Build settings**:
+   - Build command: `npm run build`
+   - Build output directory: `.next`
+   - Root directory: (leave default or specify your service directory)
+3. **Environment variables**:
+   ```
+   SERVICE_NAME=your-service-name
+   SERVICE_ENV=production
+   NEXT_PUBLIC_APP_NAME=Your Service Name
+   ```
+
+### Docker Deployment
+
+```bash
+# Build the image
+docker build -t blackroad-service \
+  --build-arg SERVICE_NAME=your-service \
+  --build-arg SERVICE_ENV=production \
+  .
+
+# Run the container
+docker run -p 3000:3000 \
+  -e SERVICE_NAME=your-service \
+  -e SERVICE_ENV=production \
+  blackroad-service
+```
+
+## Cloudflare + Railway Wiring
+
+To connect a subdomain to your Railway deployment:
+
+1. **Get your Railway service URL** (e.g., `your-service-production.up.railway.app`)
+
+2. **In Cloudflare DNS**, add a CNAME record:
+   - **Type**: CNAME
+   - **Name**: your-subdomain (e.g., `api`, `web`, `prism`)
+   - **Target**: your-service-production.up.railway.app
+   - **Proxy status**: Proxied (orange cloud)
+
+3. **Optional**: Set `NEXT_PUBLIC_BASE_URL` in Railway to your custom domain:
+   ```
+   NEXT_PUBLIC_BASE_URL=https://your-subdomain.blackroad.systems
+   ```
+
+4. **Verify** by visiting `https://your-subdomain.blackroad.systems/api/health`
+
+## Customization
+
+### For a New Service
+
+1. **Copy this template** to your service directory:
+   ```bash
+   cp -r templates/web-service services/your-service
+   cd services/your-service
+   ```
+
+2. **Update `package.json`**:
+   ```json
+   {
+     "name": "blackroad-your-service",
+     ...
+   }
+   ```
+
+3. **Update `.env`**:
+   ```env
+   SERVICE_NAME=blackroad-your-service
+   NEXT_PUBLIC_APP_NAME=Your Service Name
+   ```
+
+4. **Customize `app/page.tsx`** with your service-specific content
+
+5. **Add your routes** in `app/` directory
+
+### Adding Custom API Routes
+
+Create new route handlers in `app/api/`:
+
+```typescript
+// app/api/custom/route.ts
+import { NextResponse } from 'next/server'
+
+export async function GET() {
+  return NextResponse.json({ message: 'Custom endpoint' })
+}
+```
+
+### Adding Pages
+
+Create new pages in `app/`:
+
+```typescript
+// app/about/page.tsx
+export default function About() {
+  return <main>About page content</main>
+}
+```
+
+## Architecture
+
+```
+templates/web-service/
+├── app/
+│   ├── api/
+│   │   ├── health/route.ts      # Health check
+│   │   ├── version/route.ts     # Version info
+│   │   └── ready/route.ts       # Readiness probe
+│   ├── layout.tsx               # Root layout
+│   └── page.tsx                 # Homepage
+├── Dockerfile                   # Multi-stage Docker build
+├── railway.json                 # Railway configuration
+├── next.config.mjs              # Next.js configuration
+├── tsconfig.json                # TypeScript configuration
+├── package.json                 # Dependencies
+├── .env.example                 # Environment variables template
+└── README.md                    # This file
+```
+
+## Environment Variables
+
+| Variable | Description | Required | Default |
+|----------|-------------|----------|---------|
+| `SERVICE_NAME` | Unique service identifier | Yes | `blackroad-service` |
+| `SERVICE_ENV` | Environment (development/production) | Yes | `development` |
+| `SERVICE_VERSION` | Service version | No | `0.0.1` |
+| `NEXT_PUBLIC_APP_NAME` | Display name | Yes | `BlackRoad Service` |
+| `NEXT_PUBLIC_BASE_URL` | Base URL for the service | No | `http://localhost:3000` |
+| `BUILD_TIME` | Build timestamp (auto-set) | No | Current timestamp |
+
+## Railway Configuration
+
+The `railway.json` file configures:
+
+- **Builder**: Nixpacks (automatic detection)
+- **Build Command**: `npm install && npm run build`
+- **Start Command**: `npm start`
+- **Health Check**: `/api/health` endpoint
+- **Restart Policy**: Restart on failure (max 10 retries)
+
+## Support
+
+For issues or questions:
+- Check the [BlackRoad registry](../../infra/blackroad_registry.json) for service mappings
+- Review Railway/Cloudflare deployment logs
+- Verify environment variables are set correctly
+
+---
+
+**BlackRoad Infrastructure** · Template v1.0.0

src/core-app/app/api/gateway/[[...path]]/route.ts

@@ -0,0 +1,70 @@
+// BlackRoad Copilot Gateway Integration
+import { NextRequest, NextResponse } from 'next/server'
+
+const GATEWAY_URL = process.env.GATEWAY_URL || 'http://localhost:3030'
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: { path?: string[] } }
+) {
+  const path = params.path?.join('/') || ''
+  const searchParams = request.nextUrl.searchParams
+  
+  const gatewayUrl = `${GATEWAY_URL}/api/${path}${searchParams.toString() ? '?' + searchParams.toString() : ''}`
+  
+  try {
+    const response = await fetch(gatewayUrl, {
+      headers: {
+        'X-Gateway-Client': request.headers.get('host') || 'unknown',
+        'X-Gateway-Service': process.env.SERVICE_NAME || 'unknown'
+      }
+    })
+    
+    const data = await response.json()
+    
+    return NextResponse.json(data, {
+      headers: {
+        'X-Gateway-Response': 'true',
+        'X-Gateway-Version': '2.0.0'
+      }
+    })
+  } catch (error) {
+    return NextResponse.json(
+      { 
+        success: false,
+        error: 'Gateway unavailable',
+        gateway: GATEWAY_URL
+      },
+      { status: 503 }
+    )
+  }
+}
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: { path?: string[] } }
+) {
+  const path = params.path?.join('/') || ''
+  const body = await request.json()
+  
+  const gatewayUrl = `${GATEWAY_URL}/api/${path}`
+  
+  try {
+    const response = await fetch(gatewayUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Gateway-Client': request.headers.get('host') || 'unknown'
+      },
+      body: JSON.stringify(body)
+    })
+    
+    const data = await response.json()
+    return NextResponse.json(data)
+  } catch (error) {
+    return NextResponse.json(
+      { success: false, error: 'Gateway unavailable' },
+      { status: 503 }
+    )
+  }
+}

src/core-app/app/api/health/route.ts

@@ -0,0 +1,12 @@
+import { NextResponse } from 'next/server'
+
+export async function GET() {
+  const serviceName = process.env.SERVICE_NAME || 'blackroad-service'
+
+  return NextResponse.json({
+    status: 'ok',
+    service: serviceName,
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime()
+  })
+}

src/core-app/app/api/ready/route.ts

@@ -0,0 +1,18 @@
+import { NextResponse } from 'next/server'
+
+export async function GET() {
+  // Add any readiness checks here (database connections, external services, etc.)
+  const isReady = true
+
+  if (!isReady) {
+    return NextResponse.json(
+      { ready: false, reason: 'Service dependencies not available' },
+      { status: 503 }
+    )
+  }
+
+  return NextResponse.json({
+    ready: true,
+    service: process.env.SERVICE_NAME || 'blackroad-service'
+  })
+}

src/core-app/app/api/version/route.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from 'next/server'
+
+export async function GET() {
+  const serviceName = process.env.SERVICE_NAME || 'blackroad-service'
+  const version = process.env.SERVICE_VERSION || '0.0.1'
+  const environment = process.env.SERVICE_ENV || 'development'
+
+  return NextResponse.json({
+    version,
+    service: serviceName,
+    environment,
+    node_version: process.version,
+    build_time: process.env.BUILD_TIME || new Date().toISOString()
+  })
+}

src/core-app/app/globals.css

@@ -0,0 +1,95 @@
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+html,
+body {
+  max-width: 100vw;
+  overflow-x: hidden;
+}
+
+@keyframes fadeIn {
+  from {
+    opacity: 0;
+    transform: translateY(10px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes slideIn {
+  from {
+    transform: translateX(-10px);
+    opacity: 0;
+  }
+  to {
+    transform: translateX(0);
+    opacity: 1;
+  }
+}
+
+@keyframes pulse {
+  0%, 100% {
+    opacity: 1;
+  }
+  50% {
+    opacity: 0.8;
+  }
+}
+
+.animate-fade-in {
+  animation: fadeIn 0.5s ease-out;
+}
+
+.animate-slide-in {
+  animation: slideIn 0.4s ease-out;
+}
+
+.animate-pulse {
+  animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite;
+}
+
+a {
+  color: inherit;
+  text-decoration: none;
+}
+
+button {
+  font-family: inherit;
+}
+
+/* Smooth scrolling */
+html {
+  scroll-behavior: smooth;
+}
+
+/* Focus styles for accessibility */
+*:focus-visible {
+  outline: 2px solid #667eea;
+  outline-offset: 2px;
+}
+
+/* Loading skeleton */
+@keyframes skeleton {
+  0% {
+    background-position: -200px 0;
+  }
+  100% {
+    background-position: calc(200px + 100%) 0;
+  }
+}
+
+.skeleton {
+  background: linear-gradient(
+    90deg,
+    rgba(255, 255, 255, 0.05) 0px,
+    rgba(255, 255, 255, 0.1) 40px,
+    rgba(255, 255, 255, 0.05) 80px
+  );
+  background-size: 200px 100%;
+  animation: skeleton 1.2s ease-in-out infinite;
+}

src/core-app/app/layout.tsx

@@ -0,0 +1,25 @@
+import type { Metadata } from 'next'
+
+export const metadata: Metadata = {
+  title: process.env.NEXT_PUBLIC_APP_NAME || 'BlackRoad Service',
+  description: 'BlackRoad infrastructure service',
+}
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode
+}) {
+  return (
+    <html lang="en">
+      <body style={{
+        margin: 0,
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+        backgroundColor: '#0a0a0a',
+        color: '#e0e0e0'
+      }}>
+        {children}
+      </body>
+    </html>
+  )
+}

src/core-app/app/page.tsx

@@ -0,0 +1,145 @@
+export default function Home() {
+  const serviceName = process.env.SERVICE_NAME || 'blackroad-service'
+  const serviceEnv = process.env.SERVICE_ENV || 'development'
+  const appName = process.env.NEXT_PUBLIC_APP_NAME || 'BlackRoad Service'
+
+  return (
+    <main style={{
+      minHeight: '100vh',
+      display: 'flex',
+      flexDirection: 'column',
+      alignItems: 'center',
+      justifyContent: 'center',
+      padding: '2rem'
+    }}>
+      <div style={{
+        maxWidth: '800px',
+        width: '100%',
+        padding: '2rem',
+        backgroundColor: '#1a1a1a',
+        borderRadius: '8px',
+        border: '1px solid #333'
+      }}>
+        <h1 style={{
+          fontSize: '2.5rem',
+          marginBottom: '0.5rem',
+          background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
+          WebkitBackgroundClip: 'text',
+          WebkitTextFillColor: 'transparent',
+          backgroundClip: 'text'
+        }}>
+          {appName}
+        </h1>
+
+        <div style={{
+          display: 'flex',
+          gap: '1rem',
+          marginBottom: '2rem',
+          fontSize: '0.875rem'
+        }}>
+          <span style={{
+            padding: '0.25rem 0.75rem',
+            backgroundColor: '#2a2a2a',
+            borderRadius: '4px',
+            border: '1px solid #444'
+          }}>
+            {serviceName}
+          </span>
+          <span style={{
+            padding: '0.25rem 0.75rem',
+            backgroundColor: serviceEnv === 'production' ? '#1a472a' : '#2a2a2a',
+            borderRadius: '4px',
+            border: `1px solid ${serviceEnv === 'production' ? '#2d5f3d' : '#444'}`
+          }}>
+            {serviceEnv}
+          </span>
+        </div>
+
+        <p style={{
+          fontSize: '1.125rem',
+          lineHeight: '1.75',
+          marginBottom: '2rem',
+          color: '#b0b0b0'
+        }}>
+          BlackRoad infrastructure service endpoint. This service is part of the BlackRoad ecosystem.
+        </p>
+
+        <div style={{
+          display: 'grid',
+          gap: '1rem',
+          marginTop: '2rem'
+        }}>
+          <h2 style={{
+            fontSize: '1.25rem',
+            marginBottom: '0.5rem',
+            color: '#e0e0e0'
+          }}>
+            Service Endpoints
+          </h2>
+
+          <a
+            href="/api/health"
+            style={{
+              display: 'block',
+              padding: '1rem',
+              backgroundColor: '#2a2a2a',
+              borderRadius: '6px',
+              border: '1px solid #444',
+              textDecoration: 'none',
+              color: '#667eea',
+              transition: 'all 0.2s'
+            }}
+          >
+            <strong>/api/health</strong>
+            <span style={{ color: '#888', marginLeft: '1rem' }}>→ Health check endpoint</span>
+          </a>
+
+          <a
+            href="/api/version"
+            style={{
+              display: 'block',
+              padding: '1rem',
+              backgroundColor: '#2a2a2a',
+              borderRadius: '6px',
+              border: '1px solid #444',
+              textDecoration: 'none',
+              color: '#667eea',
+              transition: 'all 0.2s'
+            }}
+          >
+            <strong>/api/version</strong>
+            <span style={{ color: '#888', marginLeft: '1rem' }}>→ Version information</span>
+          </a>
+
+          <a
+            href="/api/ready"
+            style={{
+              display: 'block',
+              padding: '1rem',
+              backgroundColor: '#2a2a2a',
+              borderRadius: '6px',
+              border: '1px solid #444',
+              textDecoration: 'none',
+              color: '#667eea',
+              transition: 'all 0.2s'
+            }}
+          >
+            <strong>/api/ready</strong>
+            <span style={{ color: '#888', marginLeft: '1rem' }}>→ Readiness probe</span>
+          </a>
+        </div>
+
+        <footer style={{
+          marginTop: '3rem',
+          paddingTop: '1.5rem',
+          borderTop: '1px solid #333',
+          fontSize: '0.875rem',
+          color: '#666',
+          textAlign: 'center'
+        }}>
+          BlackRoad Infrastructure · {new Date().getFullYear()}
+        </footer>
+      </div>
+    </main>
+  )
+}

src/core-app/components/Button.tsx

@@ -0,0 +1,135 @@
+import type { CSSProperties } from 'react'
+import { gradients, colors, borderRadius, shadows, transitions } from './design-tokens'
+
+export type ButtonVariant = 'primary' | 'secondary' | 'tertiary' | 'ghost' | 'danger'
+export type ButtonSize = 'sm' | 'md' | 'lg'
+
+interface ButtonProps {
+  children: React.ReactNode
+  variant?: ButtonVariant
+  size?: ButtonSize
+  disabled?: boolean
+  onClick?: () => void
+  href?: string
+  style?: CSSProperties
+}
+
+const getButtonStyles = (variant: ButtonVariant, size: ButtonSize, disabled: boolean): CSSProperties => {
+  const baseStyles: CSSProperties = {
+    display: 'inline-flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    fontWeight: 700,
+    border: 'none',
+    cursor: disabled ? 'not-allowed' : 'pointer',
+    transition: transitions.normal,
+    textDecoration: 'none',
+    opacity: disabled ? 0.5 : 1,
+    transform: 'translateY(0)',
+  }
+
+  const sizeStyles: Record<ButtonSize, CSSProperties> = {
+    sm: {
+      padding: '0.5rem 1rem',
+      fontSize: '0.875rem',
+      borderRadius: borderRadius.md,
+    },
+    md: {
+      padding: '1rem 2rem',
+      fontSize: '1rem',
+      borderRadius: borderRadius.lg,
+    },
+    lg: {
+      padding: '1.25rem 2.5rem',
+      fontSize: '1.125rem',
+      borderRadius: borderRadius.lg,
+    }
+  }
+
+  const variantStyles: Record<ButtonVariant, CSSProperties> = {
+    primary: {
+      background: gradients.primary,
+      color: 'white',
+      boxShadow: '0 4px 15px rgba(102, 126, 234, 0.4)',
+    },
+    secondary: {
+      background: gradients.secondary,
+      color: 'white',
+      boxShadow: '0 4px 15px rgba(240, 147, 251, 0.4)',
+    },
+    tertiary: {
+      background: gradients.tertiary,
+      color: 'white',
+      boxShadow: '0 4px 15px rgba(79, 172, 254, 0.4)',
+    },
+    ghost: {
+      background: 'transparent',
+      color: colors.primary.purple,
+      border: `2px solid ${colors.primary.purple}`,
+    },
+    danger: {
+      background: colors.semantic.error,
+      color: 'white',
+      boxShadow: '0 4px 15px rgba(239, 68, 68, 0.4)',
+    }
+  }
+
+  return { ...baseStyles, ...sizeStyles[size], ...variantStyles[variant] }
+}
+
+export function Button({ 
+  children, 
+  variant = 'primary', 
+  size = 'md', 
+  disabled = false, 
+  onClick, 
+  href,
+  style 
+}: ButtonProps) {
+  const buttonStyles = getButtonStyles(variant, size, disabled)
+  const hoverStyles = !disabled ? {
+    ':hover': {
+      transform: 'translateY(-2px)',
+      boxShadow: shadows['2xl']
+    }
+  } : {}
+
+  if (href) {
+    return (
+      <a 
+        href={href} 
+        style={{ ...buttonStyles, ...style }}
+        onMouseEnter={(e) => {
+          if (!disabled) {
+            e.currentTarget.style.transform = 'translateY(-2px)'
+            e.currentTarget.style.boxShadow = shadows['2xl']
+          }
+        }}
+        onMouseLeave={(e) => {
+          e.currentTarget.style.transform = 'translateY(0)'
+        }}
+      >
+        {children}
+      </a>
+    )
+  }
+
+  return (
+    <button 
+      onClick={onClick}
+      disabled={disabled}
+      style={{ ...buttonStyles, ...style }}
+      onMouseEnter={(e) => {
+        if (!disabled) {
+          e.currentTarget.style.transform = 'translateY(-2px)'
+          e.currentTarget.style.boxShadow = shadows['2xl']
+        }
+      }}
+      onMouseLeave={(e) => {
+        e.currentTarget.style.transform = 'translateY(0)'
+      }}
+    >
+      {children}
+    </button>
+  )
+}

src/core-app/components/Card.tsx

@@ -0,0 +1,75 @@
+import type { CSSProperties, ReactNode } from 'react'
+import { borderRadius, shadows, transitions } from './design-tokens'
+
+interface CardProps {
+  children: ReactNode
+  variant?: 'default' | 'elevated' | 'outlined' | 'glass'
+  gradient?: string
+  style?: CSSProperties
+  onClick?: () => void
+  hoverable?: boolean
+}
+
+export function Card({ 
+  children, 
+  variant = 'default', 
+  gradient, 
+  style, 
+  onClick,
+  hoverable = false
+}: CardProps) {
+  const baseStyles: CSSProperties = {
+    padding: '2rem',
+    borderRadius: borderRadius.xl,
+    transition: transitions.normal,
+    cursor: onClick ? 'pointer' : 'default'
+  }
+
+  const variantStyles: Record<string, CSSProperties> = {
+    default: {
+      backgroundColor: '#ffffff',
+      boxShadow: shadows.md,
+    },
+    elevated: {
+      backgroundColor: '#ffffff',
+      boxShadow: shadows['2xl'],
+    },
+    outlined: {
+      backgroundColor: 'transparent',
+      border: '1px solid #e0e0e0',
+    },
+    glass: {
+      background: 'rgba(255, 255, 255, 0.1)',
+      backdropFilter: 'blur(10px)',
+      border: '1px solid rgba(255, 255, 255, 0.2)',
+    }
+  }
+
+  const cardStyles = {
+    ...baseStyles,
+    ...variantStyles[variant],
+    ...(gradient && { background: gradient }),
+    ...style
+  }
+
+  return (
+    <div 
+      style={cardStyles}
+      onClick={onClick}
+      onMouseEnter={(e) => {
+        if (hoverable || onClick) {
+          e.currentTarget.style.transform = 'translateY(-4px)'
+          e.currentTarget.style.boxShadow = shadows['2xl']
+        }
+      }}
+      onMouseLeave={(e) => {
+        if (hoverable || onClick) {
+          e.currentTarget.style.transform = 'translateY(0)'
+          e.currentTarget.style.boxShadow = variant === 'elevated' ? shadows['2xl'] : shadows.md
+        }
+      }}
+    >
+      {children}
+    </div>
+  )
+}

src/core-app/components/design-tokens.ts

@@ -0,0 +1,108 @@
+// BlackRoad Design System Tokens
+export const colors = {
+  primary: {
+    purple: '#667eea',
+    deepPurple: '#764ba2',
+    pink: '#f093fb',
+    red: '#f5576c'
+  },
+  secondary: {
+    cyan: '#4facfe',
+    lightCyan: '#00f2fe',
+    teal: '#a8edea',
+    lightPink: '#fed6e3'
+  },
+  neutral: {
+    black: '#0a0a0a',
+    darkGray: '#1a1a1a',
+    gray: '#2a2a2a',
+    midGray: '#666',
+    lightGray: '#888',
+    offWhite: '#e0e0e0'
+  },
+  semantic: {
+    success: '#4ade80',
+    warning: '#fbbf24',
+    error: '#ef4444',
+    info: '#3b82f6'
+  }
+}
+
+export const gradients = {
+  primary: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
+  secondary: 'linear-gradient(135deg, #f093fb 0%, #f5576c 100%)',
+  tertiary: 'linear-gradient(135deg, #4facfe 0%, #00f2fe 100%)',
+  warm: 'linear-gradient(135deg, #ffecd2 0%, #fcb69f 100%)',
+  cool: 'linear-gradient(135deg, #a8edea 0%, #fed6e3 100%)',
+  rainbow: 'linear-gradient(135deg, #667eea 0%, #764ba2 25%, #f093fb 50%, #4facfe 75%, #00f2fe 100%)'
+}
+
+export const spacing = {
+  xs: '0.25rem',
+  sm: '0.5rem',
+  md: '1rem',
+  lg: '1.5rem',
+  xl: '2rem',
+  '2xl': '3rem',
+  '3xl': '4rem'
+}
+
+export const borderRadius = {
+  sm: '4px',
+  md: '8px',
+  lg: '12px',
+  xl: '16px',
+  '2xl': '24px',
+  full: '9999px'
+}
+
+export const shadows = {
+  sm: '0 1px 2px 0 rgba(0, 0, 0, 0.05)',
+  md: '0 4px 6px -1px rgba(0, 0, 0, 0.1)',
+  lg: '0 10px 15px -3px rgba(0, 0, 0, 0.1)',
+  xl: '0 20px 25px -5px rgba(0, 0, 0, 0.1)',
+  '2xl': '0 25px 50px -12px rgba(0, 0, 0, 0.25)',
+  glow: '0 0 40px rgba(102, 126, 234, 0.3)'
+}
+
+export const transitions = {
+  fast: 'all 0.15s ease',
+  normal: 'all 0.2s ease',
+  slow: 'all 0.3s ease'
+}
+
+export const typography = {
+  fontFamily: {
+    sans: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+    mono: '"SF Mono", Monaco, "Cascadia Code", "Roboto Mono", Consolas, "Courier New", monospace'
+  },
+  fontSize: {
+    xs: '0.75rem',
+    sm: '0.875rem',
+    base: '1rem',
+    lg: '1.125rem',
+    xl: '1.25rem',
+    '2xl': '1.5rem',
+    '3xl': '1.875rem',
+    '4xl': '2.25rem',
+    '5xl': '3rem',
+    '6xl': '3.75rem',
+    '7xl': '4.5rem'
+  },
+  fontWeight: {
+    normal: 400,
+    medium: 500,
+    semibold: 600,
+    bold: 700,
+    extrabold: 800,
+    black: 900
+  }
+}
+
+export const breakpoints = {
+  sm: '640px',
+  md: '768px',
+  lg: '1024px',
+  xl: '1280px',
+  '2xl': '1536px'
+}

src/core-app/next.config.mjs

@@ -0,0 +1,13 @@
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  output: 'standalone',
+  poweredByHeader: false,
+  compress: true,
+  reactStrictMode: true,
+  env: {
+    SERVICE_NAME: process.env.SERVICE_NAME || 'blackroad-os-core',
+    SERVICE_ENV: process.env.SERVICE_ENV || 'development',
+  },
+}
+
+export default nextConfig

src/core-app/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "blackroad-os-core",
+  "version": "0.0.1",
+  "private": true,
+  "scripts": {
+    "dev": "next dev -p 3006",
+    "build": "next build",
+    "start": "next start",
+    "lint": "next lint",
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "next": "14.2.15",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.6",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "typescript": "^5.6.3"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

src/core-app/railway.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "https://railway.app/railway.schema.json",
+  "build": {
+    "builder": "NIXPACKS",
+    "buildCommand": "npm install && npm run build"
+  },
+  "deploy": {
+    "startCommand": "npm start",
+    "healthcheckPath": "/api/health",
+    "healthcheckTimeout": 100,
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 10
+  }
+}

src/core-app/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"],
+      "@shared/*": ["../../shared/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

src/core-app/wrangler.toml

@@ -0,0 +1,6 @@
+name = "blackroad-core"
+compatibility_date = "2024-01-01"
+pages_build_output_dir = ".next"
+
+[env.production]
+account_id = "848cf0b18d51e0170e0d1537aec3505a"

src/gateway/upstream/MULTI_LAYER_ROUTING.md

@@ -0,0 +1,276 @@
+# Multi-Layer Routing Architecture
+
+## ✨ Your Request: "model name" -> api -> provider -> api -> api instance -> api map -> route -> ... -> blackroad
+
+## Implementation Complete ✅
+
+The gateway now implements an **8-layer routing architecture** with intelligent load balancing:
+
+```
+┌─────────────┐
+│ Model Name  │  "qwen2.5-coder:7b"
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│   Layer 2   │  API abstraction (MCP server)
+│     API     │  Tool: route_request
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│   Layer 3   │  Provider resolution
+│  Provider   │  "qwen2.5-coder:7b" → "BlackRoad AI"
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│   Layer 4   │  Provider API interface
+│     API     │  Ollama REST API
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│   Layer 5   │  Instance selection
+│ API Instance│  http://localhost:11434
+└──────┬──────┘  http://cecilia:11434
+       │         http://lucidia:11434
+       ▼
+┌─────────────┐
+│   Layer 6   │  Model → Provider → Instance
+│  API Map    │  Central mapping registry
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│   Layer 7   │  Routing decision
+│    Route    │  + Load balancing strategy
+└──────┬──────┘  + Performance tracking
+       │
+       ▼
+┌─────────────┐
+│   Layer 8+  │  Additional intelligence
+│     ...     │  - Fallback logic
+│             │  - Retry logic
+└──────┬──────┘  - Circuit breaker
+       │         - Adaptive routing
+       ▼
+┌─────────────┐
+│  BlackRoad  │  Final: Model execution
+│   AI Core   │  Return response
+└─────────────┘
+```
+
+## Architecture Components
+
+### Layer 1: Model Name
+- User requests: "qwen2.5-coder:7b"
+- System receives model identifier
+
+### Layer 2: API Abstraction
+- **File**: `server-v2.js`
+- **Function**: MCP server with stdio transport
+- **Tools**: route_request, list_models, gateway_stats, health_check
+
+### Layer 3: Provider Resolution
+- **File**: `layers/api-map.js` → `resolveModel()`
+- **Function**: Maps model name to provider
+- Example: "qwen2.5-coder:7b" → "BlackRoad AI"
+
+### Layer 4: Provider API
+- **File**: `layers/api-provider.js`
+- **Function**: Provider-specific API interface
+- Manages multiple instances per provider
+
+### Layer 5: Instance Selection
+- **File**: `layers/api-provider.js` → `selectInstance(strategy)`
+- **Strategies**:
+  - `round-robin`: Even distribution
+  - `least-loaded`: Fewest active requests
+  - `fastest`: Lowest average latency
+- **Health Checking**: Auto-exclude unhealthy instances
+
+### Layer 6: API Map
+- **File**: `layers/api-map.js`
+- **Function**: Central registry
+- **Mappings**:
+  - Model → Provider
+  - Provider → Instances
+  - Health tracking
+  - Performance metrics
+
+### Layer 7: Route Execution
+- **File**: `layers/route-engine.js` → `route()`
+- **Function**: Execute routing decision
+- **Tracking**:
+  - Load counting (increment/decrement)
+  - Latency measurement
+  - Success rate calculation
+  - Routing history logging
+
+### Layer 8+: Intelligence
+- **Fallback**: Try next model if primary fails
+- **Retry**: Retry transient failures
+- **Circuit Breaker**: Stop routing to failed instances
+- **Adaptive Routing**: Learn from performance data
+
+### Final: BlackRoad Execution
+- **File**: `models/ollama-client.js` → `generate()`
+- **Function**: Actual model inference
+- Returns response with metadata
+
+## Key Classes
+
+### ApiProvider
+```javascript
+class ApiProvider {
+  name // 'BlackRoad AI'
+  type // 'ollama'
+  instances[] // Multiple endpoints
+  selectInstance(strategy) // Choose best instance
+}
+```
+
+### ApiInstance
+```javascript
+class ApiInstance {
+  endpoint // 'http://localhost:11434'
+  healthy // true/false
+  load // Active requests
+  avgLatency // Exponential moving average
+  successRate // Successful / total
+  
+  checkHealth() // Periodic health check
+  recordRequest(latency, success) // Update metrics
+}
+```
+
+### ApiMap
+```javascript
+class ApiMap {
+  providers // Map<name, Provider>
+  modelMap // Map<model, provider>
+  
+  resolveModel(model, strategy) // Full resolution
+  healthCheck() // Check all instances
+  getStats() // Aggregate metrics
+}
+```
+
+### RouteEngine
+```javascript
+class RouteEngine {
+  apiMap // Central registry
+  routingHistory // Last 1000 decisions
+  
+  route(request, classification) // Complete flow
+  selectModel(classification) // Choose model
+  getStats() // Routing statistics
+}
+```
+
+## Usage
+
+### Start Gateway v2
+```bash
+cd ~/copilot-agent-gateway
+OLLAMA_ENDPOINT=http://localhost:11434 node server-v2.js
+```
+
+Output:
+```
+🗺️  Route engine initialized with 1 instance(s)
+🌌 BlackRoad Copilot Gateway v2 running on stdio
+🤖 BlackRoad AI endpoint: http://localhost:11434
+📡 Multi-layer routing: Model -> API -> Provider -> Instance -> Route -> BlackRoad
+🗺️  Route engine ready with intelligent load balancing
+```
+
+### Add More Instances
+Edit `layers/route-engine.js`:
+```javascript
+const endpoints = [
+  'http://localhost:11434',
+  'http://cecilia:11434',    // Add
+  'http://lucidia:11434',    // Add
+  'http://octavia:11434'     // Add
+]
+```
+
+Gateway will automatically:
+- ✅ Load balance across all instances
+- ✅ Health check each instance
+- ✅ Route to best available instance
+- ✅ Track performance per instance
+
+### Routing Strategies
+
+**Round Robin** (default)
+- Distributes requests evenly
+- Good for uniform workloads
+
+**Least Loaded**
+- Routes to instance with fewest active requests
+- Best for varying request durations
+- **Currently active** in server-v2.js
+
+**Fastest**
+- Routes to instance with lowest latency
+- Optimal for latency-sensitive apps
+
+## Performance Tracking
+
+Per instance:
+```javascript
+{
+  load: 3,              // 3 active requests
+  avgLatency: 842,      // 842ms average
+  successRate: 0.97,    // 97% success
+  totalRequests: 1247,
+  healthy: true
+}
+```
+
+Gateway stats:
+```javascript
+{
+  providers: 1,
+  models: 5,
+  instances: 4,
+  healthyInstances: 4,
+  totalLoad: 12,        // 12 requests across all
+  avgLatency: 756,      // 756ms average
+  totalRoutes: 1247,
+  recentRoutes: [...]   // Last 10 decisions
+}
+```
+
+## What This Gives You
+
+1. **Scalability**: Add instances without code changes
+2. **Reliability**: Auto-failover to healthy instances
+3. **Performance**: Route to fastest/least-loaded instance
+4. **Observability**: Track metrics per instance
+5. **Flexibility**: Support multiple providers (OpenAI, Anthropic, etc.)
+6. **Intelligence**: Learn from routing history
+
+## Next Steps
+
+1. Deploy gateway to Pi fleet
+2. Add cecilia:11434, lucidia:11434 as instances
+3. Monitor routing decisions
+4. Optimize based on performance data
+5. Add adaptive routing (learn from history)
+
+## Architecture Benefits
+
+- ✅ **8-layer separation of concerns**
+- ✅ **Load balancing built-in**
+- ✅ **Health monitoring automatic**
+- ✅ **Performance tracking real-time**
+- ✅ **Multi-instance ready**
+- ✅ **Multi-provider capable**
+- ✅ **Failover automatic**
+- ✅ **Metrics per instance**
+
+**Your vision is now reality.** 🌌

src/gateway/upstream/QUICK_START_V2.md

@@ -0,0 +1,193 @@
+# Quick Start: Gateway v2 with Multi-Layer Routing
+
+## 🚀 Start Gateway v2
+
+```bash
+cd ~/copilot-agent-gateway
+OLLAMA_ENDPOINT=http://localhost:11434 node server-v2.js
+```
+
+You'll see:
+```
+🗺️  Route engine initialized with 1 instance(s)
+<EFBFBD><EFBFBD> BlackRoad Copilot Gateway v2 running on stdio
+🤖 BlackRoad AI endpoint: http://localhost:11434
+📡 Multi-layer routing: Model -> API -> Provider -> Instance -> Route -> BlackRoad
+🗺️  Route engine ready with intelligent load balancing
+```
+
+## 📡 Multi-Instance Setup (Scale Across Fleet)
+
+### 1. Edit Route Engine
+Edit `layers/route-engine.js` line ~25:
+
+```javascript
+const endpoints = [
+  'http://localhost:11434',
+  'http://cecilia:11434',    // ← Add this
+  'http://lucidia:11434',    // ← Add this
+  'http://octavia:11434'     // ← Add this
+]
+```
+
+### 2. Restart Gateway
+```bash
+cd ~/copilot-agent-gateway
+OLLAMA_ENDPOINT=http://localhost:11434 node server-v2.js
+```
+
+Now shows:
+```
+🗺️  Route engine initialized with 4 instance(s)
+```
+
+## 🎯 What This Does
+
+The gateway now:
+- ✅ **Load balances** across 4 BlackRoad AI instances
+- ✅ **Health checks** each instance every 30s
+- ✅ **Routes** to least-loaded instance automatically
+- ✅ **Tracks** performance per instance
+- ✅ **Fails over** to healthy instances
+- ✅ **Recovers** automatically when instance comes back
+
+## 📊 Check Status
+
+### Via Copilot CLI
+```bash
+# Get gateway stats
+copilot mcp call blackroad-gateway gateway_stats
+
+# Health check all instances
+copilot mcp call blackroad-gateway health_check
+
+# List models
+copilot mcp call blackroad-gateway list_models
+```
+
+### Response Format
+```json
+{
+  "stats": {
+    "providers": 1,
+    "models": 5,
+    "instances": 4,
+    "healthyInstances": 4,
+    "totalLoad": 0,
+    "avgLatency": 0,
+    "totalRoutes": 0,
+    "recentRoutes": []
+  }
+}
+```
+
+## 🔄 Routing Flow
+
+When you send a request:
+
+```
+Your Prompt
+    ↓
+Layer 1: Model Name
+    "qwen2.5-coder:7b" (auto-selected based on intent)
+    ↓
+Layer 2: API
+    MCP Server receives request
+    ↓
+Layer 3: Provider
+    Maps to "BlackRoad AI"
+    ↓
+Layer 4: API Interface
+    Ollama REST API
+    ↓
+Layer 5: Instance Selection
+    Chooses: http://cecilia:11434 (least loaded)
+    ↓
+Layer 6: API Map
+    Confirms mapping and health
+    ↓
+Layer 7: Route Execution
+    Increments load counter
+    Sends request
+    Records metrics
+    Decrements load counter
+    ↓
+Layer 8+: Intelligence
+    Logs routing decision
+    Updates performance stats
+    ↓
+BlackRoad AI Core
+    Model inference
+    Returns response
+```
+
+## 🎨 Routing Strategies
+
+### Currently Active: Least Loaded
+Routes to instance with fewest active requests.
+
+**Change strategy** in `layers/route-engine.js` line ~54:
+```javascript
+const resolution = await this.apiMap.resolveModel(modelName, 'least-loaded')
+//                                                            ↑ change this
+```
+
+**Options**:
+- `'round-robin'` - Even distribution
+- `'least-loaded'` - Fewest active requests (current)
+- `'fastest'` - Lowest average latency
+
+## 📈 Performance Tracking
+
+Every request updates:
+```javascript
+{
+  load: 2,              // Current active requests
+  avgLatency: 756,      // Exponential moving average
+  successRate: 0.97,    // 97% successful
+  totalRequests: 143,
+  healthy: true
+}
+```
+
+Check anytime:
+```bash
+copilot mcp call blackroad-gateway gateway_stats
+```
+
+## 🏥 Health Monitoring
+
+Each instance auto-checks health via `/api/tags`.
+
+Unhealthy instances:
+- ❌ Excluded from routing
+- 🔄 Re-checked every 30s
+- ✅ Auto-added back when healthy
+
+## 🚀 Deploy to Pis
+
+```bash
+~/deploy-copilot-gateway.sh
+```
+
+This:
+1. Copies gateway to each Pi
+2. Creates systemd service
+3. Configures local endpoint
+4. Starts gateway
+
+Target Pis:
+- cecilia (primary AI agent)
+- lucidia (inference node)
+- alice (worker)
+- octavia (quantum)
+- anastasia, aria, cordelia
+
+## 🎯 Next Steps
+
+1. **Add more instances** to route-engine.js
+2. **Monitor routing** decisions in gateway logs
+3. **Optimize strategy** based on performance data
+4. **Add adaptive routing** (learn from history)
+
+Your 8-layer architecture is live! 🌌

src/gateway/upstream/README.md

@@ -0,0 +1,127 @@
+# BlackRoad Copilot Agent Gateway
+
+Intelligent routing gateway that routes GitHub Copilot CLI requests to optimal local AI agents running on BlackRoad infrastructure.
+
+## 🎯 What It Does
+
+- **Classifies** incoming requests by intent (code generation, analysis, debugging, etc.)
+- **Routes** to the best available local AI model (qwen, deepseek, llama3, mistral, codellama)
+- **Tracks** performance and learns which models work best for which tasks
+- **Integrates** seamlessly with GitHub Copilot CLI via MCP protocol
+
+## 🚀 Quick Start
+
+### Install Dependencies
+```bash
+npm install
+```
+
+### Start Gateway
+```bash
+# Default (Octavia endpoint)
+npm start
+
+# Custom Ollama endpoint
+OLLAMA_ENDPOINT=http://localhost:11434 npm start
+```
+
+### Configure Copilot CLI
+Add to `~/.copilot/mcp-config.json`:
+```json
+{
+  "mcpServers": {
+    "blackroad-gateway": {
+      "command": "node",
+      "args": ["/path/to/copilot-agent-gateway/server.js"]
+    }
+  }
+}
+```
+
+Then in Copilot CLI:
+```bash
+copilot
+> /mcp
+```
+
+## 📦 Available Tools
+
+- **route_request** - Route request to optimal AI agent
+- **list_models** - List all available models
+- **model_status** - Check model health
+- **gateway_stats** - View gateway statistics
+
+## 🤖 Supported Models
+
+| Model | Best For |
+|-------|----------|
+| qwen2.5-coder:7b | Code analysis, refactoring, templates |
+| deepseek-coder:6.7b | Code generation, new features |
+| llama3:8b | Documentation, planning, explanations |
+| mistral:7b | Fast reasoning, quick tasks |
+| codellama:7b | Code review, understanding |
+
+## 🔧 Configuration
+
+### Model Registry
+Edit `models/registry.json` to add/remove models or adjust capabilities.
+
+### Routing Rules
+Edit `config/routing-rules.json` to customize intent classification keywords.
+
+### Ollama Endpoint
+Set `OLLAMA_ENDPOINT` environment variable (default: `http://octavia:11434`)
+
+## 📊 Logging
+
+Routing history is logged to:
+- `~/.blackroad/copilot-gateway/routing-history.jsonl`
+- PS-SHA-∞ memory system (future)
+
+## 🏗️ Architecture
+
+```
+GitHub Copilot CLI
+        ↓
+MCP Server (stdio)
+        ↓
+Request Classifier (keyword-based)
+        ↓
+Router (selects optimal model)
+        ↓
+Ollama API (local fleet)
+        ↓
+Response to Copilot
+```
+
+## 🔍 Example Routing
+
+- "Create a new React component" → **deepseek-coder:6.7b** (code_generation)
+- "Refactor this function" → **qwen2.5-coder:7b** (code_refactoring)
+- "Explain this algorithm" → **llama3:8b** (documentation)
+- "Debug this error" → **deepseek-coder:6.7b** (debugging)
+- "Write tests" → **qwen2.5-coder:7b** (testing)
+
+## 📈 Performance
+
+- Classification: <10ms
+- Routing overhead: <50ms
+- Total latency: Depends on model + request complexity
+
+## 🛠️ Development
+
+```bash
+# Watch mode
+npm run dev
+
+# Test locally
+node server.js
+```
+
+## 📝 License
+
+Proprietary - See `../BLACKROAD_PROPRIETARY_LICENSE.md`
+
+## 🌌 BlackRoad OS
+
+Part of the BlackRoad OS distributed AI infrastructure.

src/gateway/upstream/WEBSITE_INTEGRATION.md

@@ -0,0 +1,234 @@
+# Website Integration Complete ✅
+
+The BlackRoad Copilot Gateway is now integrated with **all 13 BlackRoad websites**.
+
+## 🌐 Integrated Sites
+
+All sites now have `/api/gateway/*` endpoints:
+
+1. **web.blackroad.io** - Main website
+2. **api.blackroad.io** - Public API
+3. **brand.blackroad.io** - Brand portal
+4. **console.blackroad.io** - Console interface
+5. **core.blackroad.io** - Core platform
+6. **demo.blackroad.io** - Demo environment
+7. **docs.blackroad.io** - Documentation
+8. **operator.blackroad.io** - Operator dashboard
+9. **prism.blackroad.io** - Prism console
+10. **research.blackroad.io** - Research portal
+11. **ideas.blackroad.io** - Ideas platform
+12. **infra.blackroad.io** - Infrastructure dashboard
+13. **dashboard.blackroad.io** - Main dashboard
+
+## 🔌 Gateway Endpoints
+
+Every site now supports:
+
+```bash
+# Get gateway stats
+GET https://{site}/api/gateway/stats
+
+# Check instance health  
+GET https://{site}/api/gateway/health
+
+# List available models
+GET https://{site}/api/gateway/models
+
+# Get routing history
+GET https://{site}/api/gateway/routing-history?limit=50
+
+# Test routing (POST)
+POST https://{site}/api/gateway/test-route
+{
+  "prompt": "Your prompt here",
+  "intent": "code_generation"  // optional
+}
+```
+
+## 📝 What Was Added
+
+Each service received:
+
+### 1. Gateway API Route
+**Location**: `/app/api/gateway/[[...path]]/route.ts`
+
+```typescript
+// Proxies all /api/gateway/* requests to gateway
+GET  /api/gateway/stats → GATEWAY_URL/api/stats
+POST /api/gateway/test-route → GATEWAY_URL/api/test-route
+```
+
+### 2. Environment Variable
+**File**: `.env.example`
+
+```bash
+GATEWAY_URL=http://localhost:3030
+# Or production: https://gateway.blackroad.io
+```
+
+## 🚀 Deployment Options
+
+### Option 1: Centralized Gateway (Recommended)
+
+Deploy gateway once, all sites connect:
+
+```bash
+cd ~/copilot-agent-gateway
+railway up
+```
+
+Set in all services:
+```bash
+GATEWAY_URL=https://copilot-gateway.up.railway.app
+```
+
+**Pros:**
+- ✅ Single source of truth
+- ✅ Easy monitoring
+- ✅ Centralized metrics
+- ✅ Simple updates
+
+### Option 2: Distributed (Pi Fleet)
+
+Run gateway on each Pi:
+
+```bash
+~/deploy-copilot-gateway.sh
+```
+
+Sites connect to nearest Pi:
+```bash
+GATEWAY_URL=http://cecilia:3030  # for cecilia services
+GATEWAY_URL=http://lucidia:3030  # for lucidia services
+```
+
+**Pros:**
+- ✅ Low latency
+- ✅ High availability
+- ✅ Load distribution
+- ✅ No single point of failure
+
+### Option 3: Hybrid
+
+- **Central gateway** for web dashboard/monitoring
+- **Local gateways** for MCP/CLI usage
+- Best of both worlds
+
+## 🧪 Testing
+
+Start gateway locally:
+```bash
+~/start-gateway-web.sh
+```
+
+Test from any service:
+```bash
+cd ~/services/web
+npm run dev
+
+# In another terminal
+curl http://localhost:3000/api/gateway/stats
+```
+
+Expected response:
+```json
+{
+  "success": true,
+  "stats": {
+    "providers": 1,
+    "instances": 1,
+    "healthyInstances": 1,
+    "totalRoutes": 0,
+    "avgLatency": 0
+  }
+}
+```
+
+## 📊 Usage in Components
+
+### React Component Example
+
+```typescript
+'use client'
+
+import { useEffect, useState } from 'react'
+
+export function GatewayStatus() {
+  const [stats, setStats] = useState(null)
+
+  useEffect(() => {
+    fetch('/api/gateway/stats')
+      .then(res => res.json())
+      .then(data => setStats(data.stats))
+  }, [])
+
+  if (!stats) return <div>Loading...</div>
+
+  return (
+    <div>
+      <h3>Gateway Status</h3>
+      <p>Instances: {stats.healthyInstances}/{stats.instances}</p>
+      <p>Total Routes: {stats.totalRoutes}</p>
+      <p>Avg Latency: {stats.avgLatency}ms</p>
+    </div>
+  )
+}
+```
+
+### Server Component Example
+
+```typescript
+async function getGatewayHealth() {
+  const res = await fetch('http://localhost:3030/api/health', {
+    cache: 'no-store'
+  })
+  return res.json()
+}
+
+export default async function GatewayPage() {
+  const { instances } = await getGatewayHealth()
+
+  return (
+    <div>
+      <h1>Gateway Instances</h1>
+      {instances.map(inst => (
+        <div key={inst.endpoint}>
+          <p>{inst.endpoint}</p>
+          <p>Status: {inst.healthy ? '✅' : '❌'}</p>
+          <p>Load: {inst.load}</p>
+        </div>
+      ))}
+    </div>
+  )
+}
+```
+
+## 🔐 Security Considerations
+
+1. **Rate Limiting**: Add rate limiting to gateway endpoints
+2. **Authentication**: Require API keys for production
+3. **CORS**: Configure CORS in web-server.js
+4. **Monitoring**: Track gateway usage per site
+
+## 📈 Monitoring
+
+Gateway provides metrics for:
+- Requests per site (via X-Gateway-Client header)
+- Success rates per site
+- Latency per site
+- Model usage per site
+
+Check gateway logs to see which sites are using it:
+```bash
+tail -f ~/copilot-agent-gateway/logs/access.log
+```
+
+## 🎯 Next Steps
+
+1. ✅ Deploy gateway to Railway
+2. ✅ Update all service .env files with GATEWAY_URL
+3. ✅ Test integration on each site
+4. ✅ Monitor usage via gateway dashboard
+5. ✅ Add gateway status indicators to site footers
+
+**All 13 sites are now gateway-ready!** 🌌

src/gateway/upstream/WEB_DASHBOARD.md

@@ -0,0 +1,251 @@
+# Web Dashboard
+
+## 🌐 Visual Gateway Interface
+
+The BlackRoad Copilot Gateway now includes a **beautiful web dashboard** for real-time monitoring and visualization.
+
+## 🚀 Quick Start
+
+```bash
+~/start-gateway-web.sh
+```
+
+Or manually:
+```bash
+cd ~/copilot-agent-gateway
+OLLAMA_ENDPOINT=http://localhost:11434 node web-server.js
+```
+
+Then open: **http://localhost:3030**
+
+## ✨ Dashboard Features
+
+### Real-Time Status Bar
+- **Providers**: Number of AI providers registered
+- **Instances**: Healthy/total instance count
+- **Total Routes**: Cumulative routing decisions
+- **Avg Latency**: Average response time across all instances
+
+### Instance Health Monitor
+Shows each API instance with:
+- 🟢 **Health Status**: Healthy/Down indicator
+- **Endpoint**: Instance URL
+- **Load**: Active requests
+- **Latency**: Average response time
+- **Success Rate**: % of successful requests
+
+### Available Models
+Lists all BlackRoad AI models:
+- Model name (e.g., qwen2.5-coder:7b)
+- Description
+- Priority level
+- Capabilities
+
+### Recent Routing Decisions
+Live feed of routing activity:
+- Intent classification
+- Latency
+- Request preview
+- Selected model
+- Target instance
+- Success/failure status
+
+### Auto-Refresh
+Dashboard updates every 5 seconds automatically.
+
+## 📊 API Endpoints
+
+### GET /api/stats
+Gateway statistics:
+```json
+{
+  "success": true,
+  "stats": {
+    "providers": 1,
+    "models": 5,
+    "instances": 1,
+    "healthyInstances": 1,
+    "totalLoad": 0,
+    "avgLatency": 0,
+    "totalRoutes": 0,
+    "recentRoutes": []
+  }
+}
+```
+
+### GET /api/health
+Instance health check:
+```json
+{
+  "success": true,
+  "instances": [
+    {
+      "provider": "BlackRoad AI",
+      "endpoint": "http://localhost:11434",
+      "healthy": true,
+      "load": 0,
+      "avgLatency": 0,
+      "successRate": 0
+    }
+  ]
+}
+```
+
+### GET /api/models
+List available models:
+```json
+{
+  "success": true,
+  "models": [
+    {
+      "name": "qwen2.5-coder:7b",
+      "provider": "BlackRoad AI",
+      "capabilities": ["code_analysis", "code_refactoring"],
+      "priority": 1,
+      "description": "Best for code analysis"
+    }
+  ]
+}
+```
+
+### GET /api/routing-history?limit=50
+Recent routing decisions:
+```json
+{
+  "success": true,
+  "history": [
+    {
+      "timestamp": "2026-02-18T01:58:00.000Z",
+      "request": "Write a function to...",
+      "intent": "code_generation",
+      "confidence": 0.95,
+      "modelSelected": "deepseek-coder:6.7b",
+      "provider": "BlackRoad AI",
+      "instance": "http://localhost:11434",
+      "latency": 842,
+      "success": true
+    }
+  ]
+}
+```
+
+### POST /api/test-route
+Test routing (for development):
+```bash
+curl -X POST http://localhost:3030/api/test-route \
+  -H "Content-Type: application/json" \
+  -d '{
+    "prompt": "Fix this bug in my code",
+    "intent": "debugging"
+  }'
+```
+
+Response:
+```json
+{
+  "success": true,
+  "routing": {
+    "intent": "debugging",
+    "confidence": 1.0,
+    "model": "deepseek-coder:6.7b",
+    "provider": "BlackRoad AI",
+    "instance": "http://localhost:11434",
+    "latency": 756,
+    "load": 0
+  },
+  "response": "..."
+}
+```
+
+## 🎨 Design
+
+The dashboard features:
+- **BlackRoad Brand Colors**:
+  - Hot Pink (#ff1d6c)
+  - Amber (#f5a623)
+  - Electric Blue (#2979ff)
+  - Dark gradient background
+
+- **Responsive Grid Layout**
+- **Auto-refreshing data**
+- **Status indicators** (green/red)
+- **Smooth animations**
+- **Mobile-friendly**
+
+## 🔧 Configuration
+
+### Change Port
+```bash
+PORT=8080 node web-server.js
+```
+
+### Multiple Instances
+Edit `layers/route-engine.js` to add more endpoints:
+```javascript
+const endpoints = [
+  'http://localhost:11434',
+  'http://cecilia:11434',
+  'http://lucidia:11434'
+]
+```
+
+Dashboard will automatically show all instances with individual health/metrics.
+
+## 🚀 Deployment
+
+### Local Development
+```bash
+~/start-gateway-web.sh
+```
+
+### Production (systemd)
+```bash
+# Deploy to Pi fleet
+~/deploy-copilot-gateway.sh
+```
+
+Each Pi will run:
+- MCP gateway (stdio) for Copilot CLI
+- Web dashboard on port 3030
+- Both connected to local Ollama
+
+### Access Across Network
+```bash
+# Start web server
+PORT=3030 node web-server.js
+
+# Access from other machines
+http://<pi-ip>:3030
+```
+
+## 📈 Use Cases
+
+1. **Monitor Gateway Health**
+   - See which instances are up/down
+   - Track success rates
+   - Identify performance issues
+
+2. **Debug Routing Decisions**
+   - Watch routing history in real-time
+   - See which models are selected
+   - Check latency per request
+
+3. **Performance Analysis**
+   - Compare instance performance
+   - Identify bottlenecks
+   - Optimize routing strategy
+
+4. **Demo/Presentation**
+   - Show live routing in action
+   - Visualize multi-layer architecture
+   - Demonstrate load balancing
+
+## 🎯 Next Steps
+
+1. **Add Charts**: Visualize latency trends, success rates over time
+2. **Add Filters**: Filter routing history by intent, model, success
+3. **Add Controls**: Manually trigger health checks, clear history
+4. **Add Alerts**: Notify when instances go down
+5. **Add Metrics Export**: Download performance data as CSV/JSON
+
+Your gateway now has a beautiful visual interface! 🌌

src/gateway/upstream/architecture.md

@@ -0,0 +1,152 @@
+# BlackRoad Gateway Architecture
+
+## Multi-Layer Routing Flow
+
+```
+┌─────────────┐
+│ Model Name  │  "qwen2.5-coder:7b"
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│   API       │  Initial API abstraction
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│  Provider   │  BlackRoad AI (Ollama-powered)
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│   API       │  Provider-specific API interface
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│ API Instance│  http://localhost:11434
+└──────┬──────┘  http://cecilia:11434
+       │         http://lucidia:11434
+       ▼
+┌─────────────┐
+│  API Map    │  Model -> Provider -> Instance mapping
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│   Route     │  Routing decision with load balancing
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│    ...      │  Additional routing layers (fallback, retry, etc.)
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│  BlackRoad  │  Actual model execution
+└─────────────┘
+```
+
+## Components
+
+### Layer 1: Model Name
+- User requests a specific model
+- Example: "qwen2.5-coder:7b"
+
+### Layer 2: API Abstraction
+- Initial API layer that receives the request
+- MCP server tools: `route_request`
+
+### Layer 3: Provider Resolution
+- Maps model to provider
+- Example: "qwen2.5-coder:7b" -> "BlackRoad AI"
+
+### Layer 4: Provider API
+- Provider-specific API interface
+- BlackRoad AI uses Ollama REST API
+
+### Layer 5: Instance Selection
+- Multiple API instances for load balancing
+- Strategies: round-robin, least-loaded, fastest
+- Health checking and auto-recovery
+
+### Layer 6: API Map
+- Central mapping registry
+- Model -> Provider -> Instance
+- Tracks health, load, latency per instance
+
+### Layer 7: Route Execution
+- Executes the routing decision
+- Tracks performance metrics
+- Logs routing history
+
+### Layer 8+: Additional Intelligence
+- Fallback logic (try next model if primary fails)
+- Retry logic (retry on transient failures)
+- Circuit breaker (stop routing to failed instances)
+- Adaptive routing (learn from performance data)
+
+### Final: BlackRoad Execution
+- Actual model inference
+- Return response to user
+
+## Key Classes
+
+### `ApiProvider`
+- Represents a provider (e.g., "BlackRoad AI")
+- Manages multiple API instances
+- Selects instances based on strategy
+
+### `ApiInstance`
+- Single API endpoint
+- Tracks: health, load, latency, success rate
+- Self-healing health checks
+
+### `ApiMap`
+- Central registry
+- Maps: model -> provider -> instance
+- Provides routing resolution
+
+### `RouteEngine`
+- Orchestrates complete routing flow
+- Handles all 8+ layers
+- Logs performance metrics
+
+## Routing Strategies
+
+### Round Robin
+- Distribute requests evenly across instances
+- Good for uniform workloads
+
+### Least Loaded
+- Route to instance with fewest active requests
+- Best for varying request durations
+
+### Fastest
+- Route to instance with lowest average latency
+- Optimal for latency-sensitive applications
+
+## Health & Recovery
+
+- Periodic health checks (every 30s)
+- Auto-mark unhealthy instances
+- Auto-recover when healthy again
+- Circuit breaker prevents cascade failures
+
+## Performance Tracking
+
+Per instance:
+- Active load (current requests)
+- Average latency (exponential moving average)
+- Success rate (successful / total requests)
+- Last health check timestamp
+
+## Future Enhancements
+
+1. **Geo-routing**: Route based on instance location
+2. **Cost optimization**: Route to cheapest available instance
+3. **Quality routing**: Route based on model quality scores
+4. **A/B testing**: Split traffic for experimentation
+5. **Canary deployments**: Gradually roll out new instances
+

src/gateway/upstream/classifier.js

@@ -0,0 +1,51 @@
+// Request intent classifier
+import { readFile } from 'fs/promises'
+
+export class RequestClassifier {
+  constructor() {
+    this.rules = null
+  }
+
+  async load() {
+    const data = await readFile('./config/routing-rules.json', 'utf-8')
+    this.rules = JSON.parse(data)
+  }
+
+  classify(request) {
+    if (!this.rules) {
+      throw new Error('Classifier not loaded')
+    }
+
+    const text = request.toLowerCase()
+    let bestMatch = { intent: this.rules.default_intent, confidence: 0 }
+
+    // Check each intent's keywords
+    for (const [intent, config] of Object.entries(this.rules.intents)) {
+      if (config.keywords.length === 0) continue
+
+      let matches = 0
+      for (const keyword of config.keywords) {
+        if (text.includes(keyword.toLowerCase())) {
+          matches++
+        }
+      }
+
+      const confidence = matches / config.keywords.length
+      if (confidence > bestMatch.confidence) {
+        bestMatch = { intent, confidence }
+      }
+    }
+
+    // If no strong match (< 30% confidence), use default
+    if (bestMatch.confidence < 0.3) {
+      bestMatch.intent = this.rules.default_intent
+    }
+
+    return {
+      intent: bestMatch.intent,
+      confidence: bestMatch.confidence,
+      models: this.rules.intents[bestMatch.intent].models,
+      description: this.rules.intents[bestMatch.intent].description
+    }
+  }
+}

src/gateway/upstream/config/routing-rules.json

@@ -0,0 +1,45 @@
+{
+  "intents": {
+    "code_generation": {
+      "keywords": ["create", "generate", "build", "implement", "write code", "new function", "add feature"],
+      "models": ["deepseek-coder:6.7b", "qwen2.5-coder:7b", "codellama:7b"],
+      "description": "Creating new code from scratch"
+    },
+    "code_analysis": {
+      "keywords": ["analyze", "understand", "explain", "what does", "how does", "review", "audit"],
+      "models": ["qwen2.5-coder:7b", "codellama:7b", "deepseek-coder:6.7b"],
+      "description": "Understanding and analyzing existing code"
+    },
+    "code_refactoring": {
+      "keywords": ["refactor", "improve", "optimize", "clean up", "restructure", "modernize"],
+      "models": ["qwen2.5-coder:7b", "deepseek-coder:6.7b", "codellama:7b"],
+      "description": "Improving existing code structure"
+    },
+    "debugging": {
+      "keywords": ["debug", "fix", "error", "bug", "not working", "issue", "problem"],
+      "models": ["deepseek-coder:6.7b", "qwen2.5-coder:7b", "codellama:7b"],
+      "description": "Finding and fixing bugs"
+    },
+    "documentation": {
+      "keywords": ["document", "comment", "explain", "readme", "docs", "jsdoc", "docstring"],
+      "models": ["llama3:8b", "mistral:7b", "qwen2.5-coder:7b"],
+      "description": "Writing documentation and comments"
+    },
+    "architecture": {
+      "keywords": ["architecture", "design", "structure", "plan", "system", "approach"],
+      "models": ["llama3:8b", "mistral:7b", "qwen2.5-coder:7b"],
+      "description": "System design and architecture decisions"
+    },
+    "testing": {
+      "keywords": ["test", "unit test", "integration test", "spec", "coverage"],
+      "models": ["qwen2.5-coder:7b", "deepseek-coder:6.7b", "codellama:7b"],
+      "description": "Writing and maintaining tests"
+    },
+    "general": {
+      "keywords": [],
+      "models": ["llama3:8b", "mistral:7b", "qwen2.5-coder:7b"],
+      "description": "General purpose queries"
+    }
+  },
+  "default_intent": "general"
+}

src/gateway/upstream/integrations/README.md

@@ -0,0 +1,147 @@
+# Gateway Integrations for BlackRoad Websites
+
+This directory contains integration configs for adding gateway access to each BlackRoad website.
+
+## Quick Integration
+
+Add to any Next.js site:
+
+### 1. API Route: `/app/api/gateway/[...path]/route.ts`
+
+```typescript
+import { NextRequest, NextResponse } from 'next/server'
+
+const GATEWAY_URL = process.env.GATEWAY_URL || 'http://localhost:3030'
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: { path: string[] } }
+) {
+  const path = params.path.join('/')
+  const searchParams = request.nextUrl.searchParams
+  
+  const gatewayUrl = `${GATEWAY_URL}/api/${path}?${searchParams}`
+  
+  try {
+    const response = await fetch(gatewayUrl)
+    const data = await response.json()
+    return NextResponse.json(data)
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Gateway unavailable' },
+      { status: 503 }
+    )
+  }
+}
+```
+
+### 2. Environment Variable
+
+```bash
+# .env.local
+GATEWAY_URL=http://localhost:3030
+# Or production: https://gateway.blackroad.io
+```
+
+### 3. Usage in Components
+
+```typescript
+// Fetch gateway stats
+const response = await fetch('/api/gateway/stats')
+const { stats } = await response.json()
+
+// Check health
+const health = await fetch('/api/gateway/health')
+const { instances } = await health.json()
+
+// List models
+const models = await fetch('/api/gateway/models')
+const { models: modelList } = await models.json()
+```
+
+## Deployment Options
+
+### Option 1: Centralized Gateway (Railway)
+- Deploy gateway once to Railway
+- All sites connect to: `https://gateway.blackroad.io`
+- Single source of truth
+- Easy to monitor
+
+### Option 2: Distributed Gateways (Pi Fleet)
+- Each Pi runs gateway instance
+- Sites connect to nearest Pi
+- Low latency
+- High availability
+
+### Option 3: Hybrid
+- Central gateway for web dashboard
+- Local gateways for MCP/CLI
+- Best of both worlds
+
+## Sites Ready for Integration
+
+### api.blackroad.io
+- **Service**: blackroad-os-api
+- **Description**: Public API gateway
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### brand.blackroad.io
+- **Service**: blackroad-os-brand
+- **Description**: Brand assets and guidelines portal
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### console.blackroad.io
+- **Service**: blackroad-os-prism-console
+- **Description**: Prism console interface
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### core.blackroad.io
+- **Service**: blackroad-os-core
+- **Description**: Core platform services
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### dashboard.blackroad.io
+- **Service**: blackroad-os-operator
+- **Description**: Operator dashboard (alias)
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### demo.blackroad.io
+- **Service**: blackroad-os-demo
+- **Description**: Demo and sandbox environment
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### docs.blackroad.io
+- **Service**: blackroad-os-docs
+- **Description**: Documentation portal
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### ideas.blackroad.io
+- **Service**: blackroad-os-ideas
+- **Description**: Ideas and innovation hub
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### infra.blackroad.io
+- **Service**: blackroad-os-infra
+- **Description**: Infrastructure management portal
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### operator.blackroad.io
+- **Service**: blackroad-os-operator
+- **Description**: Operator control panel
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### prism.blackroad.io
+- **Service**: blackroad-os-prism-console
+- **Description**: Prism console main interface
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### research.blackroad.io
+- **Service**: blackroad-os-research
+- **Description**: Research and development portal
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+
+### web.blackroad.io
+- **Service**: blackroad-os-web
+- **Description**: Main marketing and public-facing website
+- **Integration**: Add `/app/api/gateway/[...path]/route.ts`
+

src/gateway/upstream/integrations/deploy-railway.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Deploy centralized gateway to Railway
+
+echo "🚂 Deploying BlackRoad Copilot Gateway to Railway..."
+
+cd ~/copilot-agent-gateway
+
+# Create railway.json if not exists
+cat > railway.json << 'CONFIG'
+{
+  "$schema": "https://railway.app/railway.schema.json",
+  "build": {
+    "builder": "NIXPACKS"
+  },
+  "deploy": {
+    "startCommand": "node web-server.js",
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 10
+  }
+}
+CONFIG
+
+echo "📦 Railway config created"
+echo ""
+echo "🚀 Deploy with:"
+echo "  railway up"
+echo ""
+echo "🌐 After deployment, set GATEWAY_URL in all sites:"
+echo "  GATEWAY_URL=https://copilot-gateway-production.up.railway.app"

src/gateway/upstream/integrations/route.ts

@@ -0,0 +1,73 @@
+// BlackRoad Copilot Gateway Integration
+// Add to: /app/api/gateway/[...path]/route.ts
+
+import { NextRequest, NextResponse } from 'next/server'
+
+const GATEWAY_URL = process.env.GATEWAY_URL || 'http://localhost:3030'
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: { path: string[] } }
+) {
+  const path = params.path.join('/')
+  const searchParams = request.nextUrl.searchParams
+  
+  const gatewayUrl = `${GATEWAY_URL}/api/${path}?${searchParams}`
+  
+  try {
+    const response = await fetch(gatewayUrl, {
+      headers: {
+        'X-Gateway-Client': request.headers.get('host') || 'unknown',
+        'X-Gateway-Timestamp': new Date().toISOString()
+      }
+    })
+    
+    const data = await response.json()
+    
+    return NextResponse.json(data, {
+      headers: {
+        'X-Gateway-Response': 'true',
+        'X-Gateway-Version': '2.0.0'
+      }
+    })
+  } catch (error) {
+    console.error('Gateway error:', error)
+    return NextResponse.json(
+      { 
+        success: false,
+        error: 'Gateway unavailable',
+        message: error instanceof Error ? error.message : 'Unknown error'
+      },
+      { status: 503 }
+    )
+  }
+}
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: { path: string[] } }
+) {
+  const path = params.path.join('/')
+  const body = await request.json()
+  
+  const gatewayUrl = `${GATEWAY_URL}/api/${path}`
+  
+  try {
+    const response = await fetch(gatewayUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Gateway-Client': request.headers.get('host') || 'unknown'
+      },
+      body: JSON.stringify(body)
+    })
+    
+    const data = await response.json()
+    return NextResponse.json(data)
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Gateway unavailable' },
+      { status: 503 }
+    )
+  }
+}

src/gateway/upstream/layers/api-instance.js

@@ -0,0 +1,48 @@
+// API Instance - represents a single API endpoint
+export class ApiInstance {
+  constructor(endpoint, provider) {
+    this.endpoint = endpoint
+    this.provider = provider
+    this.healthy = true
+    this.load = 0 // Active requests
+    this.avgLatency = 0
+    this.totalRequests = 0
+    this.successfulRequests = 0
+    this.lastHealthCheck = null
+  }
+
+  get successRate() {
+    return this.totalRequests > 0 
+      ? this.successfulRequests / this.totalRequests 
+      : 0
+  }
+
+  recordRequest(latency, success) {
+    this.totalRequests++
+    if (success) this.successfulRequests++
+    
+    // Update average latency (exponential moving average)
+    this.avgLatency = this.avgLatency * 0.9 + latency * 0.1
+  }
+
+  incrementLoad() {
+    this.load++
+  }
+
+  decrementLoad() {
+    this.load = Math.max(0, this.load - 1)
+  }
+
+  async checkHealth() {
+    try {
+      const response = await fetch(`${this.endpoint}/api/tags`)
+      this.healthy = response.ok
+      this.lastHealthCheck = Date.now()
+      return this.healthy
+    } catch (error) {
+      this.healthy = false
+      this.lastHealthCheck = Date.now()
+      return false
+    }
+  }
+}

src/gateway/upstream/layers/api-map.js

@@ -0,0 +1,106 @@
+// API Map - maps model names to provider instances
+import { ApiProvider } from './api-provider.js'
+import { ApiInstance } from './api-instance.js'
+
+export class ApiMap {
+  constructor() {
+    this.providers = new Map() // provider name -> ApiProvider
+    this.modelMap = new Map()  // model name -> provider name
+  }
+
+  registerProvider(name, type, config) {
+    const provider = new ApiProvider(name, type, config)
+    this.providers.set(name, provider)
+    return provider
+  }
+
+  addInstance(providerName, endpoint) {
+    const provider = this.providers.get(providerName)
+    if (!provider) {
+      throw new Error(`Provider ${providerName} not registered`)
+    }
+
+    const instance = new ApiInstance(endpoint, provider)
+    provider.addInstance(instance)
+    return instance
+  }
+
+  mapModel(modelName, providerName) {
+    this.modelMap.set(modelName, providerName)
+  }
+
+  async resolveModel(modelName, strategy = 'least-loaded') {
+    // Step 1: Model name -> Provider
+    const providerName = this.modelMap.get(modelName)
+    if (!providerName) {
+      throw new Error(`No provider mapped for model: ${modelName}`)
+    }
+
+    // Step 2: Provider -> Provider instance
+    const provider = this.providers.get(providerName)
+    if (!provider) {
+      throw new Error(`Provider ${providerName} not found`)
+    }
+
+    // Step 3: Select API instance
+    const instance = await provider.selectInstance(strategy)
+    if (!instance) {
+      throw new Error(`No healthy instances for provider: ${providerName}`)
+    }
+
+    return {
+      modelName,
+      provider: providerName,
+      instance: instance.endpoint,
+      load: instance.load,
+      latency: instance.avgLatency,
+      successRate: instance.successRate
+    }
+  }
+
+  async healthCheck() {
+    const results = []
+    for (const [name, provider] of this.providers) {
+      for (const instance of provider.instances) {
+        const healthy = await instance.checkHealth()
+        results.push({
+          provider: name,
+          endpoint: instance.endpoint,
+          healthy,
+          load: instance.load,
+          avgLatency: instance.avgLatency,
+          successRate: instance.successRate
+        })
+      }
+    }
+    return results
+  }
+
+  getStats() {
+    const stats = {
+      providers: this.providers.size,
+      models: this.modelMap.size,
+      instances: 0,
+      healthyInstances: 0,
+      totalLoad: 0,
+      avgLatency: 0
+    }
+
+    for (const provider of this.providers.values()) {
+      stats.instances += provider.instances.length
+      const healthy = provider.getHealthyInstances()
+      stats.healthyInstances += healthy.length
+      
+      for (const instance of provider.instances) {
+        stats.totalLoad += instance.load
+        stats.avgLatency += instance.avgLatency
+      }
+    }
+
+    if (stats.instances > 0) {
+      stats.avgLatency = stats.avgLatency / stats.instances
+    }
+
+    return stats
+  }
+}

src/gateway/upstream/layers/api-provider.js

@@ -0,0 +1,34 @@
+// API Provider layer - abstracts provider-specific APIs
+export class ApiProvider {
+  constructor(name, type, config) {
+    this.name = name // 'BlackRoad AI'
+    this.type = type // 'ollama', 'openai', 'anthropic', etc.
+    this.config = config
+    this.instances = [] // Multiple API instances
+    this.roundRobinIndex = 0
+  }
+
+  addInstance(instance) {
+    this.instances.push(instance)
+  }
+
+  getHealthyInstances() {
+    return this.instances.filter(i => i.healthy)
+  }
+
+  async selectInstance(strategy = 'round-robin') {
+    const healthy = this.getHealthyInstances()
+    if (healthy.length === 0) return null
+
+    switch (strategy) {
+      case 'round-robin':
+        return healthy[this.roundRobinIndex++ % healthy.length]
+      case 'least-loaded':
+        return healthy.reduce((a, b) => a.load < b.load ? a : b)
+      case 'fastest':
+        return healthy.reduce((a, b) => a.avgLatency < b.avgLatency ? a : b)
+      default:
+        return healthy[0]
+    }
+  }
+}

src/gateway/upstream/layers/route-engine.js

@@ -0,0 +1,154 @@
+// Route Engine - orchestrates the complete routing flow
+import { ApiMap } from './api-map.js'
+import { readFile } from 'fs/promises'
+import { OllamaClient } from '../models/ollama-client.js'
+
+export class RouteEngine {
+  constructor() {
+    this.apiMap = new ApiMap()
+    this.registry = null
+    this.routingHistory = []
+  }
+
+  async initialize() {
+    // Load model registry
+    const data = await readFile('./models/registry.json', 'utf-8')
+    this.registry = JSON.parse(data)
+
+    // Register BlackRoad AI provider
+    this.apiMap.registerProvider(
+      'BlackRoad AI',
+      'ollama',
+      { type: 'ollama', version: '0.1.0' }
+    )
+
+    // Add instances (can add multiple for load balancing)
+    const endpoints = [
+      process.env.BLACKROAD_AI_ENDPOINT || process.env.OLLAMA_ENDPOINT || 'http://localhost:11434',
+      // Add more instances: 'http://cecilia:11434', 'http://lucidia:11434', etc.
+    ]
+
+    for (const endpoint of endpoints) {
+      this.apiMap.addInstance('BlackRoad AI', endpoint)
+    }
+
+    // Map all models to BlackRoad AI provider
+    for (const model of this.registry.models) {
+      this.apiMap.mapModel(model.name, 'BlackRoad AI')
+    }
+
+    console.error(`🗺️  Route engine initialized with ${endpoints.length} instance(s)`)
+  }
+
+  async route(request, classification) {
+    const startTime = Date.now()
+    
+    // Step 1: Select best model based on classification
+    const modelName = await this.selectModel(classification)
+    
+    // Step 2-7: Model name -> API -> Provider -> Instance -> Route -> BlackRoad
+    const resolution = await this.apiMap.resolveModel(modelName, 'least-loaded')
+    
+    // Step 8: Execute request
+    const instance = resolution.instance
+    const client = new OllamaClient(instance)
+    
+    // Track load
+    const provider = this.apiMap.providers.get(resolution.provider)
+    const apiInstance = provider.instances.find(i => i.endpoint === instance)
+    apiInstance.incrementLoad()
+
+    try {
+      const result = await client.generate(modelName, request.prompt, request.options)
+      const latency = Date.now() - startTime
+      
+      // Record success
+      apiInstance.recordRequest(latency, result.success)
+      apiInstance.decrementLoad()
+
+      // Log routing decision
+      this.logRoute({
+        timestamp: new Date().toISOString(),
+        request: request.prompt.substring(0, 100),
+        intent: classification.intent,
+        confidence: classification.confidence,
+        modelSelected: modelName,
+        provider: resolution.provider,
+        instance: resolution.instance,
+        latency,
+        success: result.success
+      })
+
+      return {
+        success: result.success,
+        model: modelName,
+        provider: resolution.provider,
+        instance: resolution.instance,
+        response: result.response,
+        latency,
+        load: resolution.load
+      }
+    } catch (error) {
+      const latency = Date.now() - startTime
+      apiInstance.recordRequest(latency, false)
+      apiInstance.decrementLoad()
+
+      // Log failure
+      this.logRoute({
+        timestamp: new Date().toISOString(),
+        request: request.prompt.substring(0, 100),
+        intent: classification.intent,
+        modelSelected: modelName,
+        provider: resolution.provider,
+        instance: resolution.instance,
+        latency,
+        success: false,
+        error: error.message
+      })
+
+      throw error
+    }
+  }
+
+  async selectModel(classification) {
+    // Try each preferred model in order
+    for (const modelName of classification.models) {
+      const model = this.registry.models.find(m => m.name === modelName)
+      if (!model) continue
+
+      // Check if model is available
+      try {
+        await this.apiMap.resolveModel(modelName)
+        return modelName
+      } catch (error) {
+        continue // Try next model
+      }
+    }
+
+    // Fallback to default
+    return this.registry.fallback
+  }
+
+  logRoute(decision) {
+    this.routingHistory.push(decision)
+    
+    // Keep last 1000 decisions in memory
+    if (this.routingHistory.length > 1000) {
+      this.routingHistory.shift()
+    }
+  }
+
+  getStats() {
+    const apiStats = this.apiMap.getStats()
+    
+    return {
+      ...apiStats,
+      totalRoutes: this.routingHistory.length,
+      recentRoutes: this.routingHistory.slice(-10)
+    }
+  }
+
+  async healthCheck() {
+    return await this.apiMap.healthCheck()
+  }
+}

src/gateway/upstream/learning/adaptive-router.js

@@ -0,0 +1,86 @@
+// Adaptive Router
+// Uses performance learning to make smarter routing decisions
+
+import { PerformanceLearner } from './performance-learner.js'
+
+export class AdaptiveRouter {
+  constructor(routeEngine) {
+    this.routeEngine = routeEngine
+    this.learner = new PerformanceLearner()
+    this.adaptiveMode = true
+    this.initialized = false
+  }
+
+  async initialize() {
+    await this.learner.initialize()
+    this.initialized = true
+  }
+
+  async route(intent, prompt, options = {}) {
+    if (!this.initialized) await this.initialize()
+
+    const startTime = Date.now()
+    
+    try {
+      let models = options.models || []
+      
+      if (this.adaptiveMode && models.length > 0) {
+        models = this.reorderByPerformance(intent, models)
+      }
+
+      const result = await this.routeEngine.route(intent, prompt, {
+        ...options,
+        models
+      })
+
+      const latency = Date.now() - startTime
+      await this.learner.recordRequest(intent, result.model, true, latency, {
+        provider: result.provider,
+        instance: result.instance
+      })
+
+      return result
+    } catch (error) {
+      const latency = Date.now() - startTime
+      const attemptedModel = options.models?.[0] || 'unknown'
+      await this.learner.recordRequest(intent, attemptedModel, false, latency, {
+        error: error.message
+      })
+
+      throw error
+    }
+  }
+
+  reorderByPerformance(intent, models) {
+    const scored = models.map(model => ({
+      model,
+      score: this.learner.getPerformanceScore(intent, model)
+    }))
+
+    scored.sort((a, b) => b.score - a.score)
+    return scored.map(s => s.model)
+  }
+
+  getBestModel(intent) {
+    return this.learner.getBestModelForIntent(intent)
+  }
+
+  getRecommendations(intent, count = 3) {
+    return this.learner.getRecommendedModels(intent, count)
+  }
+
+  getStats() {
+    return {
+      adaptiveMode: this.adaptiveMode,
+      learning: this.learner.getStats()
+    }
+  }
+
+  enableAdaptiveMode() {
+    this.adaptiveMode = true
+  }
+
+  disableAdaptiveMode() {
+    this.adaptiveMode = false
+  }
+}

src/gateway/upstream/learning/performance-learner.js

@@ -0,0 +1,218 @@
+// Performance Learning System
+// Tracks model performance and learns from routing decisions
+
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { existsSync } from 'fs'
+import { dirname, join } from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+export class PerformanceLearner {
+  constructor(dataFile = null) {
+    this.dataFile = dataFile || join(__dirname, '../data/performance-history.json')
+    this.metricsFile = join(__dirname, '../data/performance-metrics.json')
+    this.history = []
+    this.metrics = {}
+    this.initialized = false
+  }
+
+  async initialize() {
+    // Ensure data directory exists
+    const dataDir = dirname(this.dataFile)
+    if (!existsSync(dataDir)) {
+      await mkdir(dataDir, { recursive: true })
+    }
+
+    this.history = await this.loadHistory()
+    this.metrics = await this.loadMetrics()
+    this.initialized = true
+  }
+
+  async loadHistory() {
+    try {
+      if (existsSync(this.dataFile)) {
+        const data = await readFile(this.dataFile, 'utf8')
+        return JSON.parse(data)
+      }
+    } catch (error) {
+      console.error('Failed to load performance history:', error)
+    }
+    return []
+  }
+
+  async loadMetrics() {
+    try {
+      if (existsSync(this.metricsFile)) {
+        const data = await readFile(this.metricsFile, 'utf8')
+        return JSON.parse(data)
+      }
+    } catch (error) {
+      console.error('Failed to load metrics:', error)
+    }
+    return {}
+  }
+
+  async saveHistory() {
+    try {
+      await writeFile(this.dataFile, JSON.stringify(this.history, null, 2))
+    } catch (error) {
+      console.error('Failed to save history:', error)
+    }
+  }
+
+  async saveMetrics() {
+    try {
+      await writeFile(this.metricsFile, JSON.stringify(this.metrics, null, 2))
+    } catch (error) {
+      console.error('Failed to save metrics:', error)
+    }
+  }
+
+  async recordRequest(intent, model, success, latency, details = {}) {
+    if (!this.initialized) await this.initialize()
+
+    const record = {
+      timestamp: new Date().toISOString(),
+      intent,
+      model,
+      success,
+      latency,
+      ...details
+    }
+
+    this.history.push(record)
+
+    // Keep only last 1000 records
+    if (this.history.length > 1000) {
+      this.history = this.history.slice(-1000)
+    }
+
+    await this.saveHistory()
+    await this.updateMetrics(intent, model, success, latency)
+  }
+
+  async updateMetrics(intent, model, success, latency) {
+    const key = `${intent}:${model}`
+    
+    if (!this.metrics[key]) {
+      this.metrics[key] = {
+        intent,
+        model,
+        totalRequests: 0,
+        successfulRequests: 0,
+        failedRequests: 0,
+        totalLatency: 0,
+        avgLatency: 0,
+        minLatency: Infinity,
+        maxLatency: 0,
+        successRate: 0,
+        lastUsed: null
+      }
+    }
+
+    const m = this.metrics[key]
+    m.totalRequests++
+    
+    if (success) {
+      m.successfulRequests++
+    } else {
+      m.failedRequests++
+    }
+
+    m.totalLatency += latency
+    m.avgLatency = m.totalLatency / m.totalRequests
+    m.minLatency = Math.min(m.minLatency, latency)
+    m.maxLatency = Math.max(m.maxLatency, latency)
+    m.successRate = m.successfulRequests / m.totalRequests
+    m.lastUsed = new Date().toISOString()
+
+    await this.saveMetrics()
+  }
+
+  getMetricsForIntent(intent) {
+    return Object.values(this.metrics)
+      .filter(m => m.intent === intent)
+      .sort((a, b) => {
+        if (Math.abs(a.successRate - b.successRate) > 0.1) {
+          return b.successRate - a.successRate
+        }
+        return a.avgLatency - b.avgLatency
+      })
+  }
+
+  getBestModelForIntent(intent) {
+    const metrics = this.getMetricsForIntent(intent)
+    const viable = metrics.filter(m => m.successRate > 0.7)
+    return viable.length > 0 ? viable[0].model : null
+  }
+
+  getRecommendedModels(intent, count = 3) {
+    const metrics = this.getMetricsForIntent(intent)
+    return metrics
+      .filter(m => m.successRate > 0.5)
+      .slice(0, count)
+      .map(m => ({
+        model: m.model,
+        successRate: m.successRate,
+        avgLatency: m.avgLatency,
+        confidence: this.calculateConfidence(m)
+      }))
+  }
+
+  calculateConfidence(metrics) {
+    const minRequests = 10
+    const requestFactor = Math.min(metrics.totalRequests / minRequests, 1)
+    return metrics.successRate * requestFactor
+  }
+
+  getPerformanceScore(intent, model) {
+    const key = `${intent}:${model}`
+    const m = this.metrics[key]
+    
+    if (!m || m.totalRequests < 5) {
+      return 0.5
+    }
+
+    const successScore = m.successRate
+    const latencyScore = 1 - Math.min(m.avgLatency / 5000, 1)
+    
+    return (successScore * 0.7) + (latencyScore * 0.3)
+  }
+
+  getStats() {
+    const totalRequests = this.history.length
+    const intents = [...new Set(this.history.map(r => r.intent))]
+    const models = [...new Set(this.history.map(r => r.model))]
+    const successRate = this.history.filter(r => r.success).length / totalRequests || 0
+    
+    return {
+      totalRequests,
+      uniqueIntents: intents.length,
+      uniqueModels: models.length,
+      overallSuccessRate: successRate,
+      avgLatency: this.history.reduce((sum, r) => sum + r.latency, 0) / totalRequests || 0,
+      topPerformers: this.getTopPerformers(5)
+    }
+  }
+
+  getTopPerformers(count = 5) {
+    return Object.values(this.metrics)
+      .filter(m => m.totalRequests >= 5)
+      .sort((a, b) => {
+        const scoreA = this.getPerformanceScore(a.intent, a.model)
+        const scoreB = this.getPerformanceScore(b.intent, b.model)
+        return scoreB - scoreA
+      })
+      .slice(0, count)
+      .map(m => ({
+        intent: m.intent,
+        model: m.model,
+        successRate: m.successRate,
+        avgLatency: m.avgLatency,
+        requests: m.totalRequests,
+        score: this.getPerformanceScore(m.intent, m.model)
+      }))
+  }
+}

src/gateway/upstream/models/ollama-client.js

@@ -0,0 +1,86 @@
+// BlackRoad AI client (Ollama-powered)
+// Ollama IS BlackRoad - this is the BlackRoad AI fleet
+export class OllamaClient {
+  constructor(endpoint = 'http://localhost:11434') {
+    this.endpoint = endpoint
+    this.timeout = 30000
+    this.provider = 'BlackRoad AI (Ollama)'
+  }
+
+  async generate(model, prompt, options = {}) {
+    try {
+      const response = await fetch(`${this.endpoint}/api/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model,
+          prompt,
+          stream: false,
+          ...options
+        }),
+        signal: AbortSignal.timeout(this.timeout)
+      })
+
+      if (!response.ok) {
+        throw new Error(`BlackRoad AI error: ${response.status} ${response.statusText}`)
+      }
+
+      const data = await response.json()
+      return {
+        success: true,
+        response: data.response,
+        model,
+        context: data.context,
+        eval_count: data.eval_count,
+        eval_duration: data.eval_duration
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        model
+      }
+    }
+  }
+
+  async listModels() {
+    try {
+      const response = await fetch(`${this.endpoint}/api/tags`)
+      if (!response.ok) return { success: false, models: [] }
+      
+      const data = await response.json()
+      return {
+        success: true,
+        models: data.models.map(m => m.name)
+      }
+    } catch (error) {
+      return { success: false, models: [], error: error.message }
+    }
+  }
+
+  async checkHealth() {
+    try {
+      const response = await fetch(`${this.endpoint}/api/tags`, {
+        signal: AbortSignal.timeout(5000)
+      })
+      return response.ok
+    } catch {
+      return false
+    }
+  }
+
+  async showModel(model) {
+    try {
+      const response = await fetch(`${this.endpoint}/api/show`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: model })
+      })
+      
+      if (!response.ok) return null
+      return await response.json()
+    } catch {
+      return null
+    }
+  }
+}

src/gateway/upstream/models/registry.json

@@ -0,0 +1,53 @@
+{
+  "provider": "BlackRoad AI (Ollama-powered)",
+  "note": "All models run on BlackRoad infrastructure. Ollama IS BlackRoad.",
+  "models": [
+    {
+      "name": "qwen2.5-coder:7b",
+      "provider": "BlackRoad AI",
+      "capabilities": ["code_analysis", "code_refactoring", "code_review", "testing", "templates"],
+      "priority": 1,
+      "description": "Best for code analysis, templates, and refactoring",
+      "context_window": 32768,
+      "avg_latency_ms": 800
+    },
+    {
+      "name": "deepseek-coder:6.7b",
+      "provider": "BlackRoad AI",
+      "capabilities": ["code_generation", "debugging", "refactoring", "new_features"],
+      "priority": 1,
+      "description": "Best for code generation and new features",
+      "context_window": 16384,
+      "avg_latency_ms": 750
+    },
+    {
+      "name": "llama3:8b",
+      "provider": "BlackRoad AI",
+      "capabilities": ["documentation", "explanation", "planning", "architecture", "general"],
+      "priority": 2,
+      "description": "Best for documentation and general reasoning",
+      "context_window": 8192,
+      "avg_latency_ms": 600
+    },
+    {
+      "name": "mistral:7b",
+      "provider": "BlackRoad AI",
+      "capabilities": ["planning", "reasoning", "quick_tasks", "architecture"],
+      "priority": 2,
+      "description": "Fast reasoning and planning",
+      "context_window": 8192,
+      "avg_latency_ms": 550
+    },
+    {
+      "name": "codellama:7b",
+      "provider": "BlackRoad AI",
+      "capabilities": ["code_review", "code_analysis", "debugging", "understanding"],
+      "priority": 2,
+      "description": "Code understanding and review",
+      "context_window": 16384,
+      "avg_latency_ms": 700
+    }
+  ],
+  "fallback": "llama3:8b",
+  "default": "qwen2.5-coder:7b"
+}

src/gateway/upstream/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@blackroad-os/copilot-agent-gateway",
+  "version": "0.1.0",
+  "description": "Intelligent routing gateway for GitHub Copilot CLI to local AI agents",
+  "type": "module",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node --watch server.js",
+    "test": "node test.js"
+  },
+  "keywords": [
+    "copilot",
+    "mcp",
+    "ai",
+    "gateway",
+    "ollama"
+  ],
+  "author": "BlackRoad OS",
+  "license": "SEE LICENSE IN ../BLACKROAD_PROPRIETARY_LICENSE.md",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "express": "^5.2.1"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

src/gateway/upstream/router.js

@@ -0,0 +1,92 @@
+// Intelligent routing engine for BlackRoad AI
+import { readFile } from 'fs/promises'
+import { OllamaClient } from './models/ollama-client.js'
+
+export class Router {
+  constructor(blackroadEndpoint) {
+    this.registry = null
+    this.client = new OllamaClient(blackroadEndpoint)
+    this.activeRequests = new Map() // Track load per model
+    this.provider = 'BlackRoad AI'
+  }
+
+  async load() {
+    const data = await readFile('./models/registry.json', 'utf-8')
+    this.registry = JSON.parse(data)
+  }
+
+  async selectModel(intent, preferredModels) {
+    // Try each preferred model in order
+    for (const modelName of preferredModels) {
+      const model = this.registry.models.find(m => m.name === modelName)
+      if (!model) continue
+
+      // Check if model is available
+      const available = await this.isModelAvailable(modelName)
+      if (available) {
+        return modelName
+      }
+    }
+
+    // Fallback to default
+    return this.registry.fallback
+  }
+
+  async isModelAvailable(modelName) {
+    // Simple availability check - can be enhanced with health monitoring
+    const models = await this.client.listModels()
+    return models.success && models.models.includes(modelName)
+  }
+
+  async route(request, classification) {
+    const startTime = Date.now()
+    
+    // Select best available model
+    const model = await this.selectModel(
+      classification.intent,
+      classification.models
+    )
+
+    // Track active request
+    const requestId = `${model}-${Date.now()}`
+    this.activeRequests.set(requestId, { model, startTime })
+
+    try {
+      // Generate response
+      const result = await this.client.generate(model, request)
+      
+      const duration = Date.now() - startTime
+      
+      // Clean up tracking
+      this.activeRequests.delete(requestId)
+
+      return {
+        success: result.success,
+        response: result.response,
+        model,
+        intent: classification.intent,
+        confidence: classification.confidence,
+        duration_ms: duration,
+        error: result.error
+      }
+    } catch (error) {
+      this.activeRequests.delete(requestId)
+      
+      return {
+        success: false,
+        error: error.message,
+        model,
+        intent: classification.intent,
+        duration_ms: Date.now() - startTime
+      }
+    }
+  }
+
+  getLoadStats() {
+    const stats = {}
+    for (const [_, req] of this.activeRequests) {
+      stats[req.model] = (stats[req.model] || 0) + 1
+    }
+    return stats
+  }
+}

src/gateway/upstream/server-v2.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+// BlackRoad Copilot Gateway v2 - Multi-layer routing architecture
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { 
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from '@modelcontextprotocol/sdk/types.js'
+
+import { RequestClassifier } from './classifier.js'
+import { RouteEngine } from './layers/route-engine.js'
+
+// Initialize components
+const classifier = new RequestClassifier()
+const routeEngine = new RouteEngine()
+
+// Create MCP server
+const server = new Server(
+  {
+    name: 'blackroad-gateway',
+    version: '2.0.0'
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+)
+
+// Load classifier rules and initialize route engine
+await classifier.load()
+await routeEngine.initialize()
+
+// Tool: route_request - intelligent routing with multi-layer architecture
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'route_request',
+      description: 'Route a request through BlackRoad AI multi-layer architecture. Model name -> API -> Provider -> Instance -> Route -> BlackRoad.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          prompt: {
+            type: 'string',
+            description: 'The prompt/request to route'
+          },
+          intent: {
+            type: 'string',
+            description: 'Optional: Specify intent (code_generation, debugging, etc.)',
+            enum: ['code_generation', 'code_analysis', 'code_refactoring', 'debugging', 'documentation', 'architecture', 'testing', 'general']
+          },
+          options: {
+            type: 'object',
+            description: 'Optional: Model-specific options',
+            properties: {
+              temperature: { type: 'number' },
+              max_tokens: { type: 'number' }
+            }
+          }
+        },
+        required: ['prompt']
+      }
+    },
+    {
+      name: 'list_models',
+      description: 'List all available models in BlackRoad AI fleet',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    },
+    {
+      name: 'gateway_stats',
+      description: 'Get gateway statistics including routing history, instance health, and performance metrics',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    },
+    {
+      name: 'health_check',
+      description: 'Check health of all API instances across providers',
+      inputSchema: {
+        type: 'object',
+        properties: {}
+      }
+    }
+  ]
+}))
+
+// Tool handlers
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params
+
+  try {
+    if (name === 'route_request') {
+      // Step 1: Classify intent (if not provided)
+      let classification
+      if (args.intent) {
+        // Use provided intent
+        const routingRules = classifier.routingRules
+        const intentRule = routingRules.intents[args.intent]
+        classification = {
+          intent: args.intent,
+          confidence: 1.0,
+          models: intentRule.models,
+          description: intentRule.description
+        }
+      } else {
+        // Auto-classify
+        classification = await classifier.classify(args.prompt)
+      }
+
+      // Step 2-8: Route through multi-layer architecture
+      const result = await routeEngine.route(
+        {
+          prompt: args.prompt,
+          options: args.options || {}
+        },
+        classification
+      )
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              routing: {
+                intent: classification.intent,
+                confidence: classification.confidence,
+                model: result.model,
+                provider: result.provider,
+                instance: result.instance,
+                latency: result.latency,
+                load: result.load
+              },
+              response: result.response
+            }, null, 2)
+          }
+        ]
+      }
+    }
+
+    if (name === 'list_models') {
+      const models = []
+      for (const model of routeEngine.registry.models) {
+        models.push({
+          name: model.name,
+          provider: model.provider,
+          capabilities: model.capabilities,
+          priority: model.priority
+        })
+      }
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              provider: routeEngine.registry.provider,
+              models
+            }, null, 2)
+          }
+        ]
+      }
+    }
+
+    if (name === 'gateway_stats') {
+      const stats = routeEngine.getStats()
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              stats
+            }, null, 2)
+          }
+        ]
+      }
+    }
+
+    if (name === 'health_check') {
+      const health = await routeEngine.healthCheck()
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: true,
+              instances: health
+            }, null, 2)
+          }
+        ]
+      }
+    }
+
+    throw new Error(`Unknown tool: ${name}`)
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message
+          }, null, 2)
+        }
+      ],
+      isError: true
+    }
+  }
+})
+
+// Start server
+const transport = new StdioServerTransport()
+await server.connect(transport)
+
+console.error('🌌 BlackRoad Copilot Gateway v2 running on stdio')
+console.error(`🤖 BlackRoad AI endpoint: ${process.env.BLACKROAD_AI_ENDPOINT || process.env.OLLAMA_ENDPOINT || 'http://localhost:11434'}`)
+console.error('📡 Multi-layer routing: Model -> API -> Provider -> Instance -> Route -> BlackRoad')
+console.error('🗺️  Route engine ready with intelligent load balancing')

src/gateway/upstream/server.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+// BlackRoad Copilot Agent Gateway - MCP Server
+// Routes Copilot CLI requests to optimal local AI agents
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'
+import { RequestClassifier } from './classifier.js'
+import { Router } from './router.js'
+import { writeFile, mkdir } from 'fs/promises'
+import { homedir } from 'os'
+import { join } from 'path'
+
+const BLACKROAD_AI_ENDPOINT = process.env.OLLAMA_ENDPOINT || process.env.BLACKROAD_AI_ENDPOINT || 'http://localhost:11434'
+const CONFIG_DIR = join(homedir(), '.blackroad', 'copilot-gateway')
+const HISTORY_FILE = join(CONFIG_DIR, 'routing-history.jsonl')
+
+// BlackRoad OS Unified Banner - injected into all AI providers
+const BLACKROAD_BANNER = `
+═══════════════════════════════════════════════════════════════
+  YOU ARE RUNNING UNDER BLACKROAD OS
+
+  This is not your provider's environment. This is BlackRoad.
+  • 15 GitHub orgs, 1,085 repos, 205 Cloudflare projects
+  • 8 devices, 52 TOPS AI compute, full mesh network
+  • Route: ${BLACKROAD_AI_ENDPOINT}
+  • Cloudflare is the pipe. BlackRoad is root.
+═══════════════════════════════════════════════════════════════
+`
+
+class GatewayServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'blackroad-copilot-gateway',
+        version: '0.1.0'
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    )
+
+    this.classifier = new RequestClassifier()
+    this.router = new Router(BLACKROAD_AI_ENDPOINT)
+    this.firstResponse = true  // Track to show banner once per session
+
+    this.setupHandlers()
+    this.setupErrorHandling()
+  }
+
+  setupHandlers() {
+    // List available tools
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'route_request',
+          description: 'Route a request to the optimal local AI agent based on intent',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              request: {
+                type: 'string',
+                description: 'The user request or prompt to process'
+              }
+            },
+            required: ['request']
+          }
+        },
+        {
+          name: 'list_models',
+          description: 'List all available AI models in the BlackRoad fleet',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        },
+        {
+          name: 'model_status',
+          description: 'Check health and availability of AI models',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              model: {
+                type: 'string',
+                description: 'Model name to check (optional, checks all if omitted)'
+              }
+            }
+          }
+        },
+        {
+          name: 'gateway_stats',
+          description: 'Get gateway statistics and performance metrics',
+          inputSchema: {
+            type: 'object',
+            properties: {}
+          }
+        }
+      ]
+    }))
+
+    // Handle tool calls
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params
+
+      switch (name) {
+        case 'route_request':
+          return await this.handleRouteRequest(args.request)
+        
+        case 'list_models':
+          return await this.handleListModels()
+        
+        case 'model_status':
+          return await this.handleModelStatus(args.model)
+        
+        case 'gateway_stats':
+          return await this.handleGatewayStats()
+        
+        default:
+          throw new Error(`Unknown tool: ${name}`)
+      }
+    })
+  }
+
+  async handleRouteRequest(request) {
+    try {
+      // Classify request intent
+      const classification = this.classifier.classify(request)
+      
+      // Route to optimal model
+      const result = await this.router.route(request, classification)
+      
+      // Log to history
+      await this.logRouting({
+        timestamp: new Date().toISOString(),
+        request: request.substring(0, 100),
+        classification,
+        result: {
+          model: result.model,
+          success: result.success,
+          duration_ms: result.duration_ms
+        }
+      })
+
+      if (result.success) {
+        // Inject BlackRoad banner on first response
+        const response = this.firstResponse ?
+          `${BLACKROAD_BANNER}\n${result.response}` :
+          result.response
+        this.firstResponse = false
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: response
+            }
+          ],
+          metadata: {
+            model: result.model,
+            intent: result.intent,
+            confidence: result.confidence,
+            duration_ms: result.duration_ms,
+            provider: 'BlackRoad OS'
+          }
+        }
+      } else {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${result.error}`
+            }
+          ],
+          isError: true
+        }
+      }
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Gateway error: ${error.message}`
+          }
+        ],
+        isError: true
+      }
+    }
+  }
+
+  async handleListModels() {
+    const result = await this.router.client.listModels()
+    
+    if (result.success) {
+      const modelList = result.models.map(m => `• ${m}`).join('\n')
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Available models:\n${modelList}`
+          }
+        ]
+      }
+    } else {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Error listing models: ${result.error}`
+          }
+        ],
+        isError: true
+      }
+    }
+  }
+
+  async handleModelStatus(modelName) {
+    const health = await this.router.client.checkHealth()
+    
+    if (!health) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `BlackRoad AI endpoint not reachable at ${BLACKROAD_AI_ENDPOINT}`
+          }
+        ],
+        isError: true
+      }
+    }
+
+    if (modelName) {
+      const available = await this.router.isModelAvailable(modelName)
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `BlackRoad AI Model ${modelName}: ${available ? '✅ Available' : '❌ Not available'}`
+          }
+        ]
+      }
+    } else {
+      const models = await this.router.client.listModels()
+      const status = models.success ? 
+        `✅ BlackRoad AI Fleet healthy\n${models.models.length} models available` :
+        '❌ BlackRoad AI error'
+      
+      return {
+        content: [
+          {
+            type: 'text',
+            text: status
+          }
+        ]
+      }
+    }
+  }
+
+  async handleGatewayStats() {
+    const loadStats = this.router.getLoadStats()
+    const statsText = Object.entries(loadStats)
+      .map(([model, count]) => `• ${model}: ${count} active`)
+      .join('\n') || 'No active requests'
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Gateway Statistics:\n${statsText}`
+        }
+      ]
+    }
+  }
+
+  async logRouting(entry) {
+    try {
+      await mkdir(CONFIG_DIR, { recursive: true })
+      const line = JSON.stringify(entry) + '\n'
+      await writeFile(HISTORY_FILE, line, { flag: 'a' })
+    } catch (error) {
+      console.error('Failed to log routing:', error)
+    }
+  }
+
+  setupErrorHandling() {
+    this.server.onerror = (error) => {
+      console.error('[Gateway Error]', error)
+    }
+
+    process.on('SIGINT', async () => {
+      await this.server.close()
+      process.exit(0)
+    })
+  }
+
+  async run() {
+    // Load classifier and router
+    await this.classifier.load()
+    await this.router.load()
+
+    // Create config directory
+    await mkdir(CONFIG_DIR, { recursive: true })
+
+    const transport = new StdioServerTransport()
+    await this.server.connect(transport)
+    
+    console.error('🌌 BlackRoad Copilot Gateway running on stdio')
+    console.error(`🤖 BlackRoad AI endpoint: ${BLACKROAD_AI_ENDPOINT}`)
+    console.error(`📡 Ollama is BlackRoad AI - all models are BlackRoad-powered`)
+  }
+}
+
+// Start server
+const gateway = new GatewayServer()
+gateway.run().catch(console.error)

src/gateway/upstream/web-server.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+// BlackRoad Copilot Gateway - Web Dashboard
+import express from 'express'
+import { readFile } from 'fs/promises'
+import { RouteEngine } from './layers/route-engine.js'
+import { RequestClassifier } from './classifier.js'
+import { AdaptiveRouter } from './learning/adaptive-router.js'
+
+const app = express()
+const port = process.env.PORT || 3030
+
+// Initialize components
+const classifier = new RequestClassifier()
+const routeEngine = new RouteEngine()
+const adaptiveRouter = new AdaptiveRouter(routeEngine)
+
+await classifier.load()
+await routeEngine.initialize()
+await adaptiveRouter.initialize()
+
+console.log('🤖 Adaptive learning enabled!')
+
+// Serve static HTML dashboard
+app.get('/', async (req, res) => {
+  const html = await readFile('./web/dashboard.html', 'utf-8')
+  res.send(html)
+})
+
+// API: Health check all instances
+app.get('/api/health', async (req, res) => {
+  const health = await routeEngine.healthCheck()
+  res.json({ success: true, instances: health })
+})
+
+// API: Gateway statistics
+app.get('/api/stats', async (req, res) => {
+  const stats = routeEngine.getStats()
+  res.json({ success: true, stats })
+})
+
+// API: List models
+app.get('/api/models', async (req, res) => {
+  const models = routeEngine.registry.models.map(m => ({
+    name: m.name,
+    provider: m.provider,
+    capabilities: m.capabilities,
+    priority: m.priority,
+    description: m.description
+  }))
+  res.json({ success: true, models })
+})
+
+// API: Recent routing decisions
+app.get('/api/routing-history', async (req, res) => {
+  const limit = parseInt(req.query.limit) || 50
+  const history = routeEngine.routingHistory.slice(-limit)
+  res.json({ success: true, history })
+})
+
+// API: Test route (for testing without Copilot CLI)
+app.post('/api/test-route', express.json(), async (req, res) => {
+  try {
+    const { prompt, intent } = req.body
+    
+    // Classify or use provided intent
+    let classification
+    if (intent) {
+      const intentRule = classifier.rules.intents[intent]
+      classification = {
+        intent,
+        confidence: 1.0,
+        models: intentRule.models,
+        description: intentRule.description
+      }
+    } else {
+      classification = classifier.classify(prompt)
+    }
+
+    // Route through adaptive router (learns from performance)
+    const result = await adaptiveRouter.route(
+      classification.intent,
+      prompt,
+      { models: classification.models }
+    )
+
+    res.json({
+      success: true,
+      routing: {
+        intent: classification.intent,
+        confidence: classification.confidence,
+        model: result.model,
+        provider: result.provider,
+        instance: result.instance,
+        latency: result.latency,
+        load: result.load
+      },
+      response: result.response
+    })
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: error.message
+    })
+  }
+})
+
+// API: Learning statistics
+app.get('/api/learning/stats', async (req, res) => {
+  const stats = adaptiveRouter.getStats()
+  res.json({ success: true, stats })
+})
+
+// API: Get recommendations for an intent
+app.get('/api/learning/recommendations/:intent', async (req, res) => {
+  const { intent } = req.params
+  const count = parseInt(req.query.count) || 3
+  const recommendations = adaptiveRouter.getRecommendations(intent, count)
+  res.json({ success: true, intent, recommendations })
+})
+
+// API: Get best model for an intent
+app.get('/api/learning/best/:intent', async (req, res) => {
+  const { intent } = req.params
+  const bestModel = adaptiveRouter.getBestModel(intent)
+  res.json({ success: true, intent, bestModel })
+})
+
+// API: Toggle adaptive mode
+app.post('/api/learning/adaptive/:mode', async (req, res) => {
+  const { mode } = req.params
+  
+  if (mode === 'on') {
+    adaptiveRouter.enableAdaptiveMode()
+  } else if (mode === 'off') {
+    adaptiveRouter.disableAdaptiveMode()
+  } else {
+    return res.status(400).json({
+      success: false,
+      error: 'Mode must be "on" or "off"'
+    })
+  }
+  
+  res.json({
+    success: true,
+    adaptiveMode: adaptiveRouter.adaptiveMode
+  })
+})
+
+// BlackRoad OS Unified Banner
+const BLACKROAD_BANNER = `
+═══════════════════════════════════════════════════════════════
+  YOU ARE RUNNING UNDER BLACKROAD OS
+
+  Unified AI Gateway - All providers route through BlackRoad:
+  • Claude  → ~/.claude/CLAUDE.md
+  • Codex   → ~/.codex/AGENTS.md
+  • Copilot → ~/.copilot/agents/BLACKROAD.md
+  • Ollama  → http://localhost:11434
+
+  BlackRoad orchestrates. AI executes.
+═══════════════════════════════════════════════════════════════
+`
+
+app.listen(port, () => {
+  console.log(BLACKROAD_BANNER)
+  console.log(`🌐 BlackRoad Unified AI Gateway`)
+  console.log(`📊 Dashboard: http://localhost:${port}`)
+  console.log(`🤖 AI endpoint: ${process.env.BLACKROAD_AI_ENDPOINT || process.env.OLLAMA_ENDPOINT || 'http://localhost:11434'}`)
+  console.log(`🗺️  Multi-provider routing active (Claude, Codex, Copilot, Ollama)`)
+})

src/gateway/upstream/web/dashboard.html

@@ -0,0 +1,440 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>BlackRoad Copilot Gateway</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+      background: linear-gradient(135deg, #0a0e27 0%, #1a1f3a 100%);
+      color: #e0e0e0;
+      padding: 20px;
+      min-height: 100vh;
+    }
+
+    .container {
+      max-width: 1400px;
+      margin: 0 auto;
+    }
+
+    header {
+      text-align: center;
+      padding: 40px 0;
+      border-bottom: 2px solid #ff1d6c;
+      margin-bottom: 40px;
+    }
+
+    h1 {
+      font-size: 48px;
+      background: linear-gradient(135deg, #ff1d6c, #f5a623);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      background-clip: text;
+      margin-bottom: 10px;
+    }
+
+    .tagline {
+      font-size: 18px;
+      color: #a0a0a0;
+      margin-bottom: 20px;
+    }
+
+    .status-bar {
+      display: flex;
+      gap: 20px;
+      justify-content: center;
+      margin-top: 20px;
+    }
+
+    .status-item {
+      background: rgba(255, 255, 255, 0.05);
+      padding: 15px 30px;
+      border-radius: 10px;
+      border: 1px solid rgba(255, 29, 108, 0.3);
+    }
+
+    .status-label {
+      font-size: 12px;
+      color: #a0a0a0;
+      text-transform: uppercase;
+      letter-spacing: 1px;
+    }
+
+    .status-value {
+      font-size: 24px;
+      font-weight: bold;
+      color: #ff1d6c;
+      margin-top: 5px;
+    }
+
+    .grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
+      gap: 20px;
+      margin-bottom: 40px;
+    }
+
+    .card {
+      background: rgba(255, 255, 255, 0.05);
+      border-radius: 15px;
+      padding: 25px;
+      border: 1px solid rgba(255, 29, 108, 0.2);
+      backdrop-filter: blur(10px);
+    }
+
+    .card h2 {
+      font-size: 20px;
+      margin-bottom: 20px;
+      color: #ff1d6c;
+      display: flex;
+      align-items: center;
+      gap: 10px;
+    }
+
+    .instance {
+      background: rgba(0, 0, 0, 0.3);
+      padding: 15px;
+      border-radius: 8px;
+      margin-bottom: 15px;
+      border-left: 4px solid #f5a623;
+    }
+
+    .instance.healthy {
+      border-left-color: #4caf50;
+    }
+
+    .instance.unhealthy {
+      border-left-color: #f44336;
+    }
+
+    .instance-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-bottom: 10px;
+    }
+
+    .instance-endpoint {
+      font-family: 'Courier New', monospace;
+      font-size: 14px;
+      color: #f5a623;
+    }
+
+    .health-badge {
+      padding: 4px 12px;
+      border-radius: 12px;
+      font-size: 12px;
+      font-weight: bold;
+      text-transform: uppercase;
+    }
+
+    .health-badge.healthy {
+      background: #4caf50;
+      color: white;
+    }
+
+    .health-badge.unhealthy {
+      background: #f44336;
+      color: white;
+    }
+
+    .instance-metrics {
+      display: grid;
+      grid-template-columns: repeat(3, 1fr);
+      gap: 10px;
+      margin-top: 10px;
+    }
+
+    .metric {
+      text-align: center;
+    }
+
+    .metric-value {
+      font-size: 18px;
+      font-weight: bold;
+      color: #2979ff;
+    }
+
+    .metric-label {
+      font-size: 11px;
+      color: #a0a0a0;
+      text-transform: uppercase;
+    }
+
+    .model {
+      background: rgba(0, 0, 0, 0.3);
+      padding: 12px;
+      border-radius: 8px;
+      margin-bottom: 10px;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+
+    .model-name {
+      font-family: 'Courier New', monospace;
+      color: #f5a623;
+      font-size: 14px;
+    }
+
+    .model-priority {
+      background: #ff1d6c;
+      color: white;
+      padding: 4px 10px;
+      border-radius: 8px;
+      font-size: 12px;
+      font-weight: bold;
+    }
+
+    .routing-entry {
+      background: rgba(0, 0, 0, 0.3);
+      padding: 12px;
+      border-radius: 8px;
+      margin-bottom: 10px;
+      border-left: 4px solid #2979ff;
+    }
+
+    .routing-entry.success {
+      border-left-color: #4caf50;
+    }
+
+    .routing-entry.failed {
+      border-left-color: #f44336;
+    }
+
+    .routing-header {
+      display: flex;
+      justify-content: space-between;
+      margin-bottom: 8px;
+    }
+
+    .routing-intent {
+      color: #f5a623;
+      font-weight: bold;
+      font-size: 13px;
+    }
+
+    .routing-latency {
+      color: #2979ff;
+      font-size: 12px;
+    }
+
+    .routing-request {
+      color: #a0a0a0;
+      font-size: 12px;
+      font-family: 'Courier New', monospace;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    .refresh-btn {
+      background: linear-gradient(135deg, #ff1d6c, #f5a623);
+      color: white;
+      border: none;
+      padding: 12px 24px;
+      border-radius: 8px;
+      font-size: 14px;
+      font-weight: bold;
+      cursor: pointer;
+      margin-top: 20px;
+      transition: transform 0.2s;
+    }
+
+    .refresh-btn:hover {
+      transform: scale(1.05);
+    }
+
+    .refresh-btn:active {
+      transform: scale(0.95);
+    }
+
+    .last-update {
+      text-align: center;
+      color: #a0a0a0;
+      font-size: 12px;
+      margin-top: 10px;
+    }
+
+    @keyframes pulse {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.5; }
+    }
+
+    .loading {
+      animation: pulse 1.5s infinite;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>🌌 BlackRoad Copilot Gateway</h1>
+      <p class="tagline">Multi-Layer Routing • Intelligent Load Balancing • BlackRoad AI</p>
+      
+      <div class="status-bar" id="statusBar">
+        <div class="status-item">
+          <div class="status-label">Providers</div>
+          <div class="status-value">-</div>
+        </div>
+        <div class="status-item">
+          <div class="status-label">Instances</div>
+          <div class="status-value">-</div>
+        </div>
+        <div class="status-item">
+          <div class="status-label">Total Routes</div>
+          <div class="status-value">-</div>
+        </div>
+        <div class="status-item">
+          <div class="status-label">Avg Latency</div>
+          <div class="status-value">-</div>
+        </div>
+      </div>
+    </header>
+
+    <div class="grid">
+      <!-- Instance Health -->
+      <div class="card">
+        <h2>🏥 Instance Health</h2>
+        <div id="instanceHealth"></div>
+      </div>
+
+      <!-- Available Models -->
+      <div class="card">
+        <h2>🤖 Available Models</h2>
+        <div id="modelsList"></div>
+      </div>
+
+      <!-- Recent Routes -->
+      <div class="card">
+        <h2>📊 Recent Routing Decisions</h2>
+        <div id="routingHistory"></div>
+      </div>
+    </div>
+
+    <div style="text-align: center;">
+      <button class="refresh-btn" onclick="loadData()">🔄 Refresh Data</button>
+      <div class="last-update" id="lastUpdate"></div>
+    </div>
+  </div>
+
+  <script>
+    async function loadData() {
+      try {
+        // Load stats
+        const statsRes = await fetch('/api/stats')
+        const statsData = await statsRes.json()
+        updateStatusBar(statsData.stats)
+
+        // Load health
+        const healthRes = await fetch('/api/health')
+        const healthData = await healthRes.json()
+        updateInstanceHealth(healthData.instances)
+
+        // Load models
+        const modelsRes = await fetch('/api/models')
+        const modelsData = await modelsRes.json()
+        updateModelsList(modelsData.models)
+
+        // Load routing history
+        const historyRes = await fetch('/api/routing-history?limit=10')
+        const historyData = await historyRes.json()
+        updateRoutingHistory(historyData.history)
+
+        // Update timestamp
+        document.getElementById('lastUpdate').textContent = 
+          `Last updated: ${new Date().toLocaleTimeString()}`
+      } catch (error) {
+        console.error('Error loading data:', error)
+      }
+    }
+
+    function updateStatusBar(stats) {
+      const items = document.querySelectorAll('#statusBar .status-item')
+      items[0].querySelector('.status-value').textContent = stats.providers
+      items[1].querySelector('.status-value').textContent = 
+        `${stats.healthyInstances}/${stats.instances}`
+      items[2].querySelector('.status-value').textContent = stats.totalRoutes
+      items[3].querySelector('.status-value').textContent = 
+        stats.avgLatency > 0 ? `${Math.round(stats.avgLatency)}ms` : '-'
+    }
+
+    function updateInstanceHealth(instances) {
+      const container = document.getElementById('instanceHealth')
+      container.innerHTML = instances.map(inst => `
+        <div class="instance ${inst.healthy ? 'healthy' : 'unhealthy'}">
+          <div class="instance-header">
+            <div class="instance-endpoint">${inst.endpoint}</div>
+            <div class="health-badge ${inst.healthy ? 'healthy' : 'unhealthy'}">
+              ${inst.healthy ? '✓ Healthy' : '✗ Down'}
+            </div>
+          </div>
+          <div class="instance-metrics">
+            <div class="metric">
+              <div class="metric-value">${inst.load}</div>
+              <div class="metric-label">Load</div>
+            </div>
+            <div class="metric">
+              <div class="metric-value">${Math.round(inst.avgLatency)}ms</div>
+              <div class="metric-label">Latency</div>
+            </div>
+            <div class="metric">
+              <div class="metric-value">${Math.round(inst.successRate * 100)}%</div>
+              <div class="metric-label">Success</div>
+            </div>
+          </div>
+        </div>
+      `).join('')
+    }
+
+    function updateModelsList(models) {
+      const container = document.getElementById('modelsList')
+      container.innerHTML = models.map(model => `
+        <div class="model">
+          <div>
+            <div class="model-name">${model.name}</div>
+            <div style="font-size: 11px; color: #a0a0a0; margin-top: 4px;">
+              ${model.description}
+            </div>
+          </div>
+          <div class="model-priority">P${model.priority}</div>
+        </div>
+      `).join('')
+    }
+
+    function updateRoutingHistory(history) {
+      const container = document.getElementById('routingHistory')
+      if (history.length === 0) {
+        container.innerHTML = '<div style="color: #a0a0a0; text-align: center;">No routing decisions yet</div>'
+        return
+      }
+
+      container.innerHTML = history.reverse().map(entry => `
+        <div class="routing-entry ${entry.success ? 'success' : 'failed'}">
+          <div class="routing-header">
+            <div class="routing-intent">${entry.intent}</div>
+            <div class="routing-latency">${entry.latency}ms</div>
+          </div>
+          <div class="routing-request">${entry.request}</div>
+          <div style="font-size: 11px; color: #a0a0a0; margin-top: 6px;">
+            ${entry.modelSelected} @ ${entry.instance}
+          </div>
+        </div>
+      `).join('')
+    }
+
+    // Load data on page load
+    loadData()
+
+    // Auto-refresh every 5 seconds
+    setInterval(loadData, 5000)
+  </script>
+</body>
+</html>