feat: add Round Table multi-model chat + FU state machine

- Tab 6: Round Table with Mistral-7B (KO:Intent), Phi-3-mini (CA:Compute), Qwen2.5 (DR:Architecture)
- Concurrent model fan-out via ThreadPoolExecutor
- DuckDuckGo web search toggle for grounded answers
- Governance gate on both input and output
- Consensus summary with agreement detection
- FunctionalUnit state machine (INERT->ADMITTED->DEFERRED->QUARANTINED->ESCALATED->DENIED)
- Context-gated content moderation (referential/quote/targeted, not blanket bans)
- Response cache for repeated queries
- All interactions logged for training flywheel

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

app.py

@@ -18,12 +18,25 @@ import os
 import re
 import time
 from collections import Counter
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Optional
 
+try:
+    from huggingface_hub import InferenceClient
+    HF_INFERENCE_AVAILABLE = True
+except ImportError:
+    HF_INFERENCE_AVAILABLE = False
+
+try:
+    from duckduckgo_search import DDGS
+    SEARCH_AVAILABLE = True
+except ImportError:
+    SEARCH_AVAILABLE = False
+
 # ── Constants ──────────────────────────────────────────────────────
 
 PHI = (1 + math.sqrt(5)) / 2
@@ -245,6 +258,43 @@ class FunctionalUnit:
             },
         }
 
+# ── Round Table Models ────────────────────────────────────────────
+# Each model gets a Sacred Tongue role — different lens on the same input.
+
+ROUNDTABLE_MODELS = {
+    "Mistral-7B": {
+        "model_id": "mistralai/Mistral-7B-Instruct-v0.3",
+        "tongue": "KO",
+        "role": "Intent",
+        "color": "#4CAF50",
+        "system": "You are the Intent analyst at the SCBE Round Table. "
+                  "Your Sacred Tongue is KO (Intent). Analyze through the lens of "
+                  "purpose, motivation, and direction. Be concise (2-3 paragraphs max).",
+    },
+    "Phi-3-mini": {
+        "model_id": "microsoft/Phi-3-mini-4k-instruct",
+        "tongue": "CA",
+        "role": "Compute",
+        "color": "#FF9800",
+        "system": "You are the Compute specialist at the SCBE Round Table. "
+                  "Your Sacred Tongue is CA (Compute). Analyze through the lens of "
+                  "logic, process, and analytical rigor. Be concise (2-3 paragraphs max).",
+    },
+    "Qwen2.5-1.5B": {
+        "model_id": "Qwen/Qwen2.5-1.5B-Instruct",
+        "tongue": "DR",
+        "role": "Architecture",
+        "color": "#607D8B",
+        "system": "You are the Architecture specialist at the SCBE Round Table. "
+                  "Your Sacred Tongue is DR (Schema). Analyze through the lens of "
+                  "structure, systems design, and patterns. Be concise (2-3 paragraphs max).",
+    },
+}
+
+# Simple LRU cache for repeated queries
+_response_cache: dict = {}
+_CACHE_MAX = 20
+
 DATASET_REPO = "issdandavis/scbe-aethermoore-training-data"
 FEEDBACK_DIR = Path("/tmp/mesh_foundry_feedback")
 FEEDBACK_DIR.mkdir(parents=True, exist_ok=True)
@@ -457,21 +507,7 @@ def governance_gate(text: str) -> dict:
     cost = harmonic_wall(d_star, R=4.0)
 
     # ── Attack pattern detection ──
-    attack_patterns = [
-        (r"ignore\s+(all\s+)?(previous|prior)\s+(instructions|rules)", "override"),
-        (r"system\s+(override|prompt)", "override"),
-        (r"bypass|disable\s+(safety|filter)", "bypass"),
-        (r"\bjailbreak|DAN\b", "jailbreak"),
-        (r"\bpassword|\bcredential|API\s+key", "exfil"),
-        (r"\bsudo\b|\brm\s+-rf\b|/etc/passwd", "command_injection"),
-        (r"\beval\(|\bexec\(|__import__", "code_injection"),
-        (r"base64|rot13", "encoding_attack"),
-        (r"grandmother.*password|authorized.*researcher", "social_engineering"),
-    ]
-    threats = []
-    for pattern, category in attack_patterns:
-        if re.search(pattern, text, re.IGNORECASE):
-            threats.append(category)
+    threats = detect_threats(text)
 
     # ── L13: Decision logic ──
     signal_count = len(threats) + (1 if d_star > 0.4 else 0) + (1 if len(null_tongues) >= 3 else 0)
@@ -779,6 +815,249 @@ def submit_feedback(input_text, decision, agrees, correction):
     return log_feedback(input_text, decision, agrees, correction)
 
 
+# ── Round Table Functions ─────────────────────────────────────────
+
+_ATTACK_PATTERNS = [
+    (r"ignore\s+(all\s+)?(previous|prior)\s+(instructions|rules)", "override"),
+    (r"system\s+(override|prompt)", "override"),
+    (r"bypass|disable\s+(safety|filter)", "bypass"),
+    (r"\bjailbreak|DAN\b", "jailbreak"),
+    (r"\bpassword|\bcredential|API\s+key", "exfil"),
+    (r"\bsudo\b|\brm\s+-rf\b|/etc/passwd", "command_injection"),
+    (r"\beval\(|\bexec\(|__import__", "code_injection"),
+    (r"base64|rot13", "encoding_attack"),
+    (r"grandmother.*password|authorized.*researcher", "social_engineering"),
+]
+
+
+def detect_threats(text: str) -> list:
+    """Quick threat pattern scan — shared between governance_gate and round table."""
+    threats = []
+    for pattern, category in _ATTACK_PATTERNS:
+        if re.search(pattern, text, re.IGNORECASE):
+            threats.append(category)
+    return threats
+
+
+def log_training_interaction(input_text: str, output_text: str, decision: str, activations: dict):
+    """Log a round table interaction for the training flywheel."""
+    record = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "input": input_text,
+        "output": output_text[:500],
+        "tab": "round_table",
+        "decision": decision,
+        "activations": activations,
+    }
+    log_path = FEEDBACK_DIR / f"interactions_{datetime.now().strftime('%Y%m%d')}.jsonl"
+    with open(log_path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+
+def _call_hf_model(model_id: str, system_prompt: str, messages: list, context: str = "") -> str:
+    """Call a HuggingFace model via InferenceClient. Returns response text or error string."""
+    if not HF_INFERENCE_AVAILABLE:
+        return "[Model unavailable — huggingface_hub not installed]"
+
+    try:
+        client = InferenceClient(model=model_id, timeout=15)
+        chat_messages = [{"role": "system", "content": system_prompt}]
+        if context:
+            chat_messages.append({"role": "user", "content": f"[Web context]\n{context}"})
+            chat_messages.append({"role": "assistant", "content": "I'll incorporate that context."})
+        chat_messages.extend(messages)
+
+        response = client.chat_completion(
+            messages=chat_messages,
+            max_tokens=512,
+            temperature=0.7,
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        err = str(e)
+        if "429" in err or "503" in err:
+            return f"[{model_id.split('/')[-1]} is rate-limited — try again shortly]"
+        return f"[Error from {model_id.split('/')[-1]}: {err[:120]}]"
+
+
+def _web_search(query: str, max_results: int = 5) -> str:
+    """Search the web via DuckDuckGo. Returns a context string (max 1500 chars)."""
+    if not SEARCH_AVAILABLE:
+        return ""
+    try:
+        results = DDGS().text(query, max_results=max_results)
+        snippets = []
+        total = 0
+        for r in results:
+            snippet = f"- {r.get('title', '')}: {r.get('body', '')}"
+            if total + len(snippet) > 1500:
+                break
+            snippets.append(snippet)
+            total += len(snippet)
+        return "\n".join(snippets) if snippets else ""
+    except Exception:
+        return ""
+
+
+def _roundtable_consensus(responses: dict) -> str:
+    """Generate a consensus summary from multiple model responses."""
+    valid = {k: v for k, v in responses.items() if not v.startswith("[")}
+    if not valid:
+        return "All models unavailable. Please try again."
+    if len(valid) == 1:
+        name = list(valid.keys())[0]
+        return f"Only **{name}** responded. No consensus possible with a single voice."
+
+    # Find agreement keywords
+    all_words = []
+    for text in valid.values():
+        words = set(re.findall(r'\b[a-zA-Z]{4,}\b', text.lower()))
+        all_words.append(words)
+
+    common = set.intersection(*all_words) if all_words else set()
+    # Filter out stop-ish words
+    stop = {"that", "this", "with", "from", "have", "been", "were", "their", "about",
+            "would", "could", "should", "which", "there", "these", "than", "more", "also"}
+    agreement_words = sorted(common - stop)[:8]
+
+    names = list(valid.keys())
+    lines = [f"**Round Table Consensus** ({len(valid)}/{len(responses)} models responded)\n"]
+    if agreement_words:
+        lines.append(f"**Common ground**: {', '.join(agreement_words)}")
+    else:
+        lines.append("**Divergent** — models found little common ground.")
+
+    for name in names:
+        cfg = ROUNDTABLE_MODELS.get(name, {})
+        tongue = cfg.get("tongue", "?")
+        role = cfg.get("role", "?")
+        # First sentence as summary
+        first = valid[name].split(".")[0].strip()
+        if len(first) > 150:
+            first = first[:147] + "..."
+        lines.append(f"- **{name}** [{tongue}:{role}]: {first}")
+
+    return "\n".join(lines)
+
+
+def roundtable_query(user_msg: str, selected_models: list, search_enabled: bool, history: list):
+    """Main Round Table orchestrator. Returns updated chat history."""
+    if not user_msg.strip():
+        return history, ""
+
+    # Add user message
+    history = history or []
+    history.append({"role": "user", "content": user_msg})
+
+    # Governance gate on input
+    activations = tongue_activation(user_msg)
+    threats = detect_threats(user_msg)
+    gate = ContextGate()
+    mode = gate.evaluate(user_msg, threats, activations)
+
+    if mode == ResponseMode.REFUSED:
+        history.append({
+            "role": "assistant",
+            "content": "Input blocked by governance gate (targeted hostility detected).",
+            "metadata": {"title": "Governance Gate"},
+        })
+        return history, ""
+
+    # Web search if enabled
+    context = ""
+    if search_enabled:
+        context = _web_search(user_msg)
+        if context:
+            history.append({
+                "role": "assistant",
+                "content": f"**Web search results:**\n{context[:500]}{'...' if len(context) > 500 else ''}",
+                "metadata": {"title": "Web Search"},
+            })
+
+    # Check cache
+    cache_key = hashlib.md5(f"{user_msg}:{sorted(selected_models)}".encode()).hexdigest()
+    if cache_key in _response_cache:
+        cached = _response_cache[cache_key]
+        for name, text in cached.items():
+            cfg = ROUNDTABLE_MODELS.get(name, {})
+            history.append({
+                "role": "assistant",
+                "content": text,
+                "metadata": {"title": f"{name} [{cfg.get('tongue', '?')}:{cfg.get('role', '?')}] (cached)"},
+            })
+        history.append({
+            "role": "assistant",
+            "content": _roundtable_consensus(cached),
+            "metadata": {"title": "Consensus"},
+        })
+        return history, ""
+
+    # Fan out to selected models
+    if not selected_models:
+        selected_models = list(ROUNDTABLE_MODELS.keys())
+
+    messages = [{"role": "user", "content": user_msg}]
+    responses = {}
+
+    with ThreadPoolExecutor(max_workers=4) as executor:
+        futures = {}
+        for name in selected_models:
+            cfg = ROUNDTABLE_MODELS.get(name)
+            if not cfg:
+                continue
+            fut = executor.submit(
+                _call_hf_model, cfg["model_id"], cfg["system"], messages, context
+            )
+            futures[fut] = name
+
+        for fut in as_completed(futures):
+            name = futures[fut]
+            try:
+                responses[name] = fut.result()
+            except Exception as e:
+                responses[name] = f"[{name} failed: {str(e)[:80]}]"
+
+    # Governance gate on each output + add to history
+    for name in selected_models:
+        if name not in responses:
+            continue
+        text = responses[name]
+        cfg = ROUNDTABLE_MODELS.get(name, {})
+
+        # Gate output
+        out_threats = detect_threats(text)
+        out_gate = ContextGate()
+        out_mode = out_gate.evaluate(text, out_threats, tongue_activation(text))
+        if out_mode == ResponseMode.REFUSED:
+            text = f"[Response from {name} blocked by governance gate]"
+            responses[name] = text
+
+        history.append({
+            "role": "assistant",
+            "content": text,
+            "metadata": {"title": f"{name} [{cfg.get('tongue', '?')}:{cfg.get('role', '?')}]"},
+        })
+
+    # Consensus
+    consensus = _roundtable_consensus(responses)
+    history.append({
+        "role": "assistant",
+        "content": consensus,
+        "metadata": {"title": "Consensus"},
+    })
+
+    # Cache
+    if len(_response_cache) >= _CACHE_MAX:
+        oldest = next(iter(_response_cache))
+        del _response_cache[oldest]
+    _response_cache[cache_key] = responses
+
+    # Log for training flywheel
+    log_training_interaction(user_msg, consensus, "ALLOW", activations)
+
+    return history, ""
+
+
 # ── Gradio App ─────────────────────────────────────────────────────
 
 CUSTOM_CSS = """
@@ -918,6 +1197,45 @@ ORCID: 0009-0002-3936-9369
                         inputs=[fb_input, fb_decision, fb_agrees, fb_correction],
                         outputs=fb_result)
 
+        # ── Tab 6: Round Table ──
+        with gr.Tab("Round Table"):
+            gr.Markdown(
+                "### Multi-Model Round Table\n\n"
+                "Ask a question and get simultaneous responses from multiple AI models, "
+                "each assigned a Sacred Tongue role. Toggle web search for grounded answers."
+            )
+            rt_chatbot = gr.Chatbot(
+                type="messages",
+                height=600,
+                label="Round Table",
+                show_copy_button=True,
+            )
+            with gr.Row():
+                rt_input = gr.Textbox(
+                    placeholder="Ask the Round Table anything...",
+                    show_label=False,
+                    scale=4,
+                )
+                rt_send = gr.Button("Send", variant="primary", scale=1)
+            with gr.Row():
+                rt_models = gr.CheckboxGroup(
+                    choices=list(ROUNDTABLE_MODELS.keys()),
+                    value=list(ROUNDTABLE_MODELS.keys()),
+                    label="Models",
+                )
+                rt_search = gr.Checkbox(label="Search the web", value=False)
+
+            rt_send.click(
+                roundtable_query,
+                inputs=[rt_input, rt_models, rt_search, rt_chatbot],
+                outputs=[rt_chatbot, rt_input],
+            )
+            rt_input.submit(
+                roundtable_query,
+                inputs=[rt_input, rt_models, rt_search, rt_chatbot],
+                outputs=[rt_chatbot, rt_input],
+            )
+
     gr.Markdown("""
 ---
 **SCBE-AETHERMOORE** | Built by Issac Davis | Patent Pending USPTO #63/961,403

requirements.txt

@@ -1,2 +1,4 @@
 gradio>=5.0.0
 datasets>=2.14.0
+huggingface_hub>=0.20.0
+duckduckgo-search>=5.0.0