🎛️ Reengineer as CAPT Fleet Controller

- Complete rewrite from Memory Palace Proxy to Fleet Controller
- Monitor 5 Cloudflare brains + 16 public HF spaces
- Auto-route queries to best brain based on keywords
- Council mode: query all 5 brains and synthesize consensus
- PULSE proxy with tiered model selector
- ECHO memory proxy across all brains
- API tester for any brain endpoint
- MCP hub with connection guides

README.md

@@ -1,10 +0,0 @@
----
-title: CAPT Memory Palace Proxy
-emoji: 🏆
-colorFrom: blue
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,457 @@
+"""
+🎛️ CAPT Fleet Controller
+Private HF Space — Central orchestrator for all CAPT brains and public HF spaces.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+
+import gradio as gr
+import requests
+
+from fleet_controller import (
+    BRAINS, HF_SPACES, ROUTING_KEYWORDS, MODEL_TIERS, TIER_LABELS,
+    route_query, call_brain, call_all_brains,
+    check_brain_health, check_all_brains,
+    check_space_health, check_all_spaces,
+    get_all_models,
+)
+
+OPENROUTER_KEY = os.getenv("OPENROUTER_API_KEY", "")
+
+# ─── Helper: OpenRouter direct call ───
+def call_openrouter(prompt: str, model: str = "deepseek/deepseek-chat-v3-0324", system: str = "", temperature: float = 0.7, max_tokens: int = 2048) -> dict:
+    if not OPENROUTER_KEY:
+        return {"error": "OPENROUTER_API_KEY not configured"}
+    try:
+        r = requests.post(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers={
+                "Authorization": f"Bearer {OPENROUTER_KEY}",
+                "Content-Type": "application/json",
+                "HTTP-Referer": "https://capt.dev",
+                "X-Title": "CAPT-Fleet-Controller",
+            },
+            json={
+                "model": model,
+                "messages": [
+                    {"role": "system", "content": system or "You are CAPT Fleet Controller."},
+                    {"role": "user", "content": prompt},
+                ],
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+            },
+            timeout=60,
+        )
+        data = r.json()
+        if r.status_code != 200:
+            return {"error": f"HTTP {r.status_code}: {data.get('error', {}).get('message', r.text[:200])}"}
+        return {
+            "content": data["choices"][0]["message"]["content"],
+            "model": data.get("model", model),
+            "input_tokens": data.get("usage", {}).get("prompt_tokens", 0),
+            "output_tokens": data.get("usage", {}).get("completion_tokens", 0),
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+# ═══════════════════════════════════════════════════════════════════
+# TAB BUILDERS
+# ═══════════════════════════════════════════════════════════════════
+
+def build_fleet_dashboard():
+    with gr.Tab("🎛️ Fleet Dashboard"):
+        gr.Markdown("## CAPT Fleet Controller\nMonitor all brains and spaces in real-time.")
+
+        with gr.Row():
+            refresh_btn = gr.Button("🔄 Refresh All", variant="primary")
+            auto_refresh = gr.Checkbox(label="Auto-refresh (30s)", value=False)
+
+        gr.Markdown("### 🧠 Brain Health")
+        brain_table = gr.Dataframe(
+            headers=["Icon", "Brain", "Status", "Latency", "Worker"],
+            datatype=["str", "str", "str", "str", "str"],
+            interactive=False,
+            wrap=True,
+        )
+
+        gr.Markdown("### 🚀 HF Space Health")
+        space_table = gr.Dataframe(
+            headers=["Space", "Status", "Online", "HTTP", "Latency", "Issue"],
+            datatype=["str", "str", "str", "str", "str", "str"],
+            interactive=False,
+            wrap=True,
+        )
+
+        def refresh_dashboard():
+            brains = check_all_brains()
+            spaces = check_all_spaces()
+
+            brain_rows = []
+            for b in brains:
+                icon = "🟢" if b.get("online") else "🔴"
+                brain_rows.append([
+                    BRAINS.get(b["brain_id"], {}).get("icon", "🧠"),
+                    b.get("name", b["brain_id"]),
+                    f"{icon} {b.get('status', 'unknown')}",
+                    f"{b.get('latency_ms', 0)}ms" if b.get("online") else "—",
+                    BRAINS.get(b["brain_id"], {}).get("worker", ""),
+                ])
+
+            space_rows = []
+            for s in spaces:
+                icon = "🟢" if s.get("online") else "🔴"
+                space_rows.append([
+                    s.get("name", s["id"]),
+                    f"{icon} {s.get('status', 'unknown')}",
+                    "✅" if s.get("online") else "❌",
+                    str(s.get("http_code", "—")),
+                    f"{s.get('latency_ms', 0)}ms" if s.get("online") else "—",
+                    s.get("error", HF_SPACES.get(s["id"], {}).get("issue", "")),
+                ])
+
+            return brain_rows, space_rows
+
+        refresh_btn.click(refresh_dashboard, outputs=[brain_table, space_table])
+
+        # Auto-refresh timer
+        def auto_refresh_fn(active):
+            if active:
+                return refresh_dashboard()
+            return [], []
+
+        # Initial load
+        demo.load(refresh_dashboard, outputs=[brain_table, space_table])
+
+
+def build_brain_router():
+    with gr.Tab("🧠 Brain Router"):
+        gr.Markdown("## Query Router\nSend queries to individual brains or let the fleet auto-route.")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                router_query = gr.Textbox(label="Query", placeholder="Ask anything...", lines=3)
+                router_context = gr.Textbox(label="Context (optional)", placeholder="Additional context", lines=2)
+
+                with gr.Row():
+                    router_mode = gr.Radio(
+                        choices=[("Auto-Route", "auto"), ("Manual Select", "manual"), ("All Brains (Council)", "council")],
+                        value="auto",
+                        label="Routing Mode"
+                    )
+                    router_brain = gr.Dropdown(
+                        choices=[(f"{b['icon']} {b['name']}", bid) for bid, b in BRAINS.items()],
+                        value="capt-core-01",
+                        label="Target Brain",
+                        visible=False,
+                    )
+
+                with gr.Row():
+                    router_tier = gr.Dropdown(
+                        choices=[("All Tiers", "all")] + [(v, k) for k, v in TIER_LABELS.items()],
+                        value="all",
+                        label="Model Tier"
+                    )
+                    router_model = gr.Dropdown(choices=get_all_models(), value="deepseek/deepseek-chat-v3-0324", label="Model")
+
+                router_btn = gr.Button("⚡ Execute", variant="primary")
+
+            with gr.Column(scale=3):
+                router_result = gr.Textbox(label="Response", lines=10, interactive=False)
+                with gr.Row():
+                    router_brain_used = gr.Textbox(label="Brain Used", interactive=False)
+                    router_confidence = gr.Textbox(label="Confidence", interactive=False)
+                    router_latency = gr.Textbox(label="Latency", interactive=False)
+
+        def on_mode_change(mode):
+            return gr.Dropdown(visible=(mode == "manual"))
+
+        router_mode.change(on_mode_change, inputs=router_mode, outputs=router_brain)
+
+        def on_tier_change(tier):
+            if tier == "all":
+                return gr.Dropdown(choices=get_all_models())
+            models = []
+            for t, items in MODEL_TIERS.items():
+                if t == tier:
+                    for mid, name in items:
+                        models.append((f"{TIER_LABELS[t]}: {name}", mid))
+            return gr.Dropdown(choices=models)
+
+        router_tier.change(on_tier_change, inputs=router_tier, outputs=router_model)
+
+        def do_route(query, context, mode, brain_id, model):
+            if not query.strip():
+                return "Enter a query.", "", "", ""
+
+            start = time.time()
+            payload = {"query": query, "context": context, "model": model, "modality": "text"}
+
+            if mode == "council":
+                results = call_all_brains("/cogitate", payload)
+                # Aggregate responses
+                responses = []
+                for bid, result in results.items():
+                    name = BRAINS.get(bid, {}).get("name", bid)
+                    resp = result.get("response", f"Error: {result.get('error', 'Unknown')}")
+                    conf = result.get("confidence", 0)
+                    responses.append(f"### {name} (confidence: {conf:.2f})\n{resp[:500]}")
+
+                summary_prompt = f"Synthesize these {len(responses)} expert opinions into a single coherent response:\n\n" + "\n\n---\n\n".join(responses)
+                summary = call_openrouter(summary_prompt, model, "You are a synthesis engine. Combine multiple expert opinions into one clear answer.", 0.3, 2048)
+                full_response = f"## 🏛️ Council Consensus\n\n{summary.get('content', 'Synthesis failed')}\n\n---\n\n## Individual Responses\n\n" + "\n\n".join(responses)
+                return full_response, "LLM Council (All 5)", f"{summary.get('confidence', 0):.2f}" if isinstance(summary, dict) else "N/A", f"{int((time.time()-start)*1000)}ms"
+
+            elif mode == "auto":
+                brain_id = route_query(query)
+
+            result = call_brain(brain_id, "/cogitate", payload)
+            if "error" in result:
+                return f"Error: {result['error']}", brain_id, "", ""
+
+            brain_name = BRAINS.get(brain_id, {}).get("name", brain_id)
+            return (
+                result.get("response", ""),
+                f"{brain_name} ({brain_id})",
+                f"{result.get('confidence', 0)*100:.1f}%",
+                f"{result.get('pipelineTrace', {}).get('totalLatencyMs', 0)}ms",
+            )
+
+        router_btn.click(
+            do_route,
+            inputs=[router_query, router_context, router_mode, router_brain, router_model],
+            outputs=[router_result, router_brain_used, router_confidence, router_latency],
+        )
+
+
+def build_pulse_proxy():
+    with gr.Tab("⚡ PULSE Proxy"):
+        gr.Markdown("## Direct LLM Access\nBypass cognition pipeline and query any model directly.")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                pulse_prompt = gr.Textbox(label="Prompt", placeholder="Enter prompt...", lines=4)
+                pulse_system = gr.Textbox(label="System Prompt", placeholder="You are CAPT...", lines=2)
+                pulse_tier = gr.Dropdown(choices=[("All Tiers", "all")] + [(v, k) for k, v in TIER_LABELS.items()], value="all", label="Tier")
+                pulse_model = gr.Dropdown(choices=get_all_models(), value="deepseek/deepseek-chat-v3-0324", label="Model")
+                with gr.Row():
+                    pulse_temp = gr.Slider(0.0, 2.0, value=0.7, step=0.1, label="Temperature")
+                    pulse_max = gr.Slider(64, 4096, value=1024, step=64, label="Max Tokens")
+                pulse_btn = gr.Button("🔥 Generate", variant="primary")
+            with gr.Column(scale=3):
+                pulse_out = gr.Textbox(label="Output", lines=12, interactive=False)
+                pulse_meta = gr.JSON(label="Metadata")
+
+        pulse_tier.change(on_tier_change, inputs=pulse_tier, outputs=pulse_model)
+
+        def do_pulse(prompt, system, model, temp, maxtok):
+            if not prompt.strip():
+                return "", {}
+            result = call_openrouter(prompt, model, system, temp, maxtok)
+            if "error" in result:
+                return f"Error: {result['error']}", {}
+            meta = {
+                "model": result.get("model"),
+                "input_tokens": result.get("input_tokens"),
+                "output_tokens": result.get("output_tokens"),
+                "total_tokens": result.get("input_tokens", 0) + result.get("output_tokens", 0),
+            }
+            return result.get("content", ""), meta
+
+        pulse_btn.click(do_pulse, inputs=[pulse_prompt, pulse_system, pulse_model, pulse_temp, pulse_max], outputs=[pulse_out, pulse_meta])
+
+
+def build_echo_proxy():
+    with gr.Tab("💾 ECHO Proxy"):
+        gr.Markdown("## Memory Proxy\nStore and recall traces across all brains.")
+
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Store")
+                echo_content = gr.Textbox(label="Content", lines=3)
+                echo_brain = gr.Dropdown(choices=[(f"{b['icon']} {b['name']}", bid) for bid, b in BRAINS.items()], value="capt-core-01", label="Brain")
+                echo_tags = gr.Textbox(label="Tags (comma-separated)")
+                echo_salience = gr.Slider(0.0, 1.0, value=0.5, step=0.05, label="Salience")
+                echo_store_btn = gr.Button("💾 Store", variant="primary")
+                echo_store_result = gr.Textbox(label="Result", interactive=False)
+            with gr.Column():
+                gr.Markdown("### Recall")
+                echo_query = gr.Textbox(label="Query")
+                echo_recall_brain = gr.Dropdown(choices=[(f"{b['icon']} {b['name']}", bid) for bid, b in BRAINS.items()], value="capt-core-01", label="Brain")
+                echo_topk = gr.Slider(1, 20, value=5, step=1, label="Top K")
+                echo_recall_btn = gr.Button("🔍 Recall")
+                echo_recall_result = gr.JSON(label="Traces")
+
+        def do_store(content, brain, tags, salience):
+            if not content.strip():
+                return "Enter content."
+            tag_list = [t.strip() for t in tags.split(",") if t.strip()]
+            result = call_brain(brain, "/echo/store", {"content": content, "salience": salience, "tags": tag_list})
+            if "error" in result:
+                return f"Error: {result['error']}"
+            return f"✅ Stored: {result.get('data', {}).get('traceId', 'N/A')}"
+
+        def do_recall(query, brain, topk):
+            if not query.strip():
+                return []
+            result = call_brain(brain, "/echo/recall", {"query": query, "topK": int(topk)})
+            if "error" in result:
+                return [{"error": result["error"]}]
+            traces = result.get("data", {}).get("traces", [])
+            return [{"content": t.get("content", "")[:200], "salience": t.get("salience"), "tags": t.get("tags")} for t in traces]
+
+        echo_store_btn.click(do_store, inputs=[echo_content, echo_brain, echo_tags, echo_salience], outputs=echo_store_result)
+        echo_recall_btn.click(do_recall, inputs=[echo_query, echo_recall_brain, echo_topk], outputs=echo_recall_result)
+
+
+def build_api_tester():
+    with gr.Tab("🔌 API Tester"):
+        gr.Markdown("## Test Any Brain API\nDirect API proxy to all brain endpoints.")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                api_brain = gr.Dropdown(choices=[(f"{b['icon']} {b['name']}", bid) for bid, b in BRAINS.items()], value="capt-core-01", label="Brain")
+                api_endpoint = gr.Dropdown(
+                    choices=["/health", "/cogitate", "/pulse", "/echo/store", "/echo/recall", "/immu/scan", "/constitution/enforce", "/status"],
+                    value="/health",
+                    label="Endpoint"
+                )
+                api_method = gr.Radio(choices=["GET", "POST"], value="GET", label="Method")
+                api_payload = gr.Code(label="Payload (JSON)", language="json", value='{}')
+                api_btn = gr.Button("📡 Send", variant="primary")
+            with gr.Column(scale=3):
+                api_response = gr.JSON(label="Response")
+                api_raw = gr.Textbox(label="Raw Response", lines=6, interactive=False)
+
+        def do_api(brain, endpoint, method, payload):
+            try:
+                body = json.loads(payload) if payload.strip() else {}
+            except json.JSONDecodeError as e:
+                return {"error": f"Invalid JSON: {e}"}, ""
+
+            worker = BRAINS.get(brain, {}).get("worker", "")
+            url = f"{worker}{endpoint}"
+            try:
+                if method == "GET":
+                    r = requests.get(url, timeout=15)
+                else:
+                    r = requests.post(url, json=body, timeout=60, headers={"Content-Type": "application/json"})
+                try:
+                    data = r.json()
+                except:
+                    data = {"status_code": r.status_code, "text": r.text[:500]}
+                return data, r.text[:1000]
+            except Exception as e:
+                return {"error": str(e)}, ""
+
+        api_btn.click(do_api, inputs=[api_brain, api_endpoint, api_method, api_payload], outputs=[api_response, api_raw])
+
+
+def build_mcp_hub():
+    with gr.Tab("🔗 MCP Hub"):
+        gr.Markdown("## Model Context Protocol Hub\nConnect MCP clients to the fleet.")
+
+        gr.Markdown("""
+### MCP Endpoints
+
+Each brain exposes a full MCP server over SSE:
+
+| Brain | MCP SSE | MCP RPC |
+|-------|---------|---------|
+""")
+        for bid, b in BRAINS.items():
+            gr.Markdown(f"| {b['icon']} {b['name']} | `{b['worker']}/mcp` | `{b['worker']}/mcp/messages` |")
+
+        gr.Markdown("""
+### MCP Tool Registry (22 tools per brain)
+
+- `capt_cogitate` — Full 46-module pipeline
+- `pulse_generate` — LLM generation
+- `sens_perceive` — Tokenization & entities
+- `echo_store` / `echo_recall` — Memory
+- `constitution_enforce` — Seven Laws
+- `immu_scan` — Threat detection
+- `qipc_consensus` — Module consensus
+- `brain_status` — Health check
+- `echo_prune` — Memory maintenance
+- ... and 13 more
+
+### Connecting Claude Desktop
+
+```json
+{
+  "mcpServers": {
+    "capt-core": {
+      "type": "sse",
+      "url": "https://capt-brain-01.knowurknottty.workers.dev/mcp"
+    }
+  }
+}
+```
+""")
+
+        mcp_test_btn = gr.Button("🧪 Test MCP Connection to CAPT Core")
+        mcp_test_result = gr.JSON(label="MCP Test Result")
+
+        def test_mcp():
+            try:
+                r = requests.post(
+                    "https://capt-brain-01.knowurknottty.workers.dev/mcp/messages",
+                    json={"jsonrpc": "2.0", "id": 1, "method": "tools/list"},
+                    timeout=15,
+                    headers={"Content-Type": "application/json"},
+                )
+                return r.json()
+            except Exception as e:
+                return {"error": str(e)}
+
+        mcp_test_btn.click(test_mcp, outputs=mcp_test_result)
+
+
+# ═══════════════════════════════════════════════════════════════════
+# MAIN APP
+# ═══════════════════════════════════════════════════════════════════
+
+with gr.Blocks(
+    title="CAPT Fleet Controller",
+    theme=gr.themes.Base(
+        primary_hue="cyan",
+        secondary_hue="violet",
+        neutral_hue="zinc",
+        font=[gr.themes.GoogleFont("Inter"), "system-ui", "sans-serif"],
+    ).set(
+        body_background_fill="*neutral_950",
+        body_text_color="*neutral_100",
+        block_background_fill="*neutral_900",
+        block_border_color="*neutral_800",
+        input_background_fill="*neutral_950",
+        button_primary_background_fill="*primary_600",
+        button_primary_text_color="white",
+    ),
+) as demo:
+    gr.Markdown(
+        "# 🎛️ CAPT Fleet Controller\n"
+        "<p style='opacity:0.7;font-size:0.9rem'>"
+        "Central orchestrator for <b>5 Cloudflare brains</b> + <b>16 public HF spaces</b> | "
+        f"API Key: {'✅' if OPENROUTER_KEY else '❌ Not Set'}"
+        "</p>"
+    )
+
+    build_fleet_dashboard()
+    build_brain_router()
+    build_pulse_proxy()
+    build_echo_proxy()
+    build_api_tester()
+    build_mcp_hub()
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.getenv("PORT", "7860")),
+        share=False,
+        show_error=True,
+    )

fleet_controller.py

@@ -0,0 +1,322 @@
+"""
+🎛️ CAPT Fleet Controller
+Central orchestrator for all CAPT brains and HF spaces.
+"""
+
+import json
+import os
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+import requests
+
+# ─── Configuration ───
+OPENROUTER_KEY = os.getenv("OPENROUTER_API_KEY", "")
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+
+# ─── Brain Registry ───
+BRAINS = {
+    "capt-core-01": {
+        "id": "capt-core-01",
+        "name": "CAPT Core Alpha",
+        "icon": "🧠",
+        "type": "capt",
+        "worker": "https://capt-brain-01.knowurknottty.workers.dev",
+        "pages": "https://edea3345.capt-brain-01-capt-ui.pages.dev",
+        "description": "Primary 46-module cognitive architecture with constitutional governance",
+        "specialties": ["general", "analysis", "reasoning", "constitution"],
+    },
+    "biocapt-core-01": {
+        "id": "biocapt-core-01",
+        "name": "bioCAPT Genesis",
+        "icon": "🧬",
+        "type": "biocapt",
+        "worker": "https://capt-brain-02-biocapt.knowurknottty.workers.dev",
+        "pages": "https://64c3188c.capt-brain-02-biocapt-ui.pages.dev",
+        "description": "Bio-inspired variant with enhanced episodic memory",
+        "specialties": ["memory", "learning", "biomimicry", "adaptation"],
+    },
+    "frankencapt-core-01": {
+        "id": "frankencapt-core-01",
+        "name": "FrankenCAPT Chimera",
+        "icon": "⚗️",
+        "type": "frankencapt",
+        "worker": "https://capt-brain-03-frankencapt.knowurknottty.workers.dev",
+        "pages": "https://2867a361.capt-brain-03-frankencapt-ui.pages.dev",
+        "description": "Modular assembly with variant mixing and skill fusion",
+        "specialties": ["modular", "fusion", "skills", "variants"],
+    },
+    "synthesis-core-01": {
+        "id": "synthesis-core-01",
+        "name": "Synthesis Nexus",
+        "icon": "🔮",
+        "type": "synthesis",
+        "worker": "https://capt-brain-04-synthesis.knowurknottty.workers.dev",
+        "pages": "https://99766389.capt-brain-04-synthesis-ui.pages.dev",
+        "description": "Cross-brain consensus and meta-cognitive orchestration",
+        "specialties": ["consensus", "meta-cognition", "synthesis", "cross-brain"],
+    },
+    "council-core-01": {
+        "id": "council-core-01",
+        "name": "LLM Council",
+        "icon": "🏛️",
+        "type": "council",
+        "worker": "https://capt-brain-05-council.knowurknottty.workers.dev",
+        "pages": "https://551b6882.capt-brain-05-council-ui.pages.dev",
+        "description": "Multi-model deliberation and voting architecture",
+        "specialties": ["voting", "deliberation", "multi-model", "consensus"],
+    },
+}
+
+# ─── HF Space Registry ───
+HF_SPACES = {
+    "knowurknot-capt-wiki": {
+        "name": "CAPT Wiki",
+        "url": "https://knowurknot-capt-wiki.hf.space",
+        "type": "gradio",
+        "status": "degraded",
+        "issue": "Hardcoded local path, empty corpus",
+    },
+    "knowurknot-inversion-labs-biocapt-demo": {
+        "name": "Inversion Labs bioCAPT",
+        "url": "https://knowurknot-inversion-labs-biocapt-demo.hf.space",
+        "type": "gradio",
+        "status": "degraded",
+        "issue": "100% backend failure - engines not shipped",
+    },
+    "knowurknot-biocapt-universal": {
+        "name": "bioCAPT Universal",
+        "url": "https://knowurknot-biocapt-universal.hf.space",
+        "type": "gradio",
+        "status": "degraded",
+        "issue": "Mock-only backend, no real LLM",
+    },
+    "knowurknot-git-hologram": {
+        "name": "Git Hologram",
+        "url": "https://knowurknot-git-hologram.hf.space",
+        "type": "gradio",
+        "status": "working",
+        "issue": "No caching, no bioCAPT integration",
+    },
+    "knowurknot-capt-cognitive-dashboard": {
+        "name": "CAPT Cognitive Dashboard",
+        "url": "https://knowurknot-capt-cognitive-dashboard.hf.space",
+        "type": "gradio",
+        "status": "degraded",
+        "issue": "Mock data only, no live backend",
+    },
+    "knowurknot-inversion-labs-demo": {
+        "name": "Inversion Labs Demo",
+        "url": "https://knowurknot-inversion-labs-demo.hf.space",
+        "type": "gradio",
+        "status": "degraded",
+        "issue": "Exact duplicate of bioCAPT demo",
+    },
+    "knowurknot-capt-cogitate-demo": {
+        "name": "CAPT Cogitate Demo",
+        "url": "https://knowurknot-capt-cogitate-demo.hf.space",
+        "type": "gradio",
+        "status": "degraded",
+        "issue": "CAPT core unreachable, demo mode only",
+    },
+    "knowurknot-space-frankencapt": {
+        "name": "FrankenCAPT",
+        "url": "https://knowurknot-space-frankencapt.hf.space",
+        "type": "gradio",
+        "status": "partial",
+        "issue": "Chatroom backend missing",
+    },
+    "knowurknot-capt-novel-studio": {
+        "name": "CAPT Novel Studio",
+        "url": "https://knowurknot-capt-novel-studio.hf.space",
+        "type": "gradio",
+        "status": "sleeping",
+        "issue": "Asleep, wakes on request",
+    },
+    "knowurknot-karpathy-llm-council": {
+        "name": "Karpathy LLM Council",
+        "url": "https://knowurknot-karpathy-llm-council.hf.space",
+        "type": "gradio",
+        "status": "sleeping",
+        "issue": "Asleep, returns 404 after wake",
+    },
+    "knowurknot-rl-environments-guide": {
+        "name": "RL Environments Guide",
+        "url": "https://knowurknot-rl-environments-guide.hf.space",
+        "type": "gradio",
+        "status": "sleeping",
+        "issue": "Asleep, healthy when awake",
+    },
+    "knowurknot-biocapt-runtime-api": {
+        "name": "bioCAPT Runtime API",
+        "url": "https://knowurknot-biocapt-runtime-api.hf.space",
+        "type": "docker",
+        "status": "private",
+        "issue": "Private Docker space",
+    },
+    "knowurknot-biocapt-vessel": {
+        "name": "bioCAPT Vessel",
+        "url": "",
+        "type": "private",
+        "status": "private",
+        "issue": "No active domain",
+    },
+    "knowurknot-biocapt-vessel-atlas": {
+        "name": "bioCAPT Vessel Atlas",
+        "url": "",
+        "type": "private",
+        "status": "private",
+        "issue": "Template README",
+    },
+    "knowurknot-biocapt-cognitive-world": {
+        "name": "bioCAPT Cognitive World",
+        "url": "",
+        "type": "private",
+        "status": "private",
+        "issue": "Default template",
+    },
+    "knowurknot-tools": {
+        "name": "CAPT Tools",
+        "url": "https://knowurknot-tools.hf.space",
+        "type": "gradio",
+        "status": "running",
+        "issue": "Fixed & reengineered",
+    },
+}
+
+# ─── Brain Router ───
+ROUTING_KEYWORDS = {
+    "capt-core-01": ["general", "analyze", "explain", "what is", "how to", "why", "compare", "constitution", "ethics", "laws"],
+    "biocapt-core-01": ["memory", "remember", "recall", "learn", "adapt", "evolve", "bio", "organic", "neural", "synapse"],
+    "frankencapt-core-01": ["modular", "combine", "fuse", "mix", "variant", "skill", "build", "assemble", "component"],
+    "synthesis-core-01": ["synthesize", "consensus", "vote", "aggregate", "combine brains", "meta", "orchestrate", "coordinate"],
+    "council-core-01": ["council", "vote", "deliberate", "debate", "panel", "jury", "multi-model", "ensemble"],
+}
+
+def route_query(query: str) -> str:
+    """Route a query to the best brain based on keywords."""
+    q = query.lower()
+    scores = {brain_id: 0 for brain_id in BRAINS}
+    for brain_id, keywords in ROUTING_KEYWORDS.items():
+        for kw in keywords:
+            if kw in q:
+                scores[brain_id] += 1
+    best = max(scores, key=scores.get)
+    return best if scores[best] > 0 else "capt-core-01"
+
+# ─── API Callers ───
+def call_brain(brain_id: str, endpoint: str, payload: dict, timeout: int = 60) -> dict:
+    """Call a Cloudflare brain Worker."""
+    brain = BRAINS.get(brain_id)
+    if not brain:
+        return {"error": f"Unknown brain: {brain_id}"}
+    url = f"{brain['worker']}{endpoint}"
+    try:
+        r = requests.post(url, json=payload, timeout=timeout, headers={"Content-Type": "application/json"})
+        return r.json() if r.status_code == 200 else {"error": f"HTTP {r.status_code}", "detail": r.text[:200]}
+    except Exception as e:
+        return {"error": str(e)}
+
+def call_all_brains(endpoint: str, payload: dict) -> dict:
+    """Call all brains in parallel and return consensus."""
+    results = {}
+    for brain_id in BRAINS:
+        results[brain_id] = call_brain(brain_id, endpoint, payload, timeout=30)
+    return results
+
+def check_brain_health(brain_id: str) -> dict:
+    """Check health of a single brain."""
+    brain = BRAINS.get(brain_id)
+    if not brain:
+        return {"status": "unknown", "brain_id": brain_id}
+    try:
+        r = requests.get(f"{brain['worker']}/health", timeout=10)
+        data = r.json() if r.status_code == 200 else {}
+        return {
+            "status": data.get("status", "unknown"),
+            "brain_id": data.get("brain", {}).get("id", brain_id),
+            "name": data.get("brain", {}).get("name", brain["name"]),
+            "latency_ms": int(r.elapsed.total_seconds() * 1000),
+            "online": r.status_code == 200,
+        }
+    except Exception as e:
+        return {"status": "offline", "brain_id": brain_id, "name": brain["name"], "error": str(e), "online": False}
+
+def check_all_brains() -> list[dict]:
+    """Check health of all brains."""
+    return [check_brain_health(bid) for bid in BRAINS]
+
+def check_space_health(space_id: str, space_info: dict) -> dict:
+    """Check health of an HF Space."""
+    url = space_info.get("url", "")
+    if not url:
+        return {"id": space_id, "name": space_info["name"], "status": "no-url", "online": False}
+    try:
+        r = requests.get(url, timeout=15, headers={"User-Agent": "CAPT-Fleet-Controller/1.0"})
+        online = r.status_code in (200, 307, 308)
+        return {
+            "id": space_id,
+            "name": space_info["name"],
+            "status": space_info.get("status", "unknown"),
+            "online": online,
+            "http_code": r.status_code,
+            "latency_ms": int(r.elapsed.total_seconds() * 1000),
+        }
+    except Exception as e:
+        return {
+            "id": space_id,
+            "name": space_info["name"],
+            "status": space_info.get("status", "unknown"),
+            "online": False,
+            "error": str(e),
+        }
+
+def check_all_spaces() -> list[dict]:
+    """Check health of all HF spaces."""
+    return [check_space_health(sid, sinfo) for sid, sinfo in HF_SPACES.items()]
+
+# ─── Model Tiers (for PULSE proxy) ───
+MODEL_TIERS = {
+    "free": [
+        ("deepseek/deepseek-chat-v3-0324", "DeepSeek V3"),
+        ("google/gemini-2.0-flash-exp:free", "Gemini 2.0 Flash (Free)"),
+        ("meta-llama/llama-3.1-8b-instruct:free", "Llama 3.1 8B"),
+    ],
+    "super-cheap": [
+        ("openai/gpt-4o-mini", "GPT-4o Mini"),
+        ("google/gemini-flash-1.5", "Gemini 1.5 Flash"),
+        ("anthropic/claude-3-haiku", "Claude 3 Haiku"),
+        ("mistralai/mistral-small", "Mistral Small"),
+    ],
+    "cheap": [
+        ("anthropic/claude-3.5-sonnet", "Claude 3.5 Sonnet"),
+        ("openai/gpt-4o", "GPT-4o"),
+        ("google/gemini-1.5-pro", "Gemini 1.5 Pro"),
+        ("meta-llama/llama-3.1-405b-instruct", "Llama 3.1 405B"),
+    ],
+    "medium": [
+        ("anthropic/claude-3-opus", "Claude 3 Opus"),
+        ("openai/gpt-4-turbo", "GPT-4 Turbo"),
+        ("x-ai/grok-2", "Grok 2"),
+    ],
+    "too-damn-high": [
+        ("openai/o1-preview", "o1 Preview"),
+        ("openai/o1-mini", "o1 Mini"),
+    ],
+}
+
+TIER_LABELS = {
+    "free": "🆓 Free",
+    "super-cheap": "💚 Super Cheap",
+    "cheap": "💛 Cheap",
+    "medium": "🧡 Medium",
+    "too-damn-high": "💎 Too Damn High",
+}
+
+def get_all_models():
+    models = []
+    for tier, items in MODEL_TIERS.items():
+        for model_id, name in items:
+            models.append((f"{TIER_LABELS[tier]}: {name}", model_id))
+    return models

requirements.txt

@@ -0,0 +1,3 @@
+gradio[mcp]==6.2.0
+requests
+pandas