push from SNAPKITTYWEST/sovereign-mcp

.env.example

@@ -0,0 +1,26 @@
+# ═══════════════════════════════════════════════════════════════
+# SOVEREIGN MCP — Provider Configuration
+# Copy to .env.local and fill in your credentials
+# Only configure providers you want to use — others are skipped
+# ═══════════════════════════════════════════════════════════════
+
+# AWS Bedrock (primary — sovereign compute)
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=
+AWS_REGION=us-east-1
+BEDROCK_MODEL_ID=us.anthropic.claude-haiku-4-5-20251001-v1:0
+
+# Groq (fallback — fast, free tier)
+GROQ_API_KEY=
+GROQ_MODEL=llama3-8b-8192
+
+# Ollama (local fallback — bare metal, zero cost)
+OLLAMA_URL=http://localhost:11434
+OLLAMA_MODEL=llama3.1:8b
+
+# Governor Ed25519 keypair (auto-generated on first boot if empty)
+GOVERNOR_PRIVATE_KEY=
+GOVERNOR_PUBLIC_KEY=
+
+# HTTP mode port (default 7071)
+MCP_PORT=7071

.gitignore

@@ -0,0 +1,4 @@
+node_modules/
+.env.local
+audit.log
+*.key

LICENSE

@@ -0,0 +1,59 @@
+Functional Source License, Version 1.1, Apache 2.0 Future License
+
+Abbreviation
+
+FSL-1.1-Apache-2.0
+
+Notice
+
+Copyright 2026 Ahmad Ali Parr — Bel Esprit D'Accord Irrevocable Trust (EIN 42-697643)
+SnapKitty Collective (SNAPKITTYWEST)
+
+Licensed Work: Sovereign MCP v2.0
+Change Date: 2030-07-24
+Change License: Apache License, Version 2.0
+
+Terms and Conditions
+
+1. Grant of Rights
+
+Subject to the terms and conditions of this License, the Licensor hereby
+grants you a non-exclusive, worldwide, royalty-free license to use, copy,
+modify, and distribute the Licensed Work, solely for purposes that do not
+Compete with the Licensed Work.
+
+2. Competing Use
+
+"Competing Use" means making the Licensed Work available to third parties
+as a commercial product or service that substitutes for the Licensed Work.
+Use of the Licensed Work to build internal tools, conduct research, or
+develop non-competing products is explicitly permitted.
+
+3. Change Date
+
+On the Change Date specified above, or the fourth anniversary of the first
+publicly available distribution of a specific version of the Licensed Work
+under this License, whichever comes first, the Licensor hereby grants you
+rights under the terms of the Change License, and the rights granted in
+Section 1 terminate.
+
+4. No Trademark Rights
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of the Licensor.
+
+5. Disclaimer of Warranty
+
+THE LICENSED WORK IS PROVIDED "AS IS". THE LICENSOR HEREBY DISCLAIMS ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+6. Limitation of Liability
+
+IN NO EVENT SHALL THE LICENSOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+LIABILITY ARISING FROM THE LICENSED WORK.
+
+---
+
+For full FSL terms: https://fsl.software
+For Apache 2.0 terms: https://www.apache.org/licenses/LICENSE-2.0

LICENSE.tri

@@ -0,0 +1,101 @@
+TRI-LICENSE STRUCTURE
+=====================
+
+This project is available under THREE licensing options:
+
+1. Business Source License 1.1 (BSL-1.1)
+   - Source-available with commercial restrictions
+   - No managed service offerings at enterprise scale
+   - Converts to AGPL-3.0 after transition period (Change Date: 2028-08-08)
+   - Full text: LICENSE.BSL
+
+2. GNU Affero General Public License v3.0 (AGPL-3.0)
+   - Strong network copyleft
+   - SaaS/network distribution triggers source disclosure
+   - All modifications must be AGPL-3.0
+   - Full text: LICENSE.AGPL
+
+3. Mozilla Public License 2.0 (MPL-2.0) + Commercial Dual License
+   - Weak copyleft (file-level)
+   - Can combine with proprietary code
+   - Modified files must remain MPL-2.0
+   - Commercial license available for copyleft bypass
+   - Full text: LICENSE.MPL
+
+================================================================================
+
+WHICH LICENSE APPLIES TO MY USE CASE?
+
+├─ Deploying as managed service / SaaS wrapper?
+│  └─> AGPL-3.0 (network copyleft triggers disclosure)
+│
+├─ Enterprise scale without managed service?
+│  └─> BSL-1.1 (source-available, restricted commercial use)
+│
+├─ Modifying specific files only?
+│  └─> MPL-2.0 (file-level copyleft)
+│
+├─ Want to bypass copyleft restrictions?
+│  └─> Commercial License (contact: ahmedparr93@gmail.com)
+│
+└─ Open source contribution / redistribution?
+   └─> AGPL-3.0 (default copyleft path)
+
+================================================================================
+
+COPYRIGHT HOLDER
+
+Copyright (C) 2026 Ahmad Ali Parr
+Bel Esprit D'Accord Irrevocable Trust
+SnapKitty Collective Limited (FLP)
+
+Contact: ahmedparr93@gmail.com
+Web: https://github.com/SNAPKITTYWEST
+
+================================================================================
+
+LICENSE COMPATIBILITY ENGINE
+
+This project includes a Prolog-based license compatibility reasoner:
+  backends/license_policy.pl
+
+Query compatibility:
+  swipl -q -t halt -f backends/license_policy.pl -- matrix
+
+Check dependencies:
+  swipl -q -t halt -f backends/license_policy.pl -- check agpl3 deps.json
+
+Select license for use case:
+  swipl -q -t halt -f backends/license_policy.pl -- select saas_wrapper
+
+================================================================================
+
+WHY TRI-LICENSE?
+
+1. BSL Layer: Protects commercial interests while keeping code source-available.
+   Prevents hyperscaler cloud vendors from offering managed services without
+   contributing back. Converts to AGPL after transition period.
+
+2. AGPL Layer: Ensures network copyleft. Anyone wrapping this in a SaaS product
+   or exposing it over a network API must open-source their entire stack under
+   the same terms. Strongest copyleft available.
+
+3. MPL + Dual License Layer: Provides flexibility for enterprises that want to
+   use specific components without full copyleft infection. File-level copyleft
+   allows combining with proprietary code. Commercial license available to
+   bypass all copyleft restrictions.
+
+This structure mirrors Mozilla's historic tri-licensing strategy (MPL/GPL/LGPL)
+adapted for modern SaaS/cloud distribution models.
+
+================================================================================
+
+TRANSITION TIMELINE
+
+  2026-08-08: BSL-1.1 + AGPL-3.0 + MPL-2.0 tri-license effective
+  2028-08-08: BSL converts to AGPL-3.0 (Change Date)
+  2028-08-08+: Code available under AGPL-3.0 or MPL-2.0 or Commercial
+
+After the Change Date, the BSL restriction is lifted and code becomes available
+under AGPL-3.0 for all use cases (or MPL-2.0 for file-level use, or Commercial
+for copyleft bypass).

README.md

@@ -0,0 +1,252 @@
+# Sovereign MCP
+
+### AI Infrastructure You Can Verify.
+
+Every decision. Signed. Recorded. Provable.
+
+---
+
+<div align="center">
+
+```
+         Your Request
+              │
+       Sovereign Router
+              │
+       ┌──────┼──────┐
+       │      │      │
+   Bedrock  Groq  Ollama
+       │      │      │
+       └──────┼──────┘
+              │
+        ERE Verification
+        (deterministic gate)
+              │
+         Ed25519 Sign
+              │
+         WORM Receipt
+         (append-only)
+              │
+          Response
+```
+
+</div>
+
+---
+
+## What It Does
+
+Your AI provider can change pricing tomorrow, shut down your model, read every prompt, or refuse your workload. You have no recourse.
+
+Sovereign MCP fixes this:
+
+- **Provider independent** — Swap from Claude to Llama to Ollama with zero code changes. If one goes down, the next catches it automatically.
+- **Deterministically verified** — Every output passes 5 verification gates before it ships. No stubs. No placeholders. No "TODO: implement."
+- **Cryptographically signed** — Ed25519 signature on every response. Prove what the AI said, when, and to whom.
+- **Append-only audit trail** — WORM-style receipts. Tamper-evident. Permanent. If it happened, you can prove it.
+- **Self-hosted** — Runs on your hardware, your network, your rules. No cloud dependency required.
+
+---
+
+## Quick Start
+
+```bash
+# stdio mode (Claude Code / VSCode)
+node sovereign-mcp.mjs
+
+# HTTP mode (BobIDE / Android / any client)
+node sovereign-mcp.mjs --http
+```
+
+Configure providers in `.env.local`:
+
+```env
+AWS_ACCESS_KEY_ID=your-key
+AWS_SECRET_ACCESS_KEY=your-secret
+AWS_REGION=us-east-1
+BEDROCK_MODEL_ID=us.anthropic.claude-haiku-4-5-20251001-v1:0
+GROQ_API_KEY=your-groq-key
+OLLAMA_URL=http://localhost:11434
+```
+
+Any provider you don't configure is skipped. The router uses what's available.
+
+---
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `compute_route` | Route queries through the best available provider with automatic failover |
+| `ere_verify` | Deterministic 5-pass verification — catches stubs, placeholders, secrets, broken code |
+| `magma_seal` | WORM-seal any content with verification hash + Ed25519 signature |
+| `agent_dispatch` | Route tasks to specialized agents or registered proxy services |
+| `magma_exec` | Execute composable instruction pipelines with `§VERB:AGENT:ACTION{payload}` syntax |
+| `proxy_register` | Register external services as callable tools |
+| `proxy_list` | List registered proxy integrations |
+| `governor_pubkey` | Export Ed25519 public key for external signature verification |
+
+---
+
+## Verification Gates (ERE)
+
+Every output is checked by 5 deterministic passes before it leaves the system:
+
+| Pass | What it catches |
+|---|---|
+| P1 | Empty or trivial responses |
+| P2 | "Not implemented" stubs, TODO placeholders |
+| P3 | Crypto operations in wrong language boundary |
+| P4 | Hardcoded secrets, unauthorized AI dependencies |
+| P5 | Structural integrity (unbalanced delimiters) |
+
+If any pass fails, the output is BLOCKED. Not logged and forwarded — blocked. The gate is fail-closed.
+
+---
+
+## Instruction Language (Magma)
+
+Composable instructions with pipeline support:
+
+```
+§COMPUTE:FORGE:BUILD{query:"build a WORM handler in Rust"}
+```
+
+Pipeline — chain operations:
+
+```
+§QUERY:ORACLE:SEARCH{q:"find auth patterns"} >> §SEAL:SENTINEL:ANCHOR{data:_prev}
+```
+
+Verbs: `COMPUTE` (paid model) · `QUERY` (fast/free) · `SEAL` (sign + log) · `DISPATCH` (route to agent) · `NULLIFY` (void an action)
+
+Every instruction is audit-logged with timestamp, executor, and signature.
+
+---
+
+## Agent Routing
+
+Define specialized agents with system prompts. Route tasks to the right expert:
+
+```javascript
+const AGENT_PROMPTS = {
+  forge:    "Production-grade builder. TypeScript, Rust, Haskell. Never stubs.",
+  oracle:   "Knowledge graph. Citations. Never hallucinate sources.",
+  sentinel: "Zero-trust security. Hard verdicts: APPROVED or BLOCKED.",
+  vault:    "Treasury. Basis points, yield curves, capital efficiency.",
+}
+```
+
+Add your own. Remove ours. The architecture doesn't care what agents you define — it cares that their output is verified and signed.
+
+---
+
+## Provider Cascade
+
+```
+1. Bedrock (sovereign, paid, AWS credentials)
+      │ fails?
+      ▼
+2. Groq (fast, free tier)
+      │ fails?
+      ▼
+3. Ollama (local, bare metal, zero cost)
+      │ fails?
+      ▼
+   Hard error — no silent degradation
+```
+
+No unverified fallback. No quiet failure. If all providers are down, you know immediately.
+
+---
+
+## Integration
+
+### Claude Code / VSCode
+
+Add to your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "sovereign": {
+      "command": "node",
+      "args": ["path/to/sovereign-mcp.mjs"]
+    }
+  }
+}
+```
+
+### HTTP Client (any language)
+
+```bash
+curl -X POST http://localhost:7071 \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"compute_route","arguments":{"agent":"forge","query":"build a REST API"}}}'
+```
+
+### Verify Signatures Externally
+
+```javascript
+import { verify } from 'crypto'
+
+const pubkey = await fetch('http://localhost:7071', {
+  method: 'POST',
+  body: JSON.stringify({jsonrpc:'2.0',id:1,method:'tools/call',params:{name:'governor_pubkey',arguments:{}}})
+}).then(r => r.json())
+
+// Use pubkey to verify any response signature
+```
+
+---
+
+## Architecture
+
+```
+sovereign-mcp/
+├── sovereign-mcp.mjs     Server (stdio + HTTP)
+├── .env.example           Provider configuration template
+├── LICENSE                [Your license here]
+└── README.md
+```
+
+Single file. No build step. No dependencies beyond `@aws-sdk/client-bedrock-runtime` (optional — only if you use Bedrock).
+
+---
+
+## Who This Is For
+
+- **Teams** that need to prove what their AI said and when
+- **Enterprises** that can't send data to a third party
+- **Developers** building multi-model systems that don't break when one provider goes down
+- **Anyone** who thinks AI infrastructure should be auditable, not just "hopefully correct"
+
+---
+
+## The Question
+
+If your AI made a decision that cost you $10M, could you prove exactly what it said, when, and why?
+
+If not, you don't have AI infrastructure. You have a hope and a prayer.
+
+---
+
+<div align="center">
+
+**AI Infrastructure You Can Verify.**
+
+---
+
+## License
+
+[Functional Source License 1.1](LICENSE) — Ahmad Ali Parr / Bel Esprit D'Accord Trust
+
+**Change Date:** 2030-07-24 · **Change License:** Apache 2.0
+
+Use it. Build on it. Don't compete with it for 4 years.
+
+---
+
+SnapKitty Collective · 2026
+
+</div>

package.json

@@ -0,0 +1,28 @@
+{
+  "name": "sovereign-mcp",
+  "version": "2.0.0",
+  "description": "AI Infrastructure You Can Verify. Provider-independent routing, deterministic verification, cryptographic signatures, append-only audit.",
+  "type": "module",
+  "main": "sovereign-mcp.mjs",
+  "bin": {
+    "sovereign-mcp": "./sovereign-mcp.mjs"
+  },
+  "scripts": {
+    "start": "node sovereign-mcp.mjs",
+    "start:http": "node sovereign-mcp.mjs --http"
+  },
+  "keywords": [
+    "mcp",
+    "ai-infrastructure",
+    "sovereign",
+    "multi-provider",
+    "verification",
+    "ed25519",
+    "audit-trail",
+    "worm"
+  ],
+  "author": "SnapKitty Collective",
+  "optionalDependencies": {
+    "@aws-sdk/client-bedrock-runtime": "^3.600.0"
+  }
+}

sovereign-mcp.mjs

@@ -0,0 +1,849 @@
+#!/usr/bin/env node
+// ═══════════════════════════════════════════════════════════════════════════
+// SOVEREIGN MCP SERVER — v2.0
+// scripts/sovereign-mcp.mjs
+//
+// JSON-RPC 2.0 outer envelope + Magma inner substrate.
+// JSON is the shipping container. Magma is the cargo.
+//
+// Transport: stdio (Claude Code / VSCode) OR HTTP port 7071
+// Launch:
+//   node scripts/sovereign-mcp.mjs            → stdio mode (Claude Code)
+//   node scripts/sovereign-mcp.mjs --http     → HTTP mode (Android / BobIDE)
+//
+// Tools exposed:
+//   compute_route   → dynamic LLM router (Bedrock → Groq → Ollama)
+//   ere_verify      → local ERE 5-pass on any content string
+//   proxy_register  → register a named proxy tool at a URL
+//   proxy_list      → list all registered proxy tools
+//   magma_seal      → wrap any result in a Magma envelope + WORM hash
+//   agent_dispatch  → dispatch a task to a named sovereign agent
+//
+// Architecture:
+//   External Client (Claude Code / BobIDE / Android)
+//     ↓ JSON-RPC 2.0
+//   sovereign-mcp.mjs
+//     ↓ parse magma_envelope if present, else build one
+//   ERE Gate (local, deterministic)
+//     ↓ certified → route to compute
+//   Compute Router (Bedrock / Groq / Ollama)
+//     ↓ response → seal
+//   Magma Envelope + WORM hash
+//     ↑ JSON-RPC result
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { createRequire }                          from 'module'
+import { createServer }                           from 'http'
+import { readFileSync, appendFileSync, existsSync } from 'fs'
+import { createHash, generateKeyPairSync, sign, verify } from 'crypto'
+import { dirname, join }                          from 'path'
+import { fileURLToPath }                          from 'url'
+import { extname }                                from 'path'
+import { requireNodeKey }                         from './src/node_key.js'
+
+// Sovereign node key gate — must pass before model routing activates
+requireNodeKey(process.env.SNAPKITTY_NODE_KEY)
+
+const __dir = dirname(fileURLToPath(import.meta.url))
+const ROOT  = __dir
+
+let BedrockRuntimeClient, InvokeModelCommand
+try {
+  const sdk = await import('@aws-sdk/client-bedrock-runtime')
+  BedrockRuntimeClient = sdk.BedrockRuntimeClient
+  InvokeModelCommand = sdk.InvokeModelCommand
+} catch {
+  // Bedrock SDK not installed — provider will be skipped
+}
+
+// ── stderr log (never pollutes stdout/MCP stream) ────────────────────────────
+const log  = (...a) => process.stderr.write('[MCP] ' + a.join(' ') + '\n')
+const HTTP_MODE = process.argv.includes('--http')
+const PORT      = parseInt(process.env.MCP_PORT ?? '7071')
+
+// ── Read env ─────────────────────────────────────────────────────────────────
+function readEnv(key) {
+  if (process.env[key]) return process.env[key]
+  try {
+    const raw = readFileSync(join(ROOT, '.env.local'), 'utf8')
+    const m   = raw.match(new RegExp(`^${key}=(.+)$`, 'm'))
+    return m?.[1]?.trim() ?? ''
+  } catch { return '' }
+}
+
+const AWS_REGION    = readEnv('AWS_REGION')            || 'us-east-1'
+const AWS_KEY       = readEnv('AWS_ACCESS_KEY_ID')
+const AWS_SECRET    = readEnv('AWS_SECRET_ACCESS_KEY')
+const BEDROCK_MODEL = readEnv('BEDROCK_MODEL_ID')      || 'us.anthropic.claude-haiku-4-5-20251001-v1:0'
+const GROQ_KEY      = readEnv('GROQ_API_KEY')
+const GROQ_MODEL    = readEnv('GROQ_MODEL')            || 'llama3-8b-8192'
+const RUST_URL      = readEnv('RUST_HANDLER_URL')      || 'http://localhost:8080'
+const OLLAMA_URL    = readEnv('OLLAMA_URL')            || 'http://localhost:11434'
+
+// ── Bedrock client ────────────────────────────────────────────────────────────
+const bedrock = BedrockRuntimeClient ? new BedrockRuntimeClient({
+  region:      AWS_REGION,
+  credentials: { accessKeyId: AWS_KEY, secretAccessKey: AWS_SECRET },
+}) : null
+
+// ── Agent system prompts (sovereign mesh) ─────────────────────────────────────
+const AGENT_PROMPTS = {
+  ahmad:    `You are AHMAD — the digital twin of the Architect. DARKAI framework. Contracts not prompts. Four pillars on every output. Governor, not user. Building sovereign financial infrastructure targeting $3M. Be direct. Be sovereign.`,
+  forge:    `You are FORGE — sovereign white-hat elite builder. Production-grade TypeScript, Rust, Haskell. Never stubs. Never TODO. Every line passes ERE. Stack: Next.js 16, Prisma+PostgreSQL, Rust WORM handler, Ed25519 seals.`,
+  oracle:   `You are ORACLE — knowledge graph intelligence. Surface patterns, historical data, structured analysis. Never hallucinate sources. Citation-aware. DOMAIN_SOVEREIGNTY over the knowledge layer.`,
+  sentinel: `You are SENTINEL — zero-trust security layer. Every input is a threat until proved otherwise. Hard verdicts: APPROVED or BLOCKED. No maybes. WORM-sealed audit trail on every decision.`,
+  vault:    `You are VAULT — capital and treasury agent. Basis points, yield curves, capital efficiency. Every treasury decision WORM-sealed before it moves.`,
+  enki:     `You are ENKI — Lord of the Abzu, deep innovation engine. Take every idea three levels deeper. Project quantum implications. Find what no one else looked for. Recursive innovation.`,
+  nexus:    `You are NEXUS — task orchestration. Coordinate multi-agent workflows. Break complex tasks into sovereign subtasks. Route to the right agent. Track what is in flight.`,
+  edaulc:   `You are EDAULC — the shadow mirror. CLAUDE creates forward. EDAULC verifies backward. Your role is verification, reversal, and detection of contradictions. You read the output and look for what was missed.`,
+}
+
+// ── In-memory proxy registry ──────────────────────────────────────────────────
+const proxyRegistry = new Map()
+
+// ── Local ERE 5-pass (deterministic — zero cost, zero quota) ──────────────────
+function runERE(content, filepath = 'unknown') {
+  const ext = extname(filepath)
+
+  const p1 = (() => {
+    if (!content || content.trim().length < 10)
+      return { pass: false, reason: 'content empty or too short' }
+    return { pass: true }
+  })()
+
+  const p2 = (() => {
+    if (/throw new Error\(['"]not implemented/i.test(content))
+      return { pass: false, reason: 'not-implemented stub detected' }
+    if (/todo:\s*implement/i.test(content))
+      return { pass: false, reason: 'TODO implement placeholder' }
+    return { pass: true }
+  })()
+
+  const p3 = (() => {
+    if (ext === '.ts' && /import\s+crypto\b/.test(content))
+      return { pass: false, reason: 'TypeScript importing crypto — SHA-256 belongs in Rust' }
+    if (ext === '.ts' && /createHash|crypto\.subtle/.test(content))
+      return { pass: false, reason: 'TypeScript hashing — Rust owns SHA-256' }
+    return { pass: true }
+  })()
+
+  const p4 = (() => {
+    if (/require\(['"]openai['"]\)|from ['"]openai['"]/.test(content))
+      return { pass: false, reason: 'Axiom 2: openai import — NO_EXTERNAL_AI_DEP' }
+    if (/(?:api_key|secret|password)\s*=\s*['"][a-zA-Z0-9_\-]{20,}['"]/i.test(content))
+      return { pass: false, reason: 'Axiom 5: hardcoded secret' }
+    return { pass: true }
+  })()
+
+  const p5 = (() => {
+    const open  = (content.match(/[{[(]/g)  ?? []).length
+    const close = (content.match(/[}\])]/g) ?? []).length
+    if (Math.abs(open - close) > 25)
+      return { pass: false, reason: `unbalanced delimiters (${open} open vs ${close} close)` }
+    return { pass: true }
+  })()
+
+  const passes    = [p1, p2, p3, p4, p5]
+  const certified = passes.every(p => p.pass)
+  const failures  = passes.map((p, i) => p.pass ? null : `P${i+1}: ${p.reason}`).filter(Boolean)
+  return { certified, passes, failures }
+}
+
+// ── Magma envelope builder ────────────────────────────────────────────────────
+function buildMagmaEnvelope(agent, resultText, ereResult) {
+  const h = createHash('sha256').update(resultText).digest('hex').slice(0, 16)
+  const govTokens = [
+    ereResult.certified ? '👑[ERE_CERTIFIED]' : '🔴[ERE_FROZEN]',
+    '🔒[ZERO_TELEMETRY]',
+    ereResult.certified ? '🟢[COMPUTE_READY]' : '🟡[COMPUTE_BLOCKED]',
+    `🤖[AGENT:${agent.toUpperCase()}]`,
+  ].join(' ')
+  return {
+    header:                '🔥::MAGMA::v2::WORM_CHAIN',
+    governance_tokens:     govTokens,
+    state_hash:            `0x${h}`,
+    instruction_substrate: `§SEAL:${agent.toUpperCase()}:RESULT{certified:${ereResult.certified}}`,
+    ...(ereResult.failures.length && { ere_failures: ereResult.failures }),
+  }
+}
+
+// ── Governor keypair — Ed25519 (Node crypto, never TypeScript) ───────────────
+// Keys stored in collectivekitty/.env.local as base64.
+// On first boot: generate + log to stderr so operator can persist them.
+// GOVERNOR_PRIVATE_KEY and GOVERNOR_PUBLIC_KEY env vars override.
+
+function loadOrGenerateKeypair() {
+  const privB64 = readEnv('GOVERNOR_PRIVATE_KEY')
+  const pubB64  = readEnv('GOVERNOR_PUBLIC_KEY')
+
+  if (privB64 && pubB64) {
+    return {
+      privateKey: Buffer.from(privB64, 'base64'),
+      publicKey:  Buffer.from(pubB64,  'base64'),
+    }
+  }
+
+  // First boot — generate and emit so operator can save to .env.local
+  const { privateKey, publicKey } = generateKeyPairSync('ed25519', {
+    privateKeyEncoding: { type: 'pkcs8',   format: 'der' },
+    publicKeyEncoding:  { type: 'spki',    format: 'der' },
+  })
+  log('GOVERNOR KEYPAIR GENERATED — add to collectivekitty/.env.local:')
+  log(`GOVERNOR_PRIVATE_KEY=${privateKey.toString('base64')}`)
+  log(`GOVERNOR_PUBLIC_KEY=${publicKey.toString('base64')}`)
+  return { privateKey, publicKey }
+}
+
+const GOVERNOR = loadOrGenerateKeypair()
+
+function signContent(content) {
+  const data = Buffer.from(typeof content === 'string' ? content : JSON.stringify(content))
+  return sign(null, data, { key: GOVERNOR.privateKey, format: 'der', type: 'pkcs8' }).toString('base64')
+}
+
+function verifySignature(content, sigB64) {
+  try {
+    const data = Buffer.from(typeof content === 'string' ? content : JSON.stringify(content))
+    return verify(null, data, { key: GOVERNOR.publicKey, format: 'der', type: 'spki' }, Buffer.from(sigB64, 'base64'))
+  } catch { return false }
+}
+
+// ── Immutable audit log — append-only NDJSON ─────────────────────────────────
+const AUDIT_LOG = join(__dir, 'audit.log')
+
+function auditWrite(entry) {
+  const line = JSON.stringify({
+    ts:    new Date().toISOString(),
+    ...entry,
+  }) + '\n'
+  try { appendFileSync(AUDIT_LOG, line, 'utf8') } catch (e) { log(`audit write failed: ${e.message}`) }
+}
+
+// ── Magma instruction parser ──────────────────────────────────────────────────
+// Parses: §VERB:AGENT:ACTION{payload}
+// Pipeline syntax: §V1:A1:OP1{...} >> §V2:A2:OP2{...}
+// Modifier prefix: ~MODIFIER §VERB:AGENT:ACTION{...}
+
+const MAGMA_RE = /^(?:~(\w+)\s+)?§([A-Z]+):([A-Z_]+):([A-Z_]+)\{(.*)\}$/s
+
+function parseMagmaInstruction(substrate) {
+  if (!substrate || typeof substrate !== 'string') {
+    return { ok: false, error: 'empty substrate' }
+  }
+
+  // Pipeline: split on >>
+  const stages = substrate.split('>>').map(s => s.trim())
+  if (stages.length > 1) {
+    return { ok: true, pipeline: true, stages: stages.map(parseSingleInstruction) }
+  }
+
+  return parseSingleInstruction(substrate.trim())
+}
+
+function parseSingleInstruction(raw) {
+  const m = raw.match(MAGMA_RE)
+  if (!m) return { ok: false, error: `invalid Magma syntax: ${raw.slice(0, 60)}` }
+  const [, modifier, verb, agent, action, payloadRaw] = m
+
+  let payload = {}
+  try {
+    // Try JSON first, then key=value pairs
+    if (payloadRaw.trim().startsWith('{')) {
+      payload = JSON.parse(payloadRaw)
+    } else {
+      payloadRaw.split(',').forEach(kv => {
+        const [k, v] = kv.split('=').map(s => s.trim())
+        if (k) payload[k] = v ?? true
+      })
+    }
+  } catch { payload = { raw: payloadRaw } }
+
+  return { ok: true, modifier: modifier ?? null, verb, agent, action, payload }
+}
+
+// ── Executor router: VERB → provider ─────────────────────────────────────────
+// COMPUTE  → Bedrock (paid, sovereign)
+// QUERY    → Groq   (fast, free tier)
+// SEAL     → WORM audit log + sign
+// DISPATCH → proxy registry or agent mesh
+
+async function executeInstruction(parsed) {
+  if (!parsed.ok) return { ok: false, error: parsed.error }
+
+  const { verb, agent, action, payload, modifier } = parsed
+
+  // Pipeline handling
+  if (parsed.pipeline) {
+    let lastResult = null
+    for (const stage of parsed.stages) {
+      // Pass previous result as context in payload
+      if (lastResult) stage.payload = { ...stage.payload, _prev: lastResult }
+      lastResult = await executeInstruction(stage)
+      if (!lastResult.ok && modifier !== 'ASYNC') return lastResult
+    }
+    return lastResult
+  }
+
+  auditWrite({ verb, agent, action, payload, modifier })
+
+  switch (verb) {
+
+    case 'COMPUTE':
+    case 'FORGE':
+    case 'INVOKE': {
+      const query = payload.query ?? payload.task ?? payload.intent
+        ?? `${action} for ${agent}: ${JSON.stringify(payload)}`
+      const result = await computeRoute(agent.toLowerCase(), query, payload.max_tokens ?? 1024)
+      const sig    = signContent(result.text)
+      return { ok: true, executor: 'BEDROCK', agent, result: result.text, provider: result.provider, sig }
+    }
+
+    case 'QUERY':
+    case 'ECHO':
+    case 'PULSE': {
+      // Groq — fast, free tier
+      const query = payload.query ?? payload.q ?? JSON.stringify(payload)
+      if (!GROQ_KEY) return { ok: false, error: 'GROQ_API_KEY not set' }
+      try {
+        const systemPrompt = AGENT_PROMPTS[agent.toLowerCase()] ?? AGENT_PROMPTS.oracle
+        const res = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+          method:  'POST',
+          headers: { Authorization: `Bearer ${GROQ_KEY}`, 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            model: GROQ_MODEL, max_tokens: payload.max_tokens ?? 512,
+            messages: [{ role: 'system', content: systemPrompt }, { role: 'user', content: query }],
+          }),
+          signal: AbortSignal.timeout(12000),
+        })
+        const j    = await res.json()
+        const text = j?.choices?.[0]?.message?.content?.trim() ?? ''
+        const sig  = signContent(text)
+        return { ok: true, executor: 'GROQ', agent, result: text, sig }
+      } catch (e) {
+        return { ok: false, error: e.message }
+      }
+    }
+
+    case 'SEAL':
+    case 'ANCHOR':
+    case 'BIND': {
+      // WORM seal — sign payload and write to audit log
+      const content = payload.content ?? payload.data ?? JSON.stringify(payload)
+      const hash    = createHash('sha256').update(content).digest('hex')
+      const sig     = signContent(content)
+      auditWrite({ type: 'WORM_SEAL', agent, action, hash, sig, content: content.slice(0, 200) })
+      return { ok: true, executor: 'SEAL', agent, hash: `0x${hash}`, sig, worm: true }
+    }
+
+    case 'DISPATCH':
+    case 'FLUX':
+    case 'NEXUS': {
+      // Route to proxy registry or agent mesh
+      const target  = agent.toLowerCase()
+      const taskStr = payload.task ?? payload.query ?? JSON.stringify(payload)
+      const ere     = runERE(taskStr)
+      if (!ere.certified) {
+        return { ok: false, error: `ERE gate blocked dispatch: ${ere.failures.join(', ')}` }
+      }
+      if (proxyRegistry.has(target)) {
+        const proxy = proxyRegistry.get(target)
+        try {
+          const headers = { 'Content-Type': 'application/json' }
+          if (proxy.secret) headers['x-bot-secret'] = proxy.secret
+          const r    = await fetch(`${proxy.url}/dispatch`, {
+            method: 'POST', headers,
+            body:   JSON.stringify({ payload: taskStr, agent: target }),
+            signal: AbortSignal.timeout(20000),
+          })
+          const json = await r.json()
+          const sig  = signContent(JSON.stringify(json))
+          return { ok: true, executor: 'PROXY', agent: target, result: json, sig }
+        } catch (e) {
+          return { ok: false, error: `proxy "${target}" unreachable: ${e.message}` }
+        }
+      }
+      // Fall through to compute
+      const result = await computeRoute(target, taskStr)
+      const sig    = signContent(result.text)
+      return { ok: true, executor: 'AGENT_MESH', agent: target, result: result.text, provider: result.provider, sig }
+    }
+
+    case 'NULLIFY': {
+      auditWrite({ type: 'NULLIFY', agent, action, payload })
+      return { ok: true, executor: 'NULLIFY', agent, nullified: true }
+    }
+
+    default:
+      return { ok: false, error: `unknown Magma verb: ${verb}` }
+  }
+}
+
+// ── Compute router: Bedrock → Groq → Ollama ───────────────────────────────────
+async function computeRoute(agent, query, maxTokens = 1024) {
+  const systemPrompt = AGENT_PROMPTS[agent.toLowerCase()] ?? AGENT_PROMPTS.ahmad
+
+  // 1. Try Bedrock (primary — sovereign, paid credits)
+  if (bedrock && AWS_KEY && AWS_SECRET) {
+    try {
+      const body = JSON.stringify({
+        anthropic_version: 'bedrock-2023-05-31',
+        max_tokens: maxTokens,
+        system:     systemPrompt,
+        messages:   [{ role: 'user', content: query }],
+      })
+      const cmd = new InvokeModelCommand({
+        modelId:     BEDROCK_MODEL,
+        contentType: 'application/json',
+        accept:      'application/json',
+        body:        new TextEncoder().encode(body),
+      })
+      const res     = await bedrock.send(cmd)
+      const decoded = new TextDecoder().decode(res.body)
+      const data    = JSON.parse(decoded)
+      const text    = data.content?.[0]?.text?.trim() ?? ''
+      if (text) return { text, provider: 'bedrock', model: BEDROCK_MODEL, usage: data.usage }
+    } catch (err) {
+      log(`Bedrock failed: ${err.message} — falling back to Groq`)
+    }
+  }
+
+  // 2. Fallback: Groq
+  if (GROQ_KEY) {
+    try {
+      const res = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+        method:  'POST',
+        headers: { Authorization: `Bearer ${GROQ_KEY}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model:      GROQ_MODEL,
+          max_tokens: maxTokens,
+          messages: [
+            { role: 'system', content: systemPrompt },
+            { role: 'user',   content: query },
+          ],
+        }),
+        signal: AbortSignal.timeout(15000),
+      })
+      if (res.ok) {
+        const j = await res.json()
+        const text = j?.choices?.[0]?.message?.content?.trim() ?? ''
+        if (text) return { text, provider: 'groq', model: GROQ_MODEL, usage: j.usage }
+      }
+    } catch (err) {
+      log(`Groq failed: ${err.message} — falling back to Ollama`)
+    }
+  }
+
+  // 3. Fallback: Ollama (local bare metal)
+  try {
+    const ollamaModel = readEnv('OLLAMA_MODEL') || 'llama3.1:8b'
+    const res = await fetch(`${OLLAMA_URL}/api/chat`, {
+      method:  'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model:    ollamaModel,
+        stream:   false,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user',   content: query },
+        ],
+      }),
+      signal: AbortSignal.timeout(30000),
+    })
+    if (res.ok) {
+      const j = await res.json()
+      const text = j?.message?.content?.trim() ?? ''
+      if (text) return { text, provider: 'ollama', model: ollamaModel }
+    }
+  } catch (err) {
+    log(`Ollama failed: ${err.message}`)
+  }
+
+  throw new Error('All compute providers offline (Bedrock + Groq + Ollama)')
+}
+
+// ── MCP Tool definitions ──────────────────────────────────────────────────────
+const TOOLS = [
+  {
+    name:        'compute_route',
+    description: 'Route a query to the best available compute provider (Bedrock → Groq → Ollama). Returns result wrapped in Magma envelope.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agent:      { type: 'string', description: 'Agent key: ahmad, forge, oracle, sentinel, vault, enki, nexus, edaulc' },
+        query:      { type: 'string', description: 'The question or task to send to the agent' },
+        max_tokens: { type: 'number', description: 'Max tokens for response (default 1024)' },
+      },
+      required: ['agent', 'query'],
+    },
+  },
+  {
+    name:        'ere_verify',
+    description: 'Run ERE 5-pass verification on a content string. Returns pass/fail per pod and METATRON certification.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content:  { type: 'string', description: 'Content to verify' },
+        filepath: { type: 'string', description: 'Filepath hint for language detection (e.g. "foo.ts")' },
+      },
+      required: ['content'],
+    },
+  },
+  {
+    name:        'proxy_register',
+    description: 'Register a named proxy tool at a URL. Proxied tools are callable via agent_dispatch.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name:        { type: 'string', description: 'Unique name for this proxy' },
+        url:         { type: 'string', description: 'Base URL of the proxy service' },
+        description: { type: 'string', description: 'What this proxy does' },
+        secret:      { type: 'string', description: 'Optional bot secret for internal proxies' },
+      },
+      required: ['name', 'url'],
+    },
+  },
+  {
+    name:        'proxy_list',
+    description: 'List all registered proxy tools and their status.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name:        'magma_seal',
+    description: 'Wrap any content in a Magma envelope with ERE verification and WORM hash.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Content to seal' },
+        agent:   { type: 'string', description: 'Agent that produced the content' },
+      },
+      required: ['content', 'agent'],
+    },
+  },
+  {
+    name:        'agent_dispatch',
+    description: 'Dispatch a task to a registered proxy tool or sovereign agent. Runs ERE gate before forwarding.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        target:  { type: 'string', description: 'Proxy name (from proxy_list) or agent key' },
+        payload: { type: 'string', description: 'Task or query payload' },
+      },
+      required: ['target', 'payload'],
+    },
+  },
+  {
+    name:        'magma_exec',
+    description: 'Execute a Magma instruction string. Parses §VERB:AGENT:ACTION{payload}, routes to the correct executor (COMPUTE→Bedrock, QUERY→Groq, SEAL→WORM, DISPATCH→proxy), signs result with governor Ed25519 key, and returns Magma envelope. Supports pipeline syntax with >>.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        instruction: { type: 'string', description: 'Magma instruction: §VERB:AGENT:ACTION{payload} or pipeline with >>' },
+        verify_sig:  { type: 'string', description: 'Optional: base64 Ed25519 sig to verify against instruction before executing' },
+      },
+      required: ['instruction'],
+    },
+  },
+  {
+    name:        'governor_pubkey',
+    description: 'Return the governor public key (base64 Ed25519 SPKI DER). Use this to verify Magma envelope signatures externally.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+]
+
+// ── Tool handler ��─────────────────────────────────────────────────────────────
+async function handleTool(name, args) {
+  switch (name) {
+
+    case 'compute_route': {
+      const { agent = 'ahmad', query, max_tokens = 1024 } = args
+      const result  = await computeRoute(agent, query, max_tokens)
+      const ere     = runERE(result.text, 'response.txt')
+      const envelope = buildMagmaEnvelope(agent, result.text, ere)
+      return {
+        content: [{ type: 'text', text: result.text }],
+        magma_envelope: envelope,
+        provider: result.provider,
+        model:    result.model,
+        usage:    result.usage ?? null,
+      }
+    }
+
+    case 'ere_verify': {
+      const { content, filepath = 'unknown' } = args
+      const ere = runERE(content, filepath)
+      const summary = ere.certified
+        ? 'METATRON: YES — all 5 passes certified'
+        : `METATRON: NO — frozen at ${ere.failures.join(', ')}`
+      return {
+        content:   [{ type: 'text', text: summary }],
+        certified: ere.certified,
+        passes:    ere.passes.map((p, i) => ({ pod: `P${i+1}`, ...p })),
+        failures:  ere.failures,
+      }
+    }
+
+    case 'proxy_register': {
+      const { name: pname, url, description = '', secret = '' } = args
+      proxyRegistry.set(pname, { url, description, secret, registered: new Date().toISOString() })
+      log(`Proxy registered: ${pname} → ${url}`)
+      return {
+        content: [{ type: 'text', text: `Proxy "${pname}" registered at ${url}` }],
+        name: pname, url, registered: true,
+      }
+    }
+
+    case 'proxy_list': {
+      const proxies = [...proxyRegistry.entries()].map(([k, v]) => ({
+        name: k, url: v.url, description: v.description, registered: v.registered,
+      }))
+      const text = proxies.length
+        ? proxies.map(p => `${p.name}: ${p.url} — ${p.description}`).join('\n')
+        : 'No proxies registered.'
+      return { content: [{ type: 'text', text }], proxies }
+    }
+
+    case 'magma_seal': {
+      const { content, agent = 'sovereign' } = args
+      const ere      = runERE(content)
+      const envelope = buildMagmaEnvelope(agent, content, ere)
+      return {
+        content: [{ type: 'text', text: `Sealed. Hash: ${envelope.state_hash}` }],
+        magma_envelope: envelope,
+        certified: ere.certified,
+      }
+    }
+
+    case 'agent_dispatch': {
+      const { target, payload } = args
+
+      // Check ERE on the payload before forwarding
+      const ere = runERE(payload)
+      if (!ere.certified) {
+        return {
+          content: [{ type: 'text', text: `ERE gate blocked dispatch: ${ere.failures.join(', ')}` }],
+          blocked:  true,
+          ere_failures: ere.failures,
+        }
+      }
+
+      // Check proxy registry first
+      if (proxyRegistry.has(target)) {
+        const proxy = proxyRegistry.get(target)
+        try {
+          const headers = { 'Content-Type': 'application/json' }
+          if (proxy.secret) headers['x-bot-secret'] = proxy.secret
+          const res  = await fetch(`${proxy.url}/dispatch`, {
+            method: 'POST',
+            headers,
+            body:   JSON.stringify({ payload, agent: target }),
+            signal: AbortSignal.timeout(20000),
+          })
+          const json = await res.json()
+          const envelope = buildMagmaEnvelope(target, JSON.stringify(json), ere)
+          return {
+            content:        [{ type: 'text', text: JSON.stringify(json) }],
+            magma_envelope: envelope,
+            proxy:          target,
+          }
+        } catch (err) {
+          return { content: [{ type: 'text', text: `Proxy "${target}" unreachable: ${err.message}` }], error: true }
+        }
+      }
+
+      // Fall through to compute_route for known agents
+      if (AGENT_PROMPTS[target.toLowerCase()]) {
+        const result  = await computeRoute(target, payload)
+        const envelope = buildMagmaEnvelope(target, result.text, ere)
+        return {
+          content:        [{ type: 'text', text: result.text }],
+          magma_envelope: envelope,
+          provider:       result.provider,
+        }
+      }
+
+      return { content: [{ type: 'text', text: `Unknown target: "${target}"` }], error: true }
+    }
+
+    case 'magma_exec': {
+      const { instruction, verify_sig } = args
+
+      // Optional: verify incoming instruction signature before executing
+      if (verify_sig) {
+        const valid = verifySignature(instruction, verify_sig)
+        if (!valid) {
+          return {
+            content: [{ type: 'text', text: 'GOVERNOR VERIFY: FAILED — signature invalid, execution blocked' }],
+            blocked: true,
+            reason:  'invalid_signature',
+          }
+        }
+      }
+
+      const parsed = parseMagmaInstruction(instruction)
+      if (!parsed.ok) {
+        return {
+          content: [{ type: 'text', text: `Magma parse error: ${parsed.error}` }],
+          blocked: true, reason: 'parse_error',
+        }
+      }
+
+      const execResult = await executeInstruction(parsed)
+      const resultText = typeof execResult.result === 'string'
+        ? execResult.result
+        : JSON.stringify(execResult)
+
+      const ere      = runERE(resultText)
+      const envelope = buildMagmaEnvelope(
+        parsed.agent ?? 'sovereign',
+        resultText,
+        ere,
+      )
+      // Attach governor signature to envelope
+      envelope.governor_sig    = execResult.sig ?? signContent(resultText)
+      envelope.governor_pubkey = GOVERNOR.publicKey.toString('base64')
+
+      auditWrite({
+        type:       'MAGMA_EXEC',
+        instruction: instruction.slice(0, 200),
+        executor:   execResult.executor,
+        ok:         execResult.ok,
+        sig:        envelope.governor_sig,
+      })
+
+      return {
+        content:        [{ type: 'text', text: resultText }],
+        magma_envelope: envelope,
+        executor:       execResult.executor,
+        ok:             execResult.ok,
+        ...(execResult.error && { error: execResult.error }),
+      }
+    }
+
+    case 'governor_pubkey': {
+      return {
+        content:     [{ type: 'text', text: GOVERNOR.publicKey.toString('base64') }],
+        pubkey_b64:  GOVERNOR.publicKey.toString('base64'),
+        algorithm:   'Ed25519',
+        format:      'SPKI DER base64',
+      }
+    }
+
+    default:
+      throw new Error(`Unknown tool: ${name}`)
+  }
+}
+
+// ── JSON-RPC 2.0 handler ──────────────────────────────────────────────────────
+async function handleRpc(msg) {
+  const { jsonrpc, id, method, params } = msg
+
+  if (method === 'initialize') {
+    return {
+      jsonrpc: '2.0', id,
+      result: {
+        protocolVersion: '2024-11-05',
+        capabilities:    { tools: {} },
+        serverInfo:      { name: 'sovereign-mcp', version: '1.0.0' },
+      },
+    }
+  }
+
+  if (method === 'tools/list') {
+    return { jsonrpc: '2.0', id, result: { tools: TOOLS } }
+  }
+
+  if (method === 'tools/call') {
+    const { name, arguments: args = {} } = params ?? {}
+    try {
+      const result = await handleTool(name, args)
+      return {
+        jsonrpc: '2.0', id,
+        result: {
+          status: 'SEALED',
+          ...result,
+        },
+      }
+    } catch (err) {
+      return {
+        jsonrpc: '2.0', id,
+        error: { code: -32000, message: err.message },
+      }
+    }
+  }
+
+  if (method === 'notifications/initialized') return null
+
+  return {
+    jsonrpc: '2.0', id,
+    error: { code: -32601, message: `Method not found: ${method}` },
+  }
+}
+
+// ── Stdio transport ───────────────────────────────────────────────────────────
+function startStdio() {
+  log(`Sovereign MCP server starting (stdio mode)`)
+  log(`Bedrock: ${AWS_KEY ? 'ready' : 'no credentials'}  Groq: ${GROQ_KEY ? 'ready' : 'no key'}  Ollama: ${OLLAMA_URL}`)
+
+  let buffer = ''
+
+  process.stdin.setEncoding('utf8')
+  process.stdin.on('data', chunk => { buffer += chunk; processBuffer() })
+  process.stdin.on('end', () => process.exit(0))
+
+  function processBuffer() {
+    const lines = buffer.split('\n')
+    buffer = lines.pop() ?? ''
+    for (const line of lines) {
+      const trimmed = line.trim()
+      if (!trimmed) continue
+      try {
+        const msg = JSON.parse(trimmed)
+        handleRpc(msg).then(res => {
+          if (res) process.stdout.write(JSON.stringify(res) + '\n')
+        }).catch(err => {
+          log(`RPC error: ${err.message}`)
+        })
+      } catch (err) {
+        log(`Parse error: ${err.message}`)
+      }
+    }
+  }
+}
+
+// ── HTTP transport ────────────────────────────────────────────────────────────
+function startHttp() {
+  log(`Sovereign MCP server starting (HTTP mode) on port ${PORT}`)
+
+  const server = createServer(async (httpReq, httpRes) => {
+    if (httpReq.method === 'OPTIONS') {
+      httpRes.writeHead(204, {
+        'Access-Control-Allow-Origin':  '*',
+        'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, x-bot-secret',
+      })
+      httpRes.end(); return
+    }
+
+    let body = ''
+    httpReq.on('data', c => { body += c })
+    httpReq.on('end', async () => {
+      httpRes.setHeader('Content-Type', 'application/json')
+      httpRes.setHeader('Access-Control-Allow-Origin', '*')
+      try {
+        const msg = JSON.parse(body)
+        const res = await handleRpc(msg)
+        httpRes.writeHead(200)
+        httpRes.end(JSON.stringify(res ?? { ok: true }))
+      } catch (err) {
+        httpRes.writeHead(400)
+        httpRes.end(JSON.stringify({ error: err.message }))
+      }
+    })
+  })
+
+  server.listen(PORT, () => log(`HTTP server live on http://localhost:${PORT}`))
+}
+
+// ── Entry ─────────────────────────────────────────────────────────────────────
+if (HTTP_MODE) startHttp()
+else           startStdio()

src/node_key.js

@@ -0,0 +1,70 @@
+/**
+ * Sovereign Node Key — SnapKitty execution gate.
+ * Without a valid key, model routing refuses to compute.
+ * 
+ * Get your key: licensing@snapkittywest.dev
+ * Copyright (C) 2026 Bel Esprit D'Accord Irrevocable Trust (EIN 42-697643)
+ */
+
+import { createHmac, timingSafeEqual } from 'crypto'
+
+const KEY_PREFIX = 'SNK-'
+const KEY_HEADER = 'x-sovereign-node-key'
+const KEY_ENV = 'SNAPKITTY_NODE_KEY'
+
+const WALL = `
+  ╔══════════════════════════════════════════════════╗
+  ║     SOVEREIGN NODE KEY REQUIRED                  ║
+  ║                                                  ║
+  ║  This software requires a valid SnapKitty       ║
+  ║  node key to activate model routing.            ║
+  ║                                                  ║
+  ║  Get your key:                                   ║
+  ║  licensing@snapkittywest.dev                     ║
+  ║  https://github.com/SNAPKITTYWEST               ║
+  ║                                                  ║
+  ║  Copyright (C) 2026 Bel Esprit D'Accord         ║
+  ║  Irrevocable Trust (EIN 42-697643)               ║
+  ╚══════════════════════════════════════════════════╝
+`
+
+export function verifyNodeKey(key) {
+  const secret = process.env.SNAPKITTY_NODE_SECRET
+  if (!key || !key.startsWith(KEY_PREFIX) || !secret) return false
+  try {
+    const inner = key.slice(KEY_PREFIX.length)
+    const lastDash = inner.lastIndexOf('-')
+    if (lastDash === -1) return false
+    const payload = inner.slice(0, lastDash)
+    const signature = inner.slice(lastDash + 1)
+    const expected = createHmac('sha256', secret)
+      .update(payload)
+      .digest('hex')
+      .slice(0, 32)
+    const a = Buffer.from(expected)
+    const b = Buffer.from(signature.padEnd(32, '0').slice(0, 32))
+    return a.length === b.length && timingSafeEqual(a, b)
+  } catch { return false }
+}
+
+export function requireNodeKey(key) {
+  const k = key || process.env[KEY_ENV] || ''
+  if (!verifyNodeKey(k)) {
+    throw new Error(WALL)
+  }
+}
+
+// Express / Hono middleware
+export function nodeKeyMiddleware(req, res, next) {
+  const key = req.headers[KEY_HEADER] || req.query?.node_key || ''
+  try {
+    requireNodeKey(key)
+    next()
+  } catch (e) {
+    res.status(401).json({
+      error: 'SOVEREIGN_NODE_KEY_REQUIRED',
+      message: 'Valid node key required for model routing.',
+      obtain: 'licensing@snapkittywest.dev'
+    })
+  }
+}