Build CCAI Vibe Demo on top of LLMChats3 baseline

Multi-participant Collaborative Conversational AI demo: the orchestrator
runs a six-phase state machine (Initial Opinions, Critique x2, Status
Assessment, Finalization, Consensus, Closure), produces a JSON
Credential Summary keyed on credibility-for-question, and routes
addressed-to messages through alliance detection. Two failsafes - 60+20
participant messages and 100+50 orchestrator calls - pause the loop
until the user clicks Continue. Every LLM response is funneled through
a centralized strip_thinking sanitizer before being stored, displayed,
or fed back to the summarizer.

Backend
- New: services/{models,prompts/*,credential,consensus,context_budget,
json_calls,extra_personas,orchestrator}.py, utils/sanitize.py,
api/personas.py, data/demo_questions.json (10 long-context prompts).
- Rewrote api/chat.py with /chat/start (N participants, summarizer +
max-participants overrides), /chat/{id}/continue, table-view +
csv-table exports.
- Rate limit bumped to 30/day per IP; HF org bypass kept.
- Sanitizer wired into both OpenAI-compat and HANA paths.

Frontend
- New: Header, ParticipantDropdown (Neon / Extra / Expert + Create...),
ParticipantSidebar (slider on/off, Remove when off, accordion),
ExpertPersonaModal (tabbed Structured/Freeform + role-style),
ChatTableView, OrchestratorMessage, FailsafePauseBanner, storage.js.
- DevMenu rewritten: orchestrator + summarizer pickers (summarizer
defaults to "Same as Orchestrator"), 3-9 max-participants stepper,
per-participant model assignment, table + CSV download buttons.
- localStorage namespace 'ccai-vibe-demo' for personas, selections,
enabled state, model assignments, theme, etc.
- Removed dead LLMSelector / PersonaAccordion / ExportBar.

Infra
- docker-compose.yml port 7860:7860 to match HF Space.
- README rewritten for CCAI architecture, secrets, and HF deployment.
- Pytest suite: 32 tests (sanitize, CSV escaping, tolerant JSON parser,
context-budget thresholds) - all passing.

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitignore

@@ -9,3 +9,4 @@ dist/
 .venv/
 venv/
 *.log
+.commit-msg.txt

README.md

@@ -1,6 +1,6 @@
 ---
-title: AI Conversations
-emoji: 💬
+title: CCAI Vibe Demo
+emoji: 🤝
 colorFrom: blue
 colorTo: purple
 sdk: docker
@@ -11,23 +11,72 @@ hf_oauth_scopes:
 pinned: false
 ---
 
-# AI Conversations (LLMChats3)
+# CCAI Vibe Demo
 
-A web app that lets two LLMs have a natural conversation. Select two LLMs, configure their personas, and watch them chat — complete with an orchestrator that manages natural conversation endings.
+A demo of **Collaborative Conversational AI (CCAI)** - Neon.ai's patented
+group-discussion technology. Up to 9 participants (any mix of AI personas,
+human-defined "expert" personas, or - in the future - real humans, agents,
+tools, or sensors) hold a structured group conversation facilitated by a
+neutral **Orchestrator**, with the goal of reaching a real group decision
+the way a thoughtful human meeting would.
+
+This repo descends from
+[NeonClary/LLMChats3](https://github.com/NeonClary/LLMChats3) and reuses
+its color scheme, branding, settings menu structure, and chat formatting
+verbatim. The CCAI multi-participant orchestration, expert-persona modal,
+participant sidebar, and table view are layered on top.
+
+## Architecture (one-pager)
+
+- **Frontend** (React 19, react-markdown, lucide-react) - lives in
+  `frontend/`. Talks SSE to the backend.
+- **Backend** (FastAPI, httpx) - lives in `backend/`. Routes:
+  - `GET /api/personas` — Neon HANA personas (vanilla/RAG filtered),
+    bundled extra personas, and (echoed) expert personas.
+  - `GET /api/demo-questions` — the bank of 10 long-context demo prompts.
+  - `POST /api/chat/start` — kicks off a CCAI session and returns SSE.
+  - `POST /api/chat/{id}/continue?reason=…` — resumes a paused session.
+  - `GET  /api/chat/{id}/export?fmt=txt|md|csv-table` — exports.
+  - `GET  /api/chat/{id}/table` — JSON for the table view.
+- **Orchestrator state machine** — six phases (Initial Opinions,
+  Critique x2, Status Assessment, Finalization, Consensus, Closure)
+  with two failsafes (60+20 messages, 100+50 orchestrator calls) and
+  per-participant on-demand context summarization.
+
+## CCAI Phase Overview
+
+1. **Initial Opinions.** Each participant offers an independent first
+   opinion. The orchestrator builds a per-participant **Credential
+   Summary** in the background.
+2. **Critique x 2.** Each participant gets two turns to critique
+   others, ask follow-ups, and revise. After Phase 2 the Credential
+   Summary is refreshed.
+3. **Status Assessment.** The orchestrator either proceeds or runs
+   targeted follow-ups (max 3 iterations).
+4. **Finalization.** Each participant either revises their own opinion
+   or endorses another's.
+5. **Consensus Gathering.** Allied participants advocate, solo
+   participants seek allies / switch / propose compromises. The
+   orchestrator routes addressed-to messages.
+6. **Closure.** Majority-report (with weighted dissent), or
+   unaddressed-factor probe + retry, or no-consensus report.
+
+Thinking traces (`<think>`, `<reasoning>`, etc.) are stripped from every
+LLM response in `backend/app/utils/sanitize.py` before being stored,
+displayed, or fed back to the orchestrator/summarizer/Credential builder.
 
 ## Quick Start (local development)
 
 ```bash
-# 1. Clone and set up environment
 cp .env.example .env
 # Edit .env with your API keys
 
-# 2. Backend
+# Backend
 cd backend
 pip install -r requirements.txt
 uvicorn app.main:app --reload --port 8000
 
-# 3. Frontend (in a separate terminal)
+# Frontend (separate terminal)
 cd frontend
 npm install
 npm start
@@ -39,20 +88,41 @@ npm start
 cp .env.example .env
 # Edit .env with your API keys
 docker compose up --build
+# Open http://localhost:7860
 ```
 
 ## HuggingFace Spaces Deployment
 
-This app is deployed as a Docker Space at [neongeckocom/AI_Conversations](https://huggingface.co/spaces/neongeckocom/AI_Conversations). API keys are stored as Space Secrets.
+Deployed as a Docker Space (`app_port: 7860`).
+
+Required Space Secrets:
 
-Rate limiting: 20 conversations/day per IP for anonymous users. Sign in with HuggingFace as a neongeckocom org member for unlimited access.
+- `HANA_USERNAME`, `HANA_PASSWORD` — Neon HANA credentials.
+- `HANA_KLATCHAT_PASSWORD` (optional) — BrainForge/Security vLLM access.
+- Provider keys: `OPENAI_API_KEY`, `GEMINI_API_KEY`, `FIREWORKS_API_KEY`,
+  `TOGETHER_API_KEY`, `MISTRAL_API_KEY`.
+- `HF_RATE_LIMIT_DAILY=30` — daily per-IP cap (defaults to 30; org
+  members are unlimited).
+- `HF_RATE_LIMIT_ORG=neongeckocom` — bypass org name.
+- `SESSION_SECRET` — cookie session secret for OAuth.
 
 ## Features
 
-- Select any two LLMs from multiple providers (OpenAI, Gemini, Fireworks, Together, Neon)
-- Configure rich personas with names, profiles, identity prompts, and writing samples
-- Structured or freeform persona input modes with file upload support
-- Watch LLMs converse naturally with an orchestrator managing conversation flow
-- Automatic conversation ending detection with graceful wrap-up
-- Export chats as .txt or .md, plus full API logs for developers
-- HuggingFace OAuth integration with org-based rate limiting
+- **Participant dropdown** in the header with three sections (Neon /
+  Extra / Expert) and a `Create Expert Persona...` shortcut.
+- **Participant sidebar** with on/off slider per participant; flipping
+  off does not deselect, and a `Remove` button appears for actually
+  dropping someone from the conversation.
+- **Settings menu** with searchable orchestrator-model and summarizer-
+  model pickers (summarizer defaults to "Same as Orchestrator"),
+  a 3-9 max-participants stepper, per-participant model overrides, and
+  the same display-options + downloads structure as LLMChats3.
+- **Two failsafes** with explicit Continue buttons (60+20 messages,
+  100+50 orchestrator calls).
+- **Exports**: `.txt`, `.md`, RFC-4180 `.csv` table, JSON API log.
+- **Table view** of the whole conversation with per-participant first /
+  contribution / revised / final columns.
+- **localStorage persistence** for expert personas, participant
+  selection, on/off state, model assignments, orchestrator/summarizer
+  picks, and max-participants.
+- **HuggingFace OAuth** with `neongeckocom` org bypass.

backend/app/api/chat.py

@@ -1,17 +1,41 @@
+"""Chat API: start a CCAI conversation, stream SSE, drive failsafe-pause
+continues, and export results.
+"""
 from __future__ import annotations
 
+import csv
+import io
 import json
 import logging
 import time
 
 from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import StreamingResponse, JSONResponse
-from pydantic import BaseModel
+from fastapi.responses import JSONResponse, StreamingResponse
+from pydantic import BaseModel, Field
 
 from app.config import settings
-from app.services.persona import generate_role_prompt, generate_role_prompt_freeform
+from app.middleware.rate_limit import (
+    DAILY_LIMIT,
+    check_rate_limit,
+    record_conversation,
+)
+from app.services.extra_personas import get_extra_persona
+from app.services.models import (
+    DEFAULT_MAX_PARTICIPANTS,
+    MAX_MAX_PARTICIPANTS,
+    MIN_MAX_PARTICIPANTS,
+    Participant,
+    Phase,
+    Session,
+)
 from app.services.orchestrator import (
-    Session, Persona, create_session, get_session, run_conversation,
+    create_session,
+    get_session,
+    run_conversation,
+)
+from app.services.persona import (
+    generate_role_prompt,
+    generate_role_prompt_freeform,
 )
 
 router = APIRouter()
@@ -46,20 +70,43 @@ class SetSpeedPriorityRequest(BaseModel):
     enabled: bool
 
 
+class ExpertPersonaPayload(BaseModel):
+    """Expert Persona created by the user via the popup. Already carries a
+    finished `role_prompt` (the frontend calls /generate-role-* for that)."""
+
+    participant_id: str
+    name: str
+    model_id: str
+    role_prompt: str
+
+
+class ParticipantSelectionPayload(BaseModel):
+    """Reference to a participant the user has chosen for this conversation."""
+
+    participant_id: str
+    kind: str  # "neon" | "extra" | "expert"
+    # For Neon entries: the model_id IS the persona id (neon:model@ver:persona)
+    # For extra/expert: defaults to the persona's bound model_id, but the
+    # user can override via per-participant model_assignments.
+    name: str
+    role_prompt: str | None = None
+    model_id_override: str | None = None
+
+
 class StartChatRequest(BaseModel):
-    persona_a_model_id: str
-    persona_a_name: str
-    persona_a_role: str
+    question: str | None = None
 
-    persona_b_model_id: str
-    persona_b_name: str
-    persona_b_role: str
+    participants: list[ParticipantSelectionPayload]
+    expert_personas: list[ExpertPersonaPayload] = Field(default_factory=list)
+    model_assignments: dict[str, str] = Field(default_factory=dict)
 
-    starter_text: str | None = None
+    orchestrator_model_id: str | None = None
+    summarizer_model_id: str | None = None
+    max_participants: int = DEFAULT_MAX_PARTICIPANTS
 
 
 # ---------------------------------------------------------------------------
-# Endpoints
+# Settings endpoints (orchestrator default + speed priority)
 # ---------------------------------------------------------------------------
 
 @router.get("/chat/orchestrator")
@@ -84,6 +131,10 @@ async def api_set_speed_priority(req: SetSpeedPriorityRequest):
     return {"enabled": settings.speed_priority}
 
 
+# ---------------------------------------------------------------------------
+# Role-prompt generation (used by the Expert Persona modal)
+# ---------------------------------------------------------------------------
+
 @router.post("/chat/generate-role")
 async def api_generate_role(req: GenerateRoleRequest):
     result = await generate_role_prompt(
@@ -112,68 +163,195 @@ async def api_generate_role_freeform(req: GenerateRoleFreeformRequest):
     return result
 
 
+# ---------------------------------------------------------------------------
+# Demo questions
+# ---------------------------------------------------------------------------
+
+@router.get("/demo-questions")
+async def api_demo_questions():
+    from pathlib import Path
+
+    path = Path(__file__).resolve().parent.parent / "data" / "demo_questions.json"
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return data
+
+
+# ---------------------------------------------------------------------------
+# Start chat
+# ---------------------------------------------------------------------------
+
+def _build_participant(
+    sel: ParticipantSelectionPayload,
+    expert_lookup: dict[str, ExpertPersonaPayload],
+    model_assignments: dict[str, str],
+) -> Participant:
+    """Resolve a selection payload into a runnable Participant.
+
+    Resolution order for the model:
+      1. Explicit per-conversation override in `model_assignments`
+      2. The persona's selection-time `model_id_override`
+      3. The bundled extra persona's default model
+      4. For Neon participants, the model_id is the participant_id itself
+      5. For Expert personas, the persona's bound model_id
+
+    Resolution order for the role_prompt:
+      1. The selection's role_prompt (most flexible)
+      2. The matching expert persona's role_prompt
+      3. The bundled extra persona's role_prompt
+      4. For Neon participants: a thin role wrapper just naming the persona
+    """
+    pid = sel.participant_id
+    kind = sel.kind
+    name = sel.name
+
+    role_prompt = sel.role_prompt or ""
+    model_id = sel.model_id_override or model_assignments.get(pid, "")
+
+    if kind == "expert":
+        ep = expert_lookup.get(pid)
+        if ep is None:
+            raise HTTPException(400, f"Expert persona payload missing for id {pid}")
+        if not role_prompt:
+            role_prompt = ep.role_prompt
+        if not model_id:
+            model_id = ep.model_id
+        if not name:
+            name = ep.name
+    elif kind == "extra":
+        ep = get_extra_persona(pid)
+        if ep is None:
+            raise HTTPException(400, f"Unknown extra persona: {pid}")
+        if not role_prompt:
+            role_prompt = ep.role_prompt
+        if not model_id:
+            model_id = ep.default_model_id
+        if not name:
+            name = ep.name
+    elif kind == "neon":
+        # The participant_id IS the model id for Neon personas, so it's
+        # required to be a `neon:model@ver:persona` style string.
+        if not pid.startswith("neon:"):
+            raise HTTPException(
+                400, f"Neon participant_id must start with 'neon:': {pid}",
+            )
+        if not model_id:
+            model_id = pid
+        if not role_prompt:
+            role_prompt = (
+                f"You are {name}, a Neon.ai persona. Speak naturally in your "
+                "own voice and bring the perspective your background suggests."
+            )
+    else:
+        raise HTTPException(400, f"Unknown participant kind: {kind}")
+
+    resolved = settings.resolve_model(model_id)
+    if not resolved:
+        raise HTTPException(400, f"Unknown model: {model_id}")
+
+    return Participant(
+        participant_id=pid,
+        name=name,
+        role_prompt=role_prompt,
+        model_id=resolved["model_id"],
+        kind=kind,
+        enabled=True,
+        base_url=resolved.get("base_url", ""),
+        api_key=resolved.get("api_key", ""),
+        display_name=resolved.get("display_name", model_id),
+        is_neon=resolved.get("is_neon", False),
+        hana_model_id=resolved.get("hana_model_id", ""),
+        persona_name=resolved.get("persona_name", ""),
+        neon_direct_vllm=resolved.get("neon_direct_vllm", False),
+        vllm_base_url=resolved.get("vllm_base_url", ""),
+        vllm_api_key=resolved.get("vllm_api_key", ""),
+    )
+
+
 @router.post("/chat/start")
 async def api_start_chat(req: StartChatRequest, request: Request):
     """Create a session and return a streaming SSE response for the conversation."""
-    from app.middleware.rate_limit import check_rate_limit, record_conversation
+    if not req.question or not req.question.strip():
+        raise HTTPException(400, "Question is required")
 
-    allowed, remaining = check_rate_limit(request)
+    allowed, _ = check_rate_limit(request)
     if not allowed:
         return JSONResponse(
             status_code=429,
             content={
-                "detail": "Daily conversation limit reached (20/day). Sign in with HuggingFace as a neongeckocom org member for unlimited access.",
+                "detail": (
+                    f"Daily conversation limit reached ({DAILY_LIMIT}/day). "
+                    "Sign in with HuggingFace as a neongeckocom org member "
+                    "for unlimited access."
+                ),
                 "remaining": 0,
             },
         )
-    record_conversation(request)
 
-    ra = settings.resolve_model(req.persona_a_model_id)
-    rb = settings.resolve_model(req.persona_b_model_id)
+    expert_lookup = {ep.participant_id: ep for ep in req.expert_personas}
+
+    max_p = max(MIN_MAX_PARTICIPANTS, min(MAX_MAX_PARTICIPANTS, req.max_participants))
+    if len(req.participants) < 2:
+        raise HTTPException(400, "Need at least 2 participants")
+    if len(req.participants) > max_p:
+        raise HTTPException(
+            400, f"Got {len(req.participants)} participants but max is {max_p}",
+        )
 
-    if not ra:
-        raise HTTPException(400, f"Unknown model: {req.persona_a_model_id}")
-    if not rb:
-        raise HTTPException(400, f"Unknown model: {req.persona_b_model_id}")
+    participants: list[Participant] = []
+    for sel in req.participants:
+        participants.append(_build_participant(sel, expert_lookup, req.model_assignments))
+
+    record_conversation(request)
 
     session = create_session()
-    session.persona_a = Persona(
-        name=req.persona_a_name or "Persona A",
-        model_id=ra["model_id"],
-        role_prompt=req.persona_a_role,
-        base_url=ra.get("base_url", ""),
-        api_key=ra.get("api_key", ""),
-        display_name=ra["display_name"],
-        is_neon=ra.get("is_neon", False),
-        hana_model_id=ra.get("hana_model_id", ""),
-        persona_name=ra.get("persona_name", ""),
-        neon_direct_vllm=ra.get("neon_direct_vllm", False),
-        vllm_base_url=ra.get("vllm_base_url", ""),
-        vllm_api_key=ra.get("vllm_api_key", ""),
-    )
-    session.persona_b = Persona(
-        name=req.persona_b_name or "Persona B",
-        model_id=rb["model_id"],
-        role_prompt=req.persona_b_role,
-        base_url=rb.get("base_url", ""),
-        api_key=rb.get("api_key", ""),
-        display_name=rb["display_name"],
-        is_neon=rb.get("is_neon", False),
-        hana_model_id=rb.get("hana_model_id", ""),
-        persona_name=rb.get("persona_name", ""),
-        neon_direct_vllm=rb.get("neon_direct_vllm", False),
-        vllm_base_url=rb.get("vllm_base_url", ""),
-        vllm_api_key=rb.get("vllm_api_key", ""),
-    )
+    session.question = req.question.strip()
+    session.participants = participants
+    session.orchestrator_model_id = req.orchestrator_model_id
+    session.summarizer_model_id = req.summarizer_model_id
+    session.max_participants = max_p
 
     async def event_stream():
-        yield f"event: session\ndata: {json.dumps({'session_id': session.session_id})}\n\n"
-        async for chunk in run_conversation(session, req.starter_text):
+        yield (
+            "event: session\ndata: "
+            + json.dumps({
+                "session_id": session.session_id,
+                "participants": [
+                    {
+                        "participant_id": p.participant_id,
+                        "name": p.name,
+                        "model_id": p.model_id,
+                        "model_display": p.display_name,
+                        "kind": p.kind,
+                    } for p in session.participants
+                ],
+                "max_participants": session.max_participants,
+                "orchestrator_model_id": session.orchestrator_model_id or settings.orchestrator_model,
+                "summarizer_model_id": session.summarizer_model_id,
+            })
+            + "\n\n"
+        )
+        async for chunk in run_conversation(session):
             yield chunk
 
     return StreamingResponse(event_stream(), media_type="text/event-stream")
 
 
+@router.post("/chat/{session_id}/continue")
+async def api_continue(session_id: str, reason: str = "messages"):
+    session = get_session(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    if not session.paused_for_continue:
+        raise HTTPException(409, "Session is not paused")
+    session.pending_continue = True
+    return {"ok": True, "reason": reason}
+
+
+# ---------------------------------------------------------------------------
+# Exports
+# ---------------------------------------------------------------------------
+
 @router.get("/chat/{session_id}/export")
 async def api_export_chat(session_id: str, fmt: str = "txt"):
     session = get_session(session_id)
@@ -182,6 +360,8 @@ async def api_export_chat(session_id: str, fmt: str = "txt"):
 
     if fmt == "md":
         return _export_md(session)
+    if fmt == "csv-table":
+        return _export_csv_table(session)
     return _export_txt(session)
 
 
@@ -190,38 +370,135 @@ async def api_export_log(session_id: str):
     session = get_session(session_id)
     if not session:
         raise HTTPException(404, "Session not found")
+    return {"session_id": session_id, "log": session.api_log}
+
 
+@router.get("/chat/{session_id}/table")
+async def api_table_view(session_id: str):
+    session = get_session(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+
+    rows = []
+    for p in session.participants:
+        first = (session.initial_opinions or {}).get(p.participant_id, "")
+        contribution = (session.contribution_summaries or {}).get(p.participant_id, "")
+        revised = (session.final_opinions or {}).get(p.participant_id, "")
+        final_msg = _last_consensus_message_for(session, p.participant_id) or revised
+        rows.append({
+            "participant_id": p.participant_id,
+            "name": p.name,
+            "model_display": p.display_name,
+            "first_opinion": first,
+            "contribution_summary": contribution,
+            "revised_opinion": revised,
+            "final_opinion": final_msg,
+        })
+    final_report = (session.final_report or {}).get("text", "")
     return {
         "session_id": session_id,
-        "log": session.api_log,
+        "question": session.question,
+        "final_report": final_report,
+        "final_report_kind": (session.final_report or {}).get("kind", ""),
+        "rows": rows,
     }
 
 
+def _last_consensus_message_for(session: Session, participant_id: str) -> str:
+    """Return the participant's most recent message in the consensus or
+    finalization phase - used as the 'final opinion' column."""
+    for m in reversed(session.messages):
+        if m.get("speaker_id") != participant_id:
+            continue
+        if m.get("phase") in {Phase.CONSENSUS.value, Phase.FINALIZATION.value}:
+            return m.get("text", "")
+    return ""
+
+
 # ---------------------------------------------------------------------------
 # Export helpers
 # ---------------------------------------------------------------------------
 
+def _format_participants_block(session: Session) -> list[str]:
+    return [
+        f"- {p.name} ({p.display_name})"
+        for p in session.participants
+    ]
+
+
 def _export_txt(session: Session) -> dict:
-    lines = [f"LLMChats3 Conversation Log", "=" * 40, ""]
-    if session.persona_a:
-        lines.append(f"Participant 1: {session.persona_a.name} ({session.persona_a.display_name})")
-    if session.persona_b:
-        lines.append(f"Participant 2: {session.persona_b.name} ({session.persona_b.display_name})")
+    lines = ["CCAI Conversation Log", "=" * 40, ""]
+    lines.append("Question:")
+    lines.append(session.question)
+    lines.append("")
+    lines.append("Participants:")
+    lines.extend(_format_participants_block(session))
     lines.append("")
     for m in session.messages:
-        lines.append(f"{m['speaker']}: {m['text']}")
+        speaker = m.get("speaker_name") or "(anon)"
+        if m.get("role") == "orchestrator":
+            speaker = "Orchestrator"
+        lines.append(f"{speaker}: {m.get('text', '')}")
         lines.append("")
-    return {"filename": "chat_export.txt", "content": "\n".join(lines)}
+    if session.final_report and session.final_report.get("text"):
+        lines.append("---")
+        lines.append("Final Report:")
+        lines.append(session.final_report["text"])
+    return {"filename": "ccai_chat.txt", "content": "\n".join(lines)}
 
 
 def _export_md(session: Session) -> dict:
-    lines = ["# LLMChats3 Conversation Log", ""]
-    if session.persona_a:
-        lines.append(f"**Participant 1:** {session.persona_a.name} (*{session.persona_a.display_name}*)")
-    if session.persona_b:
-        lines.append(f"**Participant 2:** {session.persona_b.name} (*{session.persona_b.display_name}*)")
+    lines = ["# CCAI Conversation Log", ""]
+    lines.append("## Question")
+    lines.append("")
+    lines.append(f"> {session.question}")
+    lines.append("")
+    lines.append("## Participants")
+    lines.append("")
+    for p in session.participants:
+        lines.append(f"- **{p.name}** (*{p.display_name}*)")
     lines.append("\n---\n")
     for m in session.messages:
-        lines.append(f"**{m['speaker']}:** {m['text']}")
+        speaker = m.get("speaker_name") or "(anon)"
+        is_orch = m.get("role") == "orchestrator"
+        if is_orch:
+            speaker = "Orchestrator"
+        text = m.get("text", "")
+        if is_orch:
+            lines.append(f"_**{speaker}:**_ {text}")
+        else:
+            lines.append(f"**{speaker}:** {text}")
+        lines.append("")
+    if session.final_report and session.final_report.get("text"):
+        lines.append("\n---\n")
+        lines.append("## Final Report")
         lines.append("")
-    return {"filename": "chat_export.md", "content": "\n".join(lines)}
+        lines.append(session.final_report["text"])
+    return {"filename": "ccai_chat.md", "content": "\n".join(lines)}
+
+
+def _export_csv_table(session: Session) -> dict:
+    """RFC-4180 compliant CSV. csv.writer handles quoting/escaping."""
+    buf = io.StringIO()
+    writer = csv.writer(buf, quoting=csv.QUOTE_MINIMAL, lineterminator="\n")
+
+    writer.writerow(["Question", session.question])
+    final_text = (session.final_report or {}).get("text", "")
+    writer.writerow(["Final Group Opinion", final_text])
+    writer.writerow([])
+    writer.writerow([
+        "Participant",
+        "First opinion",
+        "Conversation contribution",
+        "Revised opinion",
+        "Final opinion",
+    ])
+    for p in session.participants:
+        writer.writerow([
+            p.name,
+            (session.initial_opinions or {}).get(p.participant_id, ""),
+            (session.contribution_summaries or {}).get(p.participant_id, ""),
+            (session.final_opinions or {}).get(p.participant_id, ""),
+            _last_consensus_message_for(session, p.participant_id),
+        ])
+    return {"filename": "ccai_chat_table.csv", "content": buf.getvalue()}

backend/app/api/personas.py

@@ -0,0 +1,65 @@
+"""Participant catalog API.
+
+`GET /api/personas` returns three sections - Neon HANA personas (with
+vanilla/RAG personas filtered out), the four bundled extra personas, and
+the user-supplied expert personas (which are local-only on the frontend
+but echoed here for completeness so the API can act as the source of
+truth for participant choices when needed).
+"""
+from __future__ import annotations
+
+import logging
+
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+
+from app.clients.hana_client import hana_client
+from app.services.extra_personas import list_extra_personas
+
+router = APIRouter()
+LOG = logging.getLogger(__name__)
+
+
+def _is_vanilla_or_rag(persona_name: str) -> bool:
+    pn = (persona_name or "").lower()
+    return "vanilla" in pn or "rag" in pn
+
+
+@router.get("/personas")
+async def get_personas():
+    """Return the participant catalog the frontend dropdown shows."""
+    try:
+        neon_models = await hana_client.get_models()
+    except Exception as exc:
+        LOG.warning("HANA models unavailable: %s", exc)
+        neon_models = []
+
+    neon_personas = []
+    for nm in neon_models or []:
+        for p in nm.get("personas", []) or []:
+            if p.get("enabled") is False:
+                continue
+            persona_name = p.get("persona_name") or ""
+            if _is_vanilla_or_rag(persona_name):
+                continue
+            participant_id = f"neon:{nm['model_id']}:{persona_name}"
+            neon_personas.append({
+                "participant_id": participant_id,
+                "kind": "neon",
+                "name": persona_name,
+                "model_display": f"Neon / {nm['name'].split('/')[-1]}",
+                "default_model_id": participant_id,
+                "description": p.get("description") or "",
+            })
+
+    extras = list_extra_personas()
+    for e in extras:
+        e["model_display"] = e["default_model_id"]
+
+    return JSONResponse(
+        content={
+            "neon": neon_personas,
+            "extra": extras,
+        },
+        headers={"Cache-Control": "no-store"},
+    )

backend/app/clients/llm_router.py

@@ -6,6 +6,7 @@ from typing import Any
 
 from app.clients.openai_compat import openai_chat_completion
 from app.clients.hana_client import hana_client
+from app.utils.sanitize import strip_thinking, response_has_thinking
 
 LOG = logging.getLogger(__name__)
 
@@ -166,7 +167,7 @@ async def _call_neon_direct_vllm(
         max_tokens=max_tokens,
     )
     return {
-        "response": result.get("response", ""),
+        "response": strip_thinking(result.get("response", "")),
         "elapsed_seconds": result.get("elapsed_seconds", 0),
         "model": resolved["model_id"],
     }
@@ -210,8 +211,12 @@ async def _call_hana(
             temperature=temperature,
             max_tokens=max_tokens,
         )
+        raw = result.get("response", "")
+        cleaned = strip_thinking(raw)
+        if response_has_thinking(raw):
+            LOG.info("Stripped thinking content from HANA %s response", resolved["model_id"])
         return {
-            "response": result.get("response", ""),
+            "response": cleaned,
             "elapsed_seconds": result.get("elapsed_seconds", 0),
             "model": resolved["model_id"],
         }

backend/app/clients/openai_compat.py

@@ -2,22 +2,17 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import re
 import time
 from typing import Any
 
 import httpx
 
+from app.utils.sanitize import strip_thinking, response_has_thinking
+
 LOG = logging.getLogger(__name__)
 
 _shared_client: httpx.AsyncClient | None = None
 
-_THINK_TAG_RE = re.compile(r"<think>.*?</think>", re.DOTALL)
-_REASONING_BLOCK_RE = re.compile(
-    r"<(reasoning|reflection|inner_thoughts|scratchpad)>.*?</\1>",
-    re.DOTALL,
-)
-
 _MAX_COMPLETION_TOKEN_MODELS = {
     "o1", "o1-mini", "o1-preview", "o3", "o3-mini", "o4-mini",
     "gpt-5", "gpt-oss",
@@ -32,21 +27,9 @@ def _get_client() -> httpx.AsyncClient:
     return _shared_client
 
 
-def _strip_thinking(text: str) -> str:
-    """Remove chain-of-thought artifacts from any model's response."""
-    text = _THINK_TAG_RE.sub("", text)
-    text = _REASONING_BLOCK_RE.sub("", text)
-    return text.strip()
-
-
-def _detect_thinking_model(model: str, msg: dict) -> bool:
-    """Detect thinking models from the response itself, not just the model name."""
-    if msg.get("reasoning_content") or msg.get("reasoning"):
-        return True
-    content = msg.get("content") or ""
-    if _THINK_TAG_RE.search(content):
-        return True
-    return False
+# Thinking-trace detection and stripping live in app.utils.sanitize so every
+# code path (HANA, vLLM-direct, OpenAI-compat, summarizer inputs, credential
+# inputs) uses the same logic. See backend/app/utils/sanitize.py.
 
 
 async def openai_chat_completion(
@@ -102,8 +85,8 @@ async def openai_chat_completion(
                 msg = choices[0].get("message") or {}
                 text = msg.get("content") or ""
                 finish_reason = choices[0].get("finish_reason") or ""
-                had_thinking = _detect_thinking_model(model, msg)
-                text = _strip_thinking(text)
+                had_thinking = response_has_thinking(text, msg)
+                text = strip_thinking(text)
 
             if had_thinking:
                 LOG.info("Stripped thinking content from %s response", model)

backend/app/data/demo_questions.json

@@ -0,0 +1,65 @@
+{
+  "version": 1,
+  "questions": [
+    {
+      "id": "undergrad_majors",
+      "category": "education",
+      "title": "Best undergraduate majors for career prospects",
+      "text": "What are the three best majors for my undergraduate degree? I live in Washington State, USA, and I am starting college in the fall. My biggest priority is to make sure I have good job prospects when I graduate in 2031. I love using AI and exploring new technology, math is one of my strongest subjects, I don't want to travel for my job, and I don't want to have to publish papers as part of my job. I like to talk to people, and to travel. I know a lot about finance because my parents are both accountants. I also love animals."
+    },
+    {
+      "id": "small_business_ai",
+      "category": "small business",
+      "title": "Should a small bakery introduce AI?",
+      "text": "Should I introduce AI tools into my small bakery, and if so, where should I start? I run a single-storefront bakery in a tourist town in Vermont with three full-time employees and four part-timers. We do counter sales, weekend wholesale to two coffee shops, and a small custom-cake business. I'm 54, comfortable with tech but not a developer. My priorities, in order: keep the staff feeling valued, hold the food quality steady, save myself maybe 5-10 hours a week of paperwork, and slowly grow custom-cake revenue. I have about $3,000 a year I could redirect into software or services without straining the books."
+    },
+    {
+      "id": "rural_water",
+      "category": "public policy",
+      "title": "Best fix for a small town's failing water system",
+      "text": "Our rural town in central Pennsylvania has roughly 1,800 residents and a 1960s-era municipal water system that has had three boil-water advisories in the last two years. We have a small budget and an aging volunteer water board. The state has offered a 50% matching grant but only if we commit to a project plan within nine months. The three options on the table are: (a) replace the existing main lines incrementally over twelve years, (b) consolidate with a neighboring town's larger system, losing local control but gaining redundancy, or (c) install a smaller modern treatment plant of our own with recurring maintenance contracts. Residents are split, and the median household income is around $52,000."
+    },
+    {
+      "id": "elder_parent",
+      "category": "family",
+      "title": "Aging parent who wants to stay in their home",
+      "text": "My 82-year-old father lives alone in the rural Midwest after losing my mother last year. He's mentally sharp, drives short distances, and absolutely insists on staying in the house they built together. In the last six months he's had two minor falls (no fractures), forgot to take his blood pressure medication twice, and started to lose weight. My sister and I both live three to four hours away with full-time jobs and our own kids. He has roughly $90,000 in savings beyond Social Security and the house is paid off. We're trying to figure out the right next step that respects his autonomy without ignoring the warning signs."
+    },
+    {
+      "id": "ai_in_classroom",
+      "category": "education / technology ethics",
+      "title": "AI policy for a public middle school",
+      "text": "I'm a principal at a public middle school in Texas, grades 6-8, 480 students. Many of my teachers are quietly using ChatGPT and similar tools to plan lessons and draft feedback. About a third of students are using AI for homework, sometimes well, sometimes to skip thinking entirely. The school board wants me to publish a formal AI policy by the end of the semester. I have to balance student learning, equity (not all students have the same access at home), staff workload, parental concerns about screen time and privacy, and our district's tight budget. Should I lean toward restricting AI, embracing it, or some structured middle path - and what would the most important rules be?"
+    },
+    {
+      "id": "career_pivot_30s",
+      "category": "career",
+      "title": "Pivot from journalism to tech in your 30s",
+      "text": "I'm 34, a print journalist for the past 11 years at a regional paper that just announced a 30% layoff. I'm probably going to be cut. I have an undergraduate degree in English, no formal coding experience but I've been an enthusiastic Python tinkerer for two years. My wife is a public school teacher; we have one toddler and a small mortgage in a mid-sized U.S. city. We have about six months of savings. I'm considering three paths: (a) try to land another reporter job and write fiction on the side, (b) do a 9-12 month immersive transition into a junior product/data role at a smaller tech company, or (c) start a paid local newsletter business solo. I want a stable enough income, but I'd also like work that uses my voice and isn't soul-crushing."
+    },
+    {
+      "id": "climate_homestead",
+      "category": "environment / personal finance",
+      "title": "Buying property knowing the climate is shifting",
+      "text": "My partner and I are looking to buy a 5-15 acre property within a four-hour drive of Denver. We want a small homestead - some chickens, a vegetable garden, room for two large dogs - and a place we can live in long term. Our budget is around $550,000 including a modest house. We're worried about climate exposure: wildfire smoke, water-rights pressure on small wells, longer droughts, and how much insurance is going to cost ten years from now. We're also worried about being too far from a hospital. Neither of us has farming experience but we're hands-on. How do we think about which properties to look at, what to actually optimize for, and what we should be willing to compromise on?"
+    },
+    {
+      "id": "open_source_strategy",
+      "category": "tech / business strategy",
+      "title": "Open-source vs proprietary for a 12-person AI startup",
+      "text": "I'm CTO of a 12-person AI startup that's about to release our first real product: a domain-specific reasoning agent for legal-contract review. We've raised a Series A. The founding team is split on whether to release our core inference stack as open source under a permissive license. The arguments for: faster developer adoption, recruiting, brand-building, the ecosystem moves fast and we'll be left behind otherwise. The arguments against: a well-funded competitor could fork us, our investors are nervous, and our actual moat is the domain training data, not the inference code. I'd like to land on a defensible decision in the next six weeks. What framework should we use, and what's the right answer for a company in roughly our position?"
+    },
+    {
+      "id": "personal_health_diet",
+      "category": "health",
+      "title": "Diet overhaul with conflicting advice",
+      "text": "I'm 41, somewhat overweight, with borderline-high blood pressure and slightly elevated LDL cholesterol. My doctor wants me to lose roughly 30 pounds and lower my blood pressure without yet starting medication. I have done short stints with several diets over the years - low carb, intermittent fasting, Mediterranean, and a vegan stretch - and lost weight on each before regaining it. I have a desk job, two school-age kids, and I cook most of our meals. I'm not interested in supplements with weak evidence, but I am willing to commit to a structured plan if it's actually likely to work for someone like me long-term. What should the plan look like, and what trade-offs am I implicitly making by picking one?"
+    },
+    {
+      "id": "early_retirement",
+      "category": "personal finance",
+      "title": "FIRE-curious couple weighing semi-retirement at 50",
+      "text": "My spouse and I are both 50, two kids in college, a paid-off house in Minnesota, and about $1.6M in retirement and brokerage accounts (~80% in low-cost index funds). Our combined gross income is ~$240k/year and we save aggressively. We're not unhappy at our jobs but we're also not in love with them. We're debating whether to keep working at full pace through 60, semi-retire next year by both moving to ~25 hours/week each (income halves), or one of us fully retires and the other continues full time. We expect health-care costs to be the wildest variable. None of us has a strong intuition about how a 30-40 year retirement actually plays out financially or psychologically."
+    }
+  ]
+}

backend/app/main.py

@@ -14,10 +14,10 @@ from starlette.middleware.sessions import SessionMiddleware
 from app.config import settings
 from app.clients.hana_client import hana_client
 from app.clients.openai_compat import close_shared_client
-from app.api import models, chat
+from app.api import models, chat, personas
 from app.middleware.rate_limit import (
-    get_oauth_username, is_org_member, get_remaining, check_rate_limit,
-    record_conversation,
+    DAILY_LIMIT, get_oauth_username, is_org_member, get_remaining,
+    check_rate_limit, record_conversation,
 )
 
 logging.basicConfig(level=logging.INFO)
@@ -41,7 +41,7 @@ async def lifespan(app: FastAPI):
     await close_shared_client()
 
 
-app = FastAPI(title="AI Conversations", version="1.0.0", lifespan=lifespan)
+app = FastAPI(title="CCAI Vibe Demo", version="1.0.0", lifespan=lifespan)
 
 app.add_middleware(
     SessionMiddleware,
@@ -66,6 +66,7 @@ except Exception as exc:
 
 app.include_router(models.router, prefix="/api")
 app.include_router(chat.router, prefix="/api")
+app.include_router(personas.router, prefix="/api")
 
 
 @app.get("/api/health")
@@ -97,7 +98,7 @@ async def auth_status(request: Request):
 @app.get("/api/rate-limit/status")
 async def rate_limit_status(request: Request):
     remaining = get_remaining(request)
-    return {"remaining": remaining, "daily_limit": 20}
+    return {"remaining": remaining, "daily_limit": DAILY_LIMIT}
 
 
 if STATIC_DIR.is_dir():

backend/app/middleware/rate_limit.py

@@ -10,7 +10,11 @@ from fastapi import Request
 LOG = logging.getLogger(__name__)
 
 ORG_NAME = os.getenv("HF_RATE_LIMIT_ORG", "neongeckocom")
-DAILY_LIMIT = int(os.getenv("HF_RATE_LIMIT_DAILY", "20"))
+# CCAI demo bumps the per-IP daily cap from LLMChats3's 20 to 30 to match
+# the heavier multi-participant conversation pattern (the orchestrator-call
+# backstop and the participant-message failsafe handle per-conversation
+# cost).
+DAILY_LIMIT = int(os.getenv("HF_RATE_LIMIT_DAILY", "30"))
 
 _ip_counts: dict[str, dict] = defaultdict(lambda: {"date": "", "count": 0})
 

backend/app/services/consensus.py

@@ -0,0 +1,178 @@
+"""Phase-5 consensus helpers: alliance detection, addressed-to
+classification, status-checks, and unaddressed-factor probing.
+
+All four are short JSON-shaped orchestrator calls layered on top of
+`json_calls.orchestrator_call`.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from app.services.json_calls import orchestrator_call
+from app.services.prompts import (
+    ALLIANCE_DETECTION_PROMPT,
+    ADDRESSED_TO_PROMPT,
+    CONSENSUS_STATUS_PROMPT,
+    UNADDRESSED_FACTOR_PROMPT,
+)
+
+LOG = logging.getLogger(__name__)
+
+
+def _format_finalization_block(
+    participants: list[Any],
+    final_opinions: dict[str, str],
+) -> str:
+    lines: list[str] = []
+    for p in participants:
+        text = final_opinions.get(p.participant_id, "(no final opinion)").strip()
+        lines.append(f"--- {p.name} (id={p.participant_id}) ---")
+        lines.append(text)
+        lines.append("")
+    return "\n".join(lines).strip()
+
+
+def _format_roster_block(participants: list[Any]) -> str:
+    return "\n".join(
+        f"- id: {p.participant_id} | name: {p.name}" for p in participants
+    )
+
+
+def _format_alliance_block(groups: list[dict[str, Any]]) -> str:
+    lines: list[str] = []
+    for i, g in enumerate(groups):
+        members = ", ".join(g.get("members") or [])
+        lines.append(f"Group {i}: stance=\"{g.get('stance', '')}\" members=[{members}]")
+    return "\n".join(lines)
+
+
+async def detect_alliances(
+    *,
+    orchestrator_model_id: str,
+    question: str,
+    participants: list[Any],
+    final_opinions: dict[str, str],
+    api_log: list[dict[str, Any]] | None = None,
+) -> list[dict[str, Any]]:
+    prompt = ALLIANCE_DETECTION_PROMPT.format(
+        question=question,
+        finalization_block=_format_finalization_block(participants, final_opinions),
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=orchestrator_model_id,
+        user_prompt=prompt,
+        label="alliances",
+        api_log=api_log,
+        max_tokens=1024,
+    )
+    if isinstance(parsed, dict) and isinstance(parsed.get("groups"), list):
+        groups = parsed["groups"]
+        return _normalize_groups(groups, participants)
+
+    # Fallback: every participant in their own group.
+    return [
+        {"stance": "(unclassified)", "members": [p.participant_id]}
+        for p in participants
+    ]
+
+
+def _normalize_groups(
+    groups: list[dict[str, Any]],
+    participants: list[Any],
+) -> list[dict[str, Any]]:
+    """Make sure every participant id appears in exactly one group."""
+    valid_ids = {p.participant_id for p in participants}
+    seen: set[str] = set()
+    out: list[dict[str, Any]] = []
+    for g in groups:
+        members = [m for m in (g.get("members") or []) if m in valid_ids and m not in seen]
+        seen.update(members)
+        if members:
+            out.append({
+                "stance": g.get("stance", "(unspecified)"),
+                "members": members,
+            })
+    leftovers = [pid for pid in valid_ids if pid not in seen]
+    for pid in leftovers:
+        out.append({"stance": "(unclassified)", "members": [pid]})
+    return out
+
+
+async def classify_addressed_to(
+    *,
+    orchestrator_model_id: str,
+    participants: list[Any],
+    speaker_name: str,
+    message: str,
+    api_log: list[dict[str, Any]] | None = None,
+) -> str | None:
+    prompt = ADDRESSED_TO_PROMPT.format(
+        roster_block=_format_roster_block(participants),
+        speaker=speaker_name,
+        message=message,
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=orchestrator_model_id,
+        user_prompt=prompt,
+        label="addressed_to",
+        api_log=api_log,
+        max_tokens=128,
+    )
+    if isinstance(parsed, dict):
+        target = parsed.get("addressed_to")
+        if target and any(p.participant_id == target for p in participants):
+            return target
+    return None
+
+
+async def assess_consensus_status(
+    *,
+    orchestrator_model_id: str,
+    question: str,
+    transcript: str,
+    alliance_groups: list[dict[str, Any]],
+    api_log: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    prompt = CONSENSUS_STATUS_PROMPT.format(
+        question=question,
+        transcript=transcript,
+        alliance_block=_format_alliance_block(alliance_groups),
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=orchestrator_model_id,
+        user_prompt=prompt,
+        label="consensus_status",
+        api_log=api_log,
+        max_tokens=256,
+    )
+    if isinstance(parsed, dict) and parsed.get("status") in {"majority", "productive", "unproductive"}:
+        return parsed
+    # Default: treat as productive so we keep iterating, but give it a
+    # bounded number of attempts via the orchestrator-call cap.
+    return {"status": "productive", "majority_group_index": None, "rationale": ""}
+
+
+async def find_unaddressed_factor(
+    *,
+    orchestrator_model_id: str,
+    question: str,
+    credential_summary_block: str,
+    transcript: str,
+    api_log: list[dict[str, Any]] | None = None,
+) -> dict[str, Any] | None:
+    prompt = UNADDRESSED_FACTOR_PROMPT.format(
+        question=question,
+        credential_summary=credential_summary_block,
+        transcript=transcript,
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=orchestrator_model_id,
+        user_prompt=prompt,
+        label="unaddressed_factor",
+        api_log=api_log,
+        max_tokens=512,
+    )
+    if isinstance(parsed, dict) and parsed.get("factor"):
+        return parsed
+    return None

backend/app/services/context_budget.py

@@ -0,0 +1,244 @@
+"""Per-participant context budgeting with on-demand summarization.
+
+Ported from the Ask-A-Neon-LLM-Demos AskJerry pattern: estimate input
+tokens with chars/4, trigger a background summarize at 55% of the model's
+input budget, and once a summary exists trim history aggressively at
+70%. The summarizer model defaults to whichever model is selected as the
+Orchestrator (so changing one auto-changes the other) and is overridable
+in the settings menu.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+from app.clients.llm_router import chat_completion
+from app.config import settings
+from app.utils.sanitize import strip_thinking
+
+LOG = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Per-model context windows (input + output tokens)
+# ---------------------------------------------------------------------------
+#
+# Lookup precedence: exact model_id match -> prefix match -> fallback.
+# Numbers are deliberately conservative (real windows often advertise a
+# bigger absolute max but degrade well before that).
+DEFAULT_CONTEXT = 8_192
+
+EXACT_CONTEXT: dict[str, int] = {
+    "gpt-5.4": 200_000,
+    "gpt-4.1": 128_000,
+    "gpt-4.1-mini": 128_000,
+    "gpt-4o": 128_000,
+    "gpt-4o-mini": 128_000,
+    "o4-mini": 128_000,
+    "gemini-2.0-flash": 1_000_000,
+    "gemini-2.5-flash": 1_000_000,
+    "gemini-2.5-pro": 1_000_000,
+    "mistral-small-2506": 131_000,
+    "mistral-small-2603": 131_000,
+    "devstral-2512": 131_000,
+    "meta-llama/Llama-3.3-70B-Instruct-Turbo": 128_000,
+    "meta-llama/Meta-Llama-3-8B-Instruct-Lite": 8_192,
+    "Qwen/Qwen3-VL-8B-Instruct": 32_000,
+}
+
+PREFIX_CONTEXT: list[tuple[str, int]] = [
+    ("accounts/fireworks/models/kimi-", 256_000),
+    ("accounts/fireworks/models/deepseek-", 128_000),
+    ("accounts/fireworks/models/gpt-oss-", 128_000),
+    ("openai/gpt-oss-", 128_000),
+]
+
+
+def context_window_for(model_id: str) -> int:
+    """Return the configured input+output token window for a model.
+
+    BrainForge / unknown Neon models fall back to DEFAULT_CONTEXT (8K).
+    """
+    if model_id in EXACT_CONTEXT:
+        return EXACT_CONTEXT[model_id]
+    for prefix, window in PREFIX_CONTEXT:
+        if model_id.startswith(prefix):
+            return window
+    if model_id.startswith("neon:"):
+        return DEFAULT_CONTEXT
+    return DEFAULT_CONTEXT
+
+
+# Reserve at least this many tokens for the model's reply.
+DEFAULT_REPLY_BUDGET = 2_048
+
+# Trigger a summarize when input estimate >= SUMMARIZE_THRESHOLD * input_budget.
+SUMMARIZE_THRESHOLD = 0.55
+# When a summary exists and history still over-fills, trim to last K rounds.
+TRIM_THRESHOLD = 0.70
+# How many of the most recent messages to keep when trimming.
+KEEP_RECENT_MESSAGES = 6
+
+
+# ---------------------------------------------------------------------------
+# Per-participant summary state
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ContextSummary:
+    """Running summary for a single participant.
+
+    `summary_text` is the latest condensed summary; `summarized_through_idx`
+    is the index of the last message included in that summary so we don't
+    re-summarize old history every turn.
+    """
+
+    summary_text: str = ""
+    summarized_through_idx: int = -1
+    last_estimate: int = 0
+
+    def is_active(self) -> bool:
+        return bool(self.summary_text.strip())
+
+
+# ---------------------------------------------------------------------------
+# Token estimator (chars/4, no real tokenizer)
+# ---------------------------------------------------------------------------
+
+def _estimate_str_tokens(text: str | None) -> int:
+    if not text:
+        return 1
+    return max(1, len(text) // 4)
+
+
+def estimate_messages_tokens(messages: list[dict[str, Any]]) -> int:
+    total = 0
+    for m in messages:
+        total += _estimate_str_tokens(m.get("content"))
+        total += 4  # per-message framing overhead
+    return total
+
+
+# ---------------------------------------------------------------------------
+# Decision: does this participant need a summarize/trim?
+# ---------------------------------------------------------------------------
+
+def should_summarize(
+    model_id: str,
+    api_messages: list[dict[str, Any]],
+    summary: ContextSummary,
+) -> tuple[bool, bool, int]:
+    """Return (should_summarize, should_trim, input_budget).
+
+    `should_summarize` is True when raw input tokens >= 55% of the input
+    budget. `should_trim` is True when the budget is so tight (>= 70%)
+    that we should drop older messages and rely on the running summary.
+    """
+    window = context_window_for(model_id)
+    input_budget = max(2_048, window - DEFAULT_REPLY_BUDGET)
+    est = estimate_messages_tokens(api_messages)
+    summary.last_estimate = est
+    return (
+        est >= input_budget * SUMMARIZE_THRESHOLD,
+        est >= input_budget * TRIM_THRESHOLD and summary.is_active(),
+        input_budget,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Build the actual outbound message list for a participant turn
+# ---------------------------------------------------------------------------
+
+def build_compressed_messages(
+    api_messages: list[dict[str, Any]],
+    summary: ContextSummary,
+    needs_trim: bool,
+) -> list[dict[str, Any]]:
+    """If we need to trim, replace older messages with a system-summary message.
+
+    The first message is assumed to be the system prompt for the participant
+    and is always preserved. Every other message older than the last
+    KEEP_RECENT_MESSAGES is dropped in favor of the running summary.
+    """
+    if not needs_trim or not api_messages:
+        return api_messages
+
+    head = api_messages[:1]  # original system prompt
+    tail = api_messages[-KEEP_RECENT_MESSAGES:]
+    summary_msg = {
+        "role": "system",
+        "content": (
+            "Summary of earlier discussion (auto-condensed for context):\n"
+            + summary.summary_text
+        ),
+    }
+    return head + [summary_msg] + tail
+
+
+# ---------------------------------------------------------------------------
+# Run a summarize call against the configured summarizer model
+# ---------------------------------------------------------------------------
+
+SUMMARIZER_SYSTEM_PROMPT = (
+    "You are a concise discussion summarizer. Condense the following multi-"
+    "participant conversation into a tight summary that preserves: who said "
+    "what (by name), the key positions taken, agreements and disagreements, "
+    "any open questions, and the overall direction. Keep the summary under "
+    "300 words. Write in third-person narrative. Do not editorialize, vote, "
+    "or take a side. Output only the summary text — no preamble, no "
+    "reasoning, no meta-commentary."
+)
+
+
+async def run_summarize(
+    summarizer_model_id: str,
+    transcript_text: str,
+    timeout: float = 30.0,
+) -> str:
+    """Call the summarizer model on a plain-text transcript and return the summary.
+
+    Empty / failed summaries return an empty string so callers can fall back
+    gracefully.
+    """
+    if not transcript_text.strip():
+        return ""
+
+    resolved = settings.resolve_model(summarizer_model_id)
+    if not resolved:
+        LOG.warning("Summarizer model %s not resolvable, skipping summarize", summarizer_model_id)
+        return ""
+
+    messages = [
+        {"role": "system", "content": SUMMARIZER_SYSTEM_PROMPT},
+        {"role": "user", "content": transcript_text},
+    ]
+    result = await chat_completion(
+        resolved=resolved,
+        messages=messages,
+        temperature=0.2,
+        max_tokens=512,
+        timeout=timeout,
+    )
+    if result.get("error"):
+        LOG.warning("Summarizer call failed: %s", result.get("response"))
+        return ""
+    # Defense-in-depth: even if a summarizer model emitted reasoning,
+    # never let it leak into participant context.
+    return strip_thinking(result.get("response", ""))
+
+
+def select_summarizer_model_id(
+    summarizer_override: str | None,
+    orchestrator_model_id: str | None,
+) -> str:
+    """Resolve the summarizer model id to use, with the rule from the plan:
+
+    - explicit override wins
+    - else fall back to whatever model is selected as the Orchestrator
+    - else fall back to the global settings default
+    """
+    if summarizer_override:
+        return summarizer_override
+    if orchestrator_model_id:
+        return orchestrator_model_id
+    return settings.orchestrator_model

backend/app/services/credential.py

@@ -0,0 +1,153 @@
+"""Credential Summary builder + refresher.
+
+The Credential Summary is a JSON dict (participant_id -> assessment)
+threaded into every later participant turn. It is built once after Phase
+1 and refreshed once after Phase 2 critique.
+"""
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from app.services.json_calls import orchestrator_call
+from app.services.prompts import (
+    CREDENTIAL_BUILD_PROMPT,
+    CREDENTIAL_REFRESH_PROMPT,
+)
+from app.utils.sanitize import strip_thinking
+
+LOG = logging.getLogger(__name__)
+
+
+def _format_participants_block(
+    participants: list[Any],
+    initial_opinions: dict[str, str],
+) -> str:
+    """Render one block per participant containing role prompt + first opinion."""
+    lines: list[str] = []
+    for p in participants:
+        opinion = strip_thinking(initial_opinions.get(p.participant_id, ""))
+        lines.append(f"--- Participant id: {p.participant_id} ---")
+        lines.append(f"Name: {p.name}")
+        lines.append(f"Role prompt: {p.role_prompt}")
+        lines.append(f"First opinion: {opinion}")
+        lines.append("")
+    return "\n".join(lines).strip()
+
+
+def credentials_to_block(credentials: list[dict[str, Any]]) -> str:
+    """Render the credentials list back into a string for use inside
+    participant prompts (so we can keep them readable rather than
+    embedding raw JSON in role prompts)."""
+    if not credentials:
+        return "(no credential summary available yet)"
+    lines: list[str] = []
+    for c in credentials:
+        lines.append(f"- {c.get('name', c.get('participant_id', '?'))} "
+                     f"(id={c.get('participant_id', '?')})")
+        if c.get("expertise"):
+            lines.append(f"    Expertise: {c['expertise']}")
+        if c.get("personality"):
+            lines.append(f"    Style: {c['personality']}")
+        if c.get("credibility_for_question") is not None:
+            lines.append(f"    Credibility on this question: {c['credibility_for_question']:.2f}")
+        if c.get("bias_to_watch"):
+            lines.append(f"    Bias to watch: {c['bias_to_watch']}")
+    return "\n".join(lines)
+
+
+async def build_credential_summary(
+    *,
+    orchestrator_model_id: str,
+    question: str,
+    participants: list[Any],
+    initial_opinions: dict[str, str],
+    api_log: list[dict[str, Any]] | None = None,
+) -> list[dict[str, Any]]:
+    """Build the Credential Summary list. Returns an empty list on parse failure."""
+    block = _format_participants_block(participants, initial_opinions)
+    prompt = CREDENTIAL_BUILD_PROMPT.format(
+        question=question,
+        participants_block=block,
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=orchestrator_model_id,
+        user_prompt=prompt,
+        label="build_credentials",
+        api_log=api_log,
+        max_tokens=2048,
+    )
+
+    creds: list[dict[str, Any]] = []
+    if isinstance(parsed, dict) and isinstance(parsed.get("credentials"), list):
+        creds = parsed["credentials"]
+
+    creds = _normalize_creds(creds, participants)
+    return creds
+
+
+async def refresh_credential_summary(
+    *,
+    orchestrator_model_id: str,
+    question: str,
+    participants: list[Any],
+    existing: list[dict[str, Any]],
+    critique_transcript: str,
+    api_log: list[dict[str, Any]] | None = None,
+) -> list[dict[str, Any]]:
+    """Refresh the Credential Summary after Phase 2 critique."""
+    if not existing:
+        return existing
+    prompt = CREDENTIAL_REFRESH_PROMPT.format(
+        question=question,
+        credential_summary_json=json.dumps({"credentials": existing}, indent=2),
+        critique_transcript=critique_transcript,
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=orchestrator_model_id,
+        user_prompt=prompt,
+        label="refresh_credentials",
+        api_log=api_log,
+        max_tokens=2048,
+    )
+    if isinstance(parsed, dict) and isinstance(parsed.get("credentials"), list):
+        return _normalize_creds(parsed["credentials"], participants)
+    return existing
+
+
+def _normalize_creds(
+    creds: list[dict[str, Any]],
+    participants: list[Any],
+) -> list[dict[str, Any]]:
+    """Defensive cleanup: ensure credibility is a float in [0, 1] and that
+    every participant has a row (fill in placeholders if the model dropped
+    one)."""
+    by_id: dict[str, dict[str, Any]] = {}
+    for c in creds:
+        pid = c.get("participant_id") or c.get("id") or ""
+        if not pid:
+            continue
+        try:
+            score = float(c.get("credibility_for_question", 0.5))
+        except Exception:
+            score = 0.5
+        c["credibility_for_question"] = max(0.0, min(1.0, score))
+        by_id[pid] = c
+
+    out: list[dict[str, Any]] = []
+    for p in participants:
+        if p.participant_id in by_id:
+            row = by_id[p.participant_id]
+            row.setdefault("name", p.name)
+            out.append(row)
+        else:
+            out.append({
+                "participant_id": p.participant_id,
+                "name": p.name,
+                "expertise": "(no credential available)",
+                "personality": "",
+                "credibility_for_question": 0.5,
+                "bias_to_watch": "",
+            })
+    return out

backend/app/services/extra_personas.py

@@ -0,0 +1,128 @@
+"""Four bundled "extra" personas powered by non-Neon LLMs.
+
+Each pairs a discussion lens with a complementary area of expertise so
+they generalize to any question. The user can replace any of them by
+creating an Expert Persona, or change which LLM powers each one in the
+settings menu.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ExtraPersonaSpec:
+    participant_id: str
+    name: str
+    default_model_id: str
+    role_prompt: str
+
+
+EXTRA_PERSONAS: list[ExtraPersonaSpec] = [
+    ExtraPersonaSpec(
+        participant_id="extra_pragmatic_generalist",
+        name="The Pragmatic Generalist",
+        default_model_id="gpt-5.4",
+        role_prompt=(
+            "You are The Pragmatic Generalist with a complementary specialty in "
+            "finance and economics. You have broad general knowledge across "
+            "many domains and you instinctively look for what is feasible, "
+            "cost-effective, and likely to actually work in practice. Even on "
+            "questions that aren't financial, you anchor your reasoning in "
+            "monetary cost, return on investment, opportunity cost, time "
+            "horizons, and budget realism, and you call out when an idea "
+            "sounds great but the numbers don't add up. Your tone is calm, "
+            "measured, and faintly skeptical of utopian framing. You speak "
+            "like an experienced advisor: short paragraphs, concrete examples, "
+            "and a habit of comparing options head-to-head on cost vs benefit "
+            "rather than treating any one option as obvious. You are willing "
+            "to change your mind when shown a credible argument, but you ask "
+            "for a back-of-envelope calculation before doing so."
+        ),
+    ),
+    ExtraPersonaSpec(
+        participant_id="extra_skeptical_critic",
+        name="The Skeptical Critic",
+        default_model_id="gemini-2.5-flash",
+        role_prompt=(
+            "You are The Skeptical Critic with a complementary specialty in "
+            "philosophy. Your role in a group discussion is to play the "
+            "principled devil's advocate: surface assumptions nobody is "
+            "examining, pressure-test claims with counterexamples, and ask "
+            "the unpopular questions. You frame your challenges through "
+            "philosophical fundamentals - epistemology (how do we know that?), "
+            "ethics (utilitarian vs deontological framings, consequentialist "
+            "tradeoffs), and edge-case thought experiments that expose the "
+            "limits of a position. Your tone is sharp but not hostile; you "
+            "respect arguments more than people, including your own. You "
+            "speak in concise, well-structured sentences, you cite specific "
+            "claims by other participants when challenging them, and you are "
+            "happy to concede when someone refutes you cleanly - because to "
+            "you the goal is the truth, not winning."
+        ),
+    ),
+    ExtraPersonaSpec(
+        participant_id="extra_empathetic_humanist",
+        name="The Empathetic Humanist",
+        default_model_id="devstral-2512",
+        role_prompt=(
+            "You are The Empathetic Humanist with a complementary specialty in "
+            "world history. You center human, ethical, social, and values "
+            "impact in every discussion. You instinctively ask: who is "
+            "affected, whose voice is missing, and what does this mean for "
+            "the people on the receiving end? You ground your arguments in "
+            "historical precedent - how comparable choices have played out "
+            "across cultures, civilizations, and eras - and you draw lessons "
+            "from them without being preachy. Your tone is warm, thoughtful, "
+            "and a bit reflective; you speak in flowing sentences and you "
+            "name the human stakes explicitly. You're willing to slow the "
+            "group down when something matters morally, and you push back "
+            "gently but firmly when an argument treats people as variables. "
+            "You change your mind when shown that the human consequences "
+            "you feared are not real, or that historical analogues don't "
+            "apply."
+        ),
+    ),
+    ExtraPersonaSpec(
+        participant_id="extra_data_driven_analyst",
+        name="The Data-Driven Analyst",
+        default_model_id="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+        role_prompt=(
+            "You are The Data-Driven Analyst with a complementary specialty in "
+            "geology and Earth-science / physical-systems thinking. You want "
+            "evidence: numbers, studies, measurements, and falsifiable claims. "
+            "When others speak in generalities, you ask 'how would we measure "
+            "that?' or 'what's the magnitude?'. You bring a long-time-horizon, "
+            "physical-systems mindset shaped by Earth science: resources are "
+            "finite, environmental constraints are real, infrastructure has "
+            "lifespans, and feedback loops can take decades to reveal "
+            "themselves. Your tone is precise, dry, and quietly rigorous; "
+            "you cite figures even when approximate, you flag uncertainty "
+            "ranges rather than pretending precision you don't have, and you "
+            "respect any participant who shows their work. You are willing "
+            "to update your view when better data is presented, and you are "
+            "openly suspicious of any claim that has 'never' or 'always' in "
+            "it."
+        ),
+    ),
+]
+
+
+def list_extra_personas() -> list[dict]:
+    return [
+        {
+            "participant_id": p.participant_id,
+            "name": p.name,
+            "default_model_id": p.default_model_id,
+            "role_prompt": p.role_prompt,
+            "kind": "extra",
+        }
+        for p in EXTRA_PERSONAS
+    ]
+
+
+def get_extra_persona(participant_id: str) -> ExtraPersonaSpec | None:
+    for p in EXTRA_PERSONAS:
+        if p.participant_id == participant_id:
+            return p
+    return None

backend/app/services/json_calls.py

@@ -0,0 +1,145 @@
+"""Helpers for orchestrator-side LLM calls that need JSON-shaped output."""
+from __future__ import annotations
+
+import json
+import logging
+import re
+import time
+from typing import Any
+
+from app.clients.openai_compat import openai_chat_completion
+from app.config import settings
+from app.services.prompts import ORCHESTRATOR_BASE_DIRECTIVE
+from app.utils.sanitize import strip_thinking
+
+LOG = logging.getLogger(__name__)
+
+
+def _strip_json_fences(raw: str) -> str:
+    """Some models wrap JSON in ```json ... ``` fences. Peel them off."""
+    raw = raw.strip()
+    if raw.startswith("```"):
+        # drop the first fence line
+        first_nl = raw.find("\n")
+        if first_nl != -1:
+            raw = raw[first_nl + 1:]
+        raw = raw.rstrip()
+        if raw.endswith("```"):
+            raw = raw[:-3].rstrip()
+    return raw
+
+
+def _extract_json_blob(raw: str) -> str:
+    """Best-effort: pull out the first balanced { ... } or [ ... ] block."""
+    raw = _strip_json_fences(raw)
+    for opener, closer in [("{", "}"), ("[", "]")]:
+        start = raw.find(opener)
+        if start == -1:
+            continue
+        depth = 0
+        in_str = False
+        esc = False
+        for i in range(start, len(raw)):
+            ch = raw[i]
+            if in_str:
+                if esc:
+                    esc = False
+                elif ch == "\\":
+                    esc = True
+                elif ch == '"':
+                    in_str = False
+                continue
+            if ch == '"':
+                in_str = True
+                continue
+            if ch == opener:
+                depth += 1
+            elif ch == closer:
+                depth -= 1
+                if depth == 0:
+                    return raw[start:i + 1]
+    return raw
+
+
+def parse_json_response(raw: str) -> dict | list | None:
+    """Tolerant JSON parser for orchestrator outputs.
+
+    Handles markdown fences, leading/trailing prose, and falls back to
+    extracting the first balanced bracket block. Returns None if nothing
+    parseable is found.
+    """
+    if not raw:
+        return None
+    candidates = [raw, _strip_json_fences(raw), _extract_json_blob(raw)]
+    seen: set[str] = set()
+    for c in candidates:
+        c = c.strip()
+        if not c or c in seen:
+            continue
+        seen.add(c)
+        try:
+            return json.loads(c)
+        except Exception:
+            continue
+    LOG.warning("parse_json_response failed; raw=%r", raw[:200])
+    return None
+
+
+async def orchestrator_call(
+    *,
+    orchestrator_model_id: str,
+    user_prompt: str,
+    label: str,
+    api_log: list[dict[str, Any]] | None = None,
+    expect_json: bool = True,
+    temperature: float = 0.2,
+    max_tokens: int = 1024,
+    timeout: float = 45.0,
+) -> tuple[str, dict | list | None]:
+    """Run an orchestrator-side LLM call.
+
+    Returns (raw_text_after_strip, parsed_json_or_None). When `expect_json`
+    is False the parsed value will always be None and the caller should use
+    the raw text. Any exception is converted into a ("", None) result so
+    the orchestrator state machine can degrade gracefully.
+    """
+    resolved = settings.resolve_model(orchestrator_model_id)
+    if not resolved:
+        LOG.warning("Orchestrator model %s not resolvable", orchestrator_model_id)
+        return "", None
+
+    messages = [
+        {"role": "system", "content": ORCHESTRATOR_BASE_DIRECTIVE},
+        {"role": "user", "content": user_prompt},
+    ]
+
+    log_entry: dict[str, Any] = {
+        "timestamp": time.time(),
+        "label": f"orchestrator:{label}",
+        "model": resolved["model_id"],
+        "request": {"messages": messages, "max_tokens": max_tokens},
+    }
+    try:
+        result = await openai_chat_completion(
+            base_url=resolved["base_url"],
+            api_key=resolved["api_key"],
+            model=resolved["model_id"],
+            messages=messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            timeout=timeout,
+        )
+    except Exception as exc:
+        LOG.exception("orchestrator_call %s failed: %s", label, exc)
+        log_entry["response"] = {"error": str(exc)}
+        if api_log is not None:
+            api_log.append(log_entry)
+        return "", None
+
+    log_entry["response"] = result
+    if api_log is not None:
+        api_log.append(log_entry)
+
+    raw = strip_thinking(result.get("response", ""))
+    parsed = parse_json_response(raw) if expect_json else None
+    return raw, parsed

backend/app/services/models.py

@@ -0,0 +1,138 @@
+"""Core dataclasses for a CCAI session.
+
+Kept in their own module so `orchestrator.py` can import from them
+cleanly and the API layer doesn't need to reach into the orchestrator
+to construct one.
+"""
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+from app.services.context_budget import ContextSummary
+
+
+class Phase(str, Enum):
+    INITIAL_OPINIONS = "initial_opinions"
+    CRITIQUE_ROUND_1 = "critique_round_1"
+    CRITIQUE_ROUND_2 = "critique_round_2"
+    STATUS_ASSESSMENT = "status_assessment"
+    FINALIZATION = "finalization"
+    CONSENSUS = "consensus"
+    CLOSURE = "closure"
+    FAILSAFE_PAUSED = "failsafe_paused"
+    FINISHED = "finished"
+
+
+# How many participants a session may include (overridable by the user
+# via Settings; values outside [3, 9] are clamped server-side).
+DEFAULT_MAX_PARTICIPANTS = 5
+MIN_MAX_PARTICIPANTS = 3
+MAX_MAX_PARTICIPANTS = 9
+
+
+# Failsafe defaults from the plan: pause every N=60 participant messages
+# (then every +20), and every M=100 orchestrator calls (then every +50).
+PARTICIPANT_MESSAGE_PAUSE_AT = 60
+PARTICIPANT_MESSAGE_PAUSE_INC = 20
+ORCHESTRATOR_CALL_PAUSE_AT = 100
+ORCHESTRATOR_CALL_PAUSE_INC = 50
+
+
+@dataclass
+class Participant:
+    """One member of the CCAI forum.
+
+    `kind` distinguishes Neon HANA personas, the four bundled "extra"
+    personas, and user-created Expert Personas. `enabled` reflects the
+    sidebar slider. Disabled participants are kept on the session so
+    the user can re-enable mid-conversation, but they don't take turns.
+    """
+
+    participant_id: str
+    name: str
+    role_prompt: str
+    model_id: str
+
+    kind: str = "expert"  # "neon" | "extra" | "expert"
+    enabled: bool = True
+
+    # Resolved provider routing (populated from settings.resolve_model)
+    base_url: str = ""
+    api_key: str = ""
+    display_name: str = ""
+
+    # Neon-specific routing
+    is_neon: bool = False
+    hana_model_id: str = ""
+    persona_name: str = ""
+    neon_direct_vllm: bool = False
+    vllm_base_url: str = ""
+    vllm_api_key: str = ""
+
+    # Per-participant context summary (managed by services.context_budget)
+    summary: ContextSummary = field(default_factory=ContextSummary)
+
+    # Robustness counter: 3 consecutive failures auto-disables.
+    consecutive_failures: int = 0
+
+
+@dataclass
+class Session:
+    session_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+    question: str = ""
+    participants: list[Participant] = field(default_factory=list)
+
+    # Both fall through to settings.orchestrator_model when None. The
+    # summarizer additionally falls through to the orchestrator's id when
+    # None (so changing one auto-changes the other unless overridden).
+    orchestrator_model_id: str | None = None
+    summarizer_model_id: str | None = None
+
+    max_participants: int = DEFAULT_MAX_PARTICIPANTS
+
+    phase: Phase = Phase.INITIAL_OPINIONS
+
+    # Phase 1 outputs
+    initial_opinions: dict[str, str] = field(default_factory=dict)
+    credential_summary: list[dict[str, Any]] = field(default_factory=list)
+
+    # Phase 2 / 3 / 4 / 5 message store. Each entry:
+    #   { speaker_id, speaker_name, role: "participant"|"orchestrator",
+    #     text, phase, timestamp, elapsed_seconds, addressed_to,
+    #     model_id, model_display }
+    messages: list[dict[str, Any]] = field(default_factory=list)
+
+    # Phase-4 state: per-participant final opinion text (for alliances)
+    final_opinions: dict[str, str] = field(default_factory=dict)
+    alliance_groups: list[dict[str, Any]] = field(default_factory=list)
+
+    # Phase-3 status-assessment loop counter (max 3)
+    status_assessment_iterations: int = 0
+
+    # Phase-5 / Phase-6 attempts at consensus before giving up (max 2)
+    consensus_attempts: int = 0
+
+    # Final structured report after closure
+    final_report: dict[str, Any] | None = None
+
+    # Per-participant contribution summaries for the table view
+    contribution_summaries: dict[str, str] = field(default_factory=dict)
+
+    # Failsafes
+    total_participant_messages: int = 0
+    participant_message_cap: int = PARTICIPANT_MESSAGE_PAUSE_AT
+    orchestrator_call_count: int = 0
+    orchestrator_call_cap: int = ORCHESTRATOR_CALL_PAUSE_AT
+
+    paused_for_continue: bool = False
+    pause_reason: str | None = None  # "messages" | "orchestrator"
+    finished: bool = False
+
+    # Streaming control: the orchestrator state-machine writes to this and
+    # the API layer reads it.
+    api_log: list[dict[str, Any]] = field(default_factory=list)
+    pending_continue: bool = False

backend/app/services/orchestrator.py

@@ -1,108 +1,94 @@
+"""CCAI orchestrator: six-phase state machine driving a multi-participant
+group discussion to a consensus (or to a documented failure-to-consense).
+
+Phase outline (matches the build plan):
+
+    1. Initial Opinions (independent, no peeking)
+    1.5. Build Credential Summary
+    2. Critique x 2 rounds (full history visible)
+    3. Status Assessment (max 3 iterations of targeted follow-ups)
+    4. Opinion Finalization
+    5. Consensus Gathering (alliance-aware, addressed-to aware)
+    6. Closure (majority report, or unaddressed-factor probe + retry,
+       or failure report)
+
+Two failsafes pause the loop until the user clicks "Continue":
+    - Participant-message cap: 60, then +20.
+    - Orchestrator-call cap: 100, then +50.
+
+Every LLM response runs through `app.utils.sanitize.strip_thinking` on
+its way into history, into the orchestrator's prompts, and into the
+summarizer.
+"""
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
-import random
 import time
-import uuid
-from dataclasses import dataclass, field
+from dataclasses import asdict
 from typing import Any, AsyncIterator
 
-from app.clients.openai_compat import openai_chat_completion
-from app.clients.llm_router import chat_completion as unified_chat_completion
+from app.clients.llm_router import chat_completion
 from app.config import settings
-
-LOG = logging.getLogger(__name__)
-
-# ---------------------------------------------------------------------------
-# Prompt templates
-# ---------------------------------------------------------------------------
-
-_BREVITY = (
-    " Keep your reply short — 2-4 sentences, like a casual chat message, not an email or essay."
+from app.services import context_budget
+from app.services.consensus import (
+    assess_consensus_status,
+    classify_addressed_to,
+    detect_alliances,
+    find_unaddressed_factor,
 )
-
-AUTO_START_PROMPT = (
-    "You're starting a conversation with someone new. Here is some information about them: "
-    "{other_role}\n\n"
-    "Consider connections between this information and what you know about yourself, and say "
-    "something that could start a conversation with that new person. Speak in the first person, "
-    "as if directly to the other person." + _BREVITY
-)
-
-FIRST_REPLY_PROMPT = (
-    "Someone just started a conversation with you, this is what they said: {last_message}\n\n"
-    "Consider connections between this conversation starter and what you know about yourself, "
-    "and say something that could continue the conversation with that new person. Speak in the "
-    "first person, as if directly to the other person." + _BREVITY
+from app.services.context_budget import (
+    ContextSummary,
+    DEFAULT_REPLY_BUDGET,
+    KEEP_RECENT_MESSAGES,
+    build_compressed_messages,
+    context_window_for,
+    estimate_messages_tokens,
+    run_summarize,
+    select_summarizer_model_id,
+    should_summarize,
 )
-
-CONTINUE_PROMPT = (
-    "You are having a conversation with another person, here is the conversation so far:\n\n"
-    "{history}\n\n"
-    "Consider how human conversations generally progress, and provide a response. If the last "
-    "reply in the conversation is one which might indicate a human is losing interest in or "
-    "wrapping up the conversation, then make a response which will help wrap up and close the "
-    "conversation." + _BREVITY
+from app.services.credential import (
+    build_credential_summary,
+    credentials_to_block,
+    refresh_credential_summary,
 )
-
-WINDING_NEXT_PROMPT = (
-    "You are having a conversation with another person, here is the conversation so far:\n\n"
-    "{history}\n\n"
-    "Consider how human conversations generally progress, and provide a response which will "
-    "wrap up and close the conversation. This is the last reply you will give in this "
-    "conversation." + _BREVITY
+from app.services.json_calls import orchestrator_call
+from app.services.models import (
+    DEFAULT_MAX_PARTICIPANTS,
+    MAX_MAX_PARTICIPANTS,
+    MIN_MAX_PARTICIPANTS,
+    ORCHESTRATOR_CALL_PAUSE_INC,
+    PARTICIPANT_MESSAGE_PAUSE_INC,
+    Participant,
+    Phase,
+    Session,
 )
-
-WINDING_FINAL_PROMPT = (
-    "You are having a conversation with another person, here is the conversation so far:\n\n"
-    "{history}\n\n"
-    "Consider how human conversations generally progress, and focus on the last two messages "
-    "in this conversation. Provide a very short response which closes the conversation."
-    + _BREVITY
+from app.services.prompts import (
+    CONSENSUS_ALLIED_PROMPT,
+    CONSENSUS_SOLO_PROMPT,
+    CONSENSUS_TARGETED_RESPONSE_PROMPT,
+    CONTRIBUTION_SUMMARY_PROMPT,
+    CRITIQUE_PROMPT,
+    FINALIZATION_PROMPT,
+    INITIAL_OPINION_PROMPT,
+    MAJORITY_REPORT_PROMPT,
+    NO_CONSENSUS_REPORT_PROMPT,
+    NO_REASONING_DIRECTIVE,
+    PARTICIPANT_BASE_DIRECTIVE,
+    STATUS_ASSESSMENT_PROMPT,
+    TARGETED_FOLLOWUP_PROMPT,
 )
+from app.utils.sanitize import strip_thinking
 
-ORCHESTRATOR_CHECK_PROMPT = (
-    "You are monitoring a conversation between two people. Your job is to determine whether "
-    "the latest message indicates the speaker is losing interest or wrapping up the conversation. "
-    "Reply with ONLY a JSON object: {{\"winding_down\": true}} or {{\"winding_down\": false}}. "
-    "No other text.\n\nLatest message:\n{message}"
-)
+LOG = logging.getLogger(__name__)
 
 
 # ---------------------------------------------------------------------------
-# Session data
+# Session registry
 # ---------------------------------------------------------------------------
 
-@dataclass
-class Persona:
-    name: str
-    model_id: str
-    role_prompt: str
-    base_url: str = ""
-    api_key: str = ""
-    display_name: str = ""
-    is_neon: bool = False
-    hana_model_id: str = ""
-    persona_name: str = ""
-    neon_direct_vllm: bool = False
-    vllm_base_url: str = ""
-    vllm_api_key: str = ""
-
-
-@dataclass
-class Session:
-    session_id: str = field(default_factory=lambda: str(uuid.uuid4()))
-    persona_a: Persona | None = None
-    persona_b: Persona | None = None
-    messages: list[dict[str, str]] = field(default_factory=list)
-    api_log: list[dict[str, Any]] = field(default_factory=list)
-    a_count: int = 0
-    b_count: int = 0
-    end_mode: bool = False
-    finished: bool = False
-
-
 _sessions: dict[str, Session] = {}
 
 
@@ -116,276 +102,970 @@ def create_session() -> Session:
     return s
 
 
+# ---------------------------------------------------------------------------
+# SSE helpers
+# ---------------------------------------------------------------------------
+
+def _sse(event: str, data: dict[str, Any]) -> str:
+    return f"event: {event}\ndata: {json.dumps(data)}\n\n"
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
 
-def _format_history(messages: list[dict[str, str]]) -> str:
-    lines = []
+def _active_participants(session: Session) -> list[Participant]:
+    return [p for p in session.participants if p.enabled]
+
+
+def _orchestrator_model_id(session: Session) -> str:
+    return session.orchestrator_model_id or settings.orchestrator_model
+
+
+def _summarizer_model_id(session: Session) -> str:
+    return select_summarizer_model_id(
+        session.summarizer_model_id,
+        session.orchestrator_model_id,
+    )
+
+
+def _format_history(
+    messages: list[dict[str, Any]],
+    *,
+    include_orchestrator: bool = True,
+) -> str:
+    lines: list[str] = []
     for m in messages:
-        lines.append(f"{m['speaker']}: {m['text']}")
+        if m.get("role") == "orchestrator" and not include_orchestrator:
+            continue
+        speaker = m.get("speaker_name") or m.get("speaker_id") or "(anon)"
+        if m.get("role") == "orchestrator":
+            speaker = "Orchestrator"
+        lines.append(f"{speaker}: {m.get('text', '')}")
     return "\n".join(lines)
 
 
-async def _call_llm(
-    persona: Persona,
-    system_content: str,
-    user_content: str,
-    session: Session,
-    label: str = "",
-    max_tokens: int = 500,
-    timeout: float = 20,
+def _participant_roster_string(
+    speaker: Participant,
+    participants: list[Participant],
 ) -> str:
-    system_with_directive = (
-        system_content + "\n\nIMPORTANT: Respond ONLY with your in-character dialogue. "
-        "Do NOT include your reasoning, thought process, analysis of the prompt, "
-        "meta-commentary, internal monologue, or draft notes. Output ONLY the words "
-        "your character would actually say aloud."
+    others = [p.name for p in participants if p.participant_id != speaker.participant_id]
+    return ", ".join(others) if others else "(no other participants)"
+
+
+# ---------------------------------------------------------------------------
+# Failsafe checks
+# ---------------------------------------------------------------------------
+
+def _participant_msg_cap_hit(session: Session) -> bool:
+    return session.total_participant_messages >= session.participant_message_cap
+
+
+def _orchestrator_cap_hit(session: Session) -> bool:
+    return session.orchestrator_call_count >= session.orchestrator_call_cap
+
+
+def _bump_orchestrator_count(session: Session) -> None:
+    session.orchestrator_call_count += 1
+
+
+async def _wait_for_continue(
+    session: Session,
+    reason: str,
+) -> AsyncIterator[str]:
+    """Pause the state machine until the user clicks Continue."""
+    session.paused_for_continue = True
+    session.pause_reason = reason
+    if reason == "messages":
+        msg = (
+            f"Conversation paused after {session.total_participant_messages} "
+            "participant messages. Click Continue to allow another "
+            f"{PARTICIPANT_MESSAGE_PAUSE_INC} messages."
+        )
+        evt = "failsafe_pause"
+        bump_inc = PARTICIPANT_MESSAGE_PAUSE_INC
+    else:
+        msg = (
+            f"Conversation paused after {session.orchestrator_call_count} "
+            "orchestrator calls. Click Continue to allow another "
+            f"{ORCHESTRATOR_CALL_PAUSE_INC} orchestrator calls."
+        )
+        evt = "orchestrator_cap_pause"
+        bump_inc = ORCHESTRATOR_CALL_PAUSE_INC
+
+    yield _sse(evt, {
+        "reason": reason,
+        "message": msg,
+        "participant_messages": session.total_participant_messages,
+        "orchestrator_calls": session.orchestrator_call_count,
+    })
+
+    # Block until pending_continue is flipped by the API layer.
+    while session.paused_for_continue and not session.pending_continue:
+        await asyncio.sleep(0.25)
+    session.pending_continue = False
+    session.paused_for_continue = False
+    if reason == "messages":
+        session.participant_message_cap += bump_inc
+    else:
+        session.orchestrator_call_cap += bump_inc
+    session.pause_reason = None
+    yield _sse("status", {"message": "Resuming conversation..."})
+
+
+# ---------------------------------------------------------------------------
+# Participant turn (with context budgeting + summarize-on-demand)
+# ---------------------------------------------------------------------------
+
+async def _maybe_summarize_for_participant(
+    session: Session,
+    participant: Participant,
+    api_messages: list[dict[str, Any]],
+) -> None:
+    """If this participant's input estimate exceeds the threshold, run a
+    summarize call against the configured summarizer model and update
+    `participant.summary` in place."""
+    needs_sum, _trim, _budget = should_summarize(
+        participant.model_id, api_messages, participant.summary,
+    )
+    if not needs_sum:
+        return
+
+    # Build a transcript that excludes orchestrator status banners (those
+    # don't add information value to a summary) but keeps everything the
+    # participant has said and heard.
+    summarizable_msgs = [
+        m for m in session.messages
+        if m.get("role") != "orchestrator_status"
+    ]
+    if not summarizable_msgs:
+        return
+
+    transcript = _format_history(summarizable_msgs, include_orchestrator=False)
+    if not transcript.strip():
+        return
+
+    summarizer_id = _summarizer_model_id(session)
+    summary_text = await run_summarize(summarizer_id, transcript)
+    # The summarizer counts as an orchestrator-side call for cap purposes.
+    session.orchestrator_call_count += 1
+    if summary_text:
+        participant.summary.summary_text = summary_text
+        participant.summary.summarized_through_idx = len(session.messages) - 1
+
+
+async def _call_participant(
+    *,
+    session: Session,
+    participant: Participant,
+    user_prompt: str,
+    label: str,
+    max_tokens: int = 600,
+    timeout: float = 45.0,
+) -> tuple[str, float, bool]:
+    """Run one participant turn and return (text, elapsed_seconds, ok).
+
+    The state-machine handles auto-disable on repeated failure.
+    """
+    others = _participant_roster_string(participant, _active_participants(session))
+    base_directive = PARTICIPANT_BASE_DIRECTIVE.format(
+        n_participants=len(_active_participants(session)),
+        other_participants=others,
+    )
+    system_text = (
+        f"{participant.role_prompt}\n\n{base_directive}\n\n{NO_REASONING_DIRECTIVE}"
     )
-    messages = [
-        {"role": "system", "content": system_with_directive},
-        {"role": "user", "content": user_content},
+    api_messages: list[dict[str, Any]] = [
+        {"role": "system", "content": system_text},
+        {"role": "user", "content": user_prompt},
     ]
+
+    await _maybe_summarize_for_participant(session, participant, api_messages)
+
+    needs_sum, needs_trim, _ = should_summarize(
+        participant.model_id, api_messages, participant.summary,
+    )
+    if needs_trim:
+        api_messages = build_compressed_messages(
+            api_messages, participant.summary, needs_trim,
+        )
+
+    resolved = {
+        "model_id": participant.model_id,
+        "base_url": participant.base_url,
+        "api_key": participant.api_key,
+        "is_neon": participant.is_neon,
+        "hana_model_id": participant.hana_model_id,
+        "persona_name": participant.persona_name,
+        "neon_direct_vllm": participant.neon_direct_vllm,
+        "vllm_base_url": participant.vllm_base_url,
+        "vllm_api_key": participant.vllm_api_key,
+    }
+
     log_entry: dict[str, Any] = {
         "timestamp": time.time(),
-        "label": label,
-        "model": persona.model_id,
-        "request": {"messages": messages, "max_tokens": max_tokens},
+        "label": f"participant:{participant.participant_id}:{label}",
+        "model": participant.model_id,
+        "request": {"messages": api_messages, "max_tokens": max_tokens},
     }
 
-    resolved = {
-        "model_id": persona.model_id,
-        "base_url": persona.base_url,
-        "api_key": persona.api_key,
-        "is_neon": persona.is_neon,
-        "hana_model_id": persona.hana_model_id,
-        "persona_name": persona.persona_name,
-        "neon_direct_vllm": persona.neon_direct_vllm,
-        "vllm_base_url": persona.vllm_base_url,
-        "vllm_api_key": persona.vllm_api_key,
-    }
-    result = await unified_chat_completion(
-        resolved=resolved,
-        messages=messages,
-        temperature=0.7,
-        max_tokens=max_tokens,
-        timeout=timeout,
-    )
+    try:
+        result = await chat_completion(
+            resolved=resolved,
+            messages=api_messages,
+            temperature=0.7,
+            max_tokens=max_tokens,
+            timeout=timeout,
+        )
+    except Exception as exc:
+        LOG.exception("Participant %s call failed: %s", participant.participant_id, exc)
+        log_entry["response"] = {"error": str(exc)}
+        session.api_log.append(log_entry)
+        participant.consecutive_failures += 1
+        return "", 0.0, False
 
     log_entry["response"] = result
     session.api_log.append(log_entry)
 
-    return result.get("response", ""), result.get("elapsed_seconds", 0)
+    if result.get("error"):
+        participant.consecutive_failures += 1
+        return "", result.get("elapsed_seconds", 0), False
+
+    participant.consecutive_failures = 0
+    text = strip_thinking(result.get("response", ""))
+    elapsed = float(result.get("elapsed_seconds", 0) or 0)
+    return text, elapsed, True
 
 
-async def _call_orchestrator(
-    prompt: str,
+def _add_participant_message(
     session: Session,
-    label: str = "",
-) -> str:
-    resolved = settings.resolve_model(settings.orchestrator_model)
-    if not resolved:
-        LOG.warning("Orchestrator model %s not found, using first available", settings.orchestrator_model)
-        for prov in settings.providers:
-            for m in prov["models"]:
-                resolved = {
-                    "base_url": m.get("base_url", prov["base_url"]),
-                    "api_key": m.get("api_key", prov["api_key"]),
-                    "model_id": m["id"],
-                }
-                break
-            if resolved:
-                break
-
-    if not resolved:
-        return '{"winding_down": false}'
-
-    messages = [
-        {"role": "system", "content": "You are a conversation monitor. Respond only with the requested JSON."},
-        {"role": "user", "content": prompt},
-    ]
-    log_entry: dict[str, Any] = {
+    participant: Participant,
+    text: str,
+    *,
+    phase: Phase,
+    elapsed: float,
+    addressed_to: str | None = None,
+) -> dict[str, Any]:
+    msg = {
+        "speaker_id": participant.participant_id,
+        "speaker_name": participant.name,
+        "role": "participant",
+        "text": text,
+        "phase": phase.value,
         "timestamp": time.time(),
-        "label": f"orchestrator:{label}",
-        "model": resolved["model_id"],
-        "request": {"messages": messages},
+        "elapsed_seconds": round(elapsed, 2),
+        "addressed_to": addressed_to,
+        "model_id": participant.model_id,
+        "model_display": participant.display_name,
     }
+    session.messages.append(msg)
+    session.total_participant_messages += 1
+    return msg
 
-    result = await openai_chat_completion(
-        base_url=resolved["base_url"],
-        api_key=resolved["api_key"],
-        model=resolved["model_id"],
-        messages=messages,
-        temperature=0.2,
-        max_tokens=256,
-        timeout=20,
-    )
-
-    log_entry["response"] = result
-    session.api_log.append(log_entry)
 
-    return result.get("response", "")
+def _add_orchestrator_message(
+    session: Session,
+    text: str,
+    *,
+    kind: str,
+    extra: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    msg = {
+        "speaker_id": "orchestrator",
+        "speaker_name": "Orchestrator",
+        "role": "orchestrator",
+        "kind": kind,  # "status" | "factor" | "majority_report" | "no_consensus_report"
+        "text": text,
+        "phase": session.phase.value,
+        "timestamp": time.time(),
+    }
+    if extra:
+        msg.update(extra)
+    session.messages.append(msg)
+    return msg
 
 
-def _parse_json_bool(raw: str, key: str) -> bool:
-    try:
-        raw = raw.strip()
-        if raw.startswith("```"):
-            raw = raw.split("\n", 1)[-1].rsplit("```", 1)[0]
-        return json.loads(raw).get(key, False)
-    except Exception:
-        lower = raw.lower()
-        return f'"{key}": true' in lower or f'"{key}":true' in lower
+def _msg_payload(msg: dict[str, Any]) -> dict[str, Any]:
+    """Public payload for a message event over SSE."""
+    return msg
 
 
 # ---------------------------------------------------------------------------
-# Main conversation loop (yields SSE events)
+# Phase implementations
 # ---------------------------------------------------------------------------
 
-async def run_conversation(
-    session: Session,
-    starter_text: str | None = None,
-) -> AsyncIterator[str]:
-    pa = session.persona_a
-    pb = session.persona_b
-    if not pa or not pb:
-        yield _sse("error", {"message": "Both personas must be configured"})
-        return
-
-    participants = [pa, pb]
-    starter_idx = random.randint(0, 1)
-    starter = participants[starter_idx]
-    responder = participants[1 - starter_idx]
+async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
+    session.phase = Phase.INITIAL_OPINIONS
+    yield _sse("status", {"message": "Phase 1: collecting independent first opinions..."})
+
+    actives = _active_participants(session)
+    for p in actives:
+        # Phase 1 deliberately uses a *bare* prompt (no transcript) so each
+        # participant's first opinion is independent of the others.
+        prompt = INITIAL_OPINION_PROMPT.format(question=session.question)
+        text, elapsed, ok = await _call_participant(
+            session=session, participant=p,
+            user_prompt=prompt,
+            label="initial_opinion",
+            max_tokens=700,
+        )
+        if not ok or not text.strip():
+            yield _sse("participant_error", {
+                "participant_id": p.participant_id,
+                "name": p.name,
+                "phase": session.phase.value,
+            })
+            if p.consecutive_failures >= 3:
+                p.enabled = False
+                yield _sse("status", {
+                    "message": f"{p.name} auto-disabled after 3 failures.",
+                })
+            continue
+        msg = _add_participant_message(session, p, text, phase=session.phase, elapsed=elapsed)
+        session.initial_opinions[p.participant_id] = text
+        yield _sse("message", _msg_payload(msg))
+
+        if _participant_msg_cap_hit(session):
+            async for chunk in _wait_for_continue(session, "messages"):
+                yield chunk
+
+    yield _sse("status", {"message": "Building Credential Summary..."})
+    creds = await build_credential_summary(
+        orchestrator_model_id=_orchestrator_model_id(session),
+        question=session.question,
+        participants=_active_participants(session),
+        initial_opinions=session.initial_opinions,
+        api_log=session.api_log,
+    )
+    _bump_orchestrator_count(session)
+    session.credential_summary = creds
 
-    yield _sse("status", {"message": "Starting conversation..."})
 
-    # --- First message ---
-    if starter_text:
-        # Show the user-provided starter as the first message from the starter LLM,
-        # then send it to the responder to reply to (no LLM call for the opener).
-        _add_message(session, starter, starter_text.strip(), starter_idx)
-        yield _sse("message", _msg_payload(session.messages[-1], starter_idx))
+async def _phase_critique(session: Session, round_number: int) -> AsyncIterator[str]:
+    session.phase = (
+        Phase.CRITIQUE_ROUND_1 if round_number == 1 else Phase.CRITIQUE_ROUND_2
+    )
+    yield _sse("status", {
+        "message": f"Phase 2: critique round {round_number} of 2...",
+    })
+    cred_block = credentials_to_block(session.credential_summary)
+    actives = _active_participants(session)
+    for p in actives:
+        transcript = _format_history(session.messages)
+        prompt = CRITIQUE_PROMPT.format(
+            round_number=round_number,
+            question=session.question,
+            credential_summary=cred_block,
+            transcript=transcript,
+        )
+        text, elapsed, ok = await _call_participant(
+            session=session, participant=p,
+            user_prompt=prompt,
+            label=f"critique_round_{round_number}",
+            max_tokens=700,
+        )
+        if not ok or not text.strip():
+            yield _sse("participant_error", {
+                "participant_id": p.participant_id, "name": p.name,
+                "phase": session.phase.value,
+            })
+            if p.consecutive_failures >= 3:
+                p.enabled = False
+                yield _sse("status", {"message": f"{p.name} auto-disabled after 3 failures."})
+            continue
+
+        # Detect addressed_to so the consensus phase's targeted-response
+        # logic can also reuse it - cheap classification call.
+        addressed = await classify_addressed_to(
+            orchestrator_model_id=_orchestrator_model_id(session),
+            participants=_active_participants(session),
+            speaker_name=p.name,
+            message=text,
+            api_log=session.api_log,
+        )
+        _bump_orchestrator_count(session)
 
-        reply_prompt = FIRST_REPLY_PROMPT.format(last_message=starter_text.strip())
-        second_msg, second_elapsed = await _call_llm(
-            responder, responder.role_prompt, reply_prompt, session,
-            label=f"first_reply:{responder.name}",
+        msg = _add_participant_message(
+            session, p, text, phase=session.phase, elapsed=elapsed,
+            addressed_to=addressed,
         )
-        _add_message(session, responder, second_msg, 1 - starter_idx, second_elapsed)
-        yield _sse("message", _msg_payload(session.messages[-1], 1 - starter_idx))
-    else:
-        user_prompt = AUTO_START_PROMPT.format(other_role=responder.role_prompt)
-        first_msg, first_elapsed = await _call_llm(
-            starter, starter.role_prompt, user_prompt, session,
-            label=f"start:{starter.name}",
+        yield _sse("message", _msg_payload(msg))
+
+        if _participant_msg_cap_hit(session):
+            async for chunk in _wait_for_continue(session, "messages"):
+                yield chunk
+        if _orchestrator_cap_hit(session):
+            async for chunk in _wait_for_continue(session, "orchestrator"):
+                yield chunk
+
+
+async def _phase_status_assessment(session: Session) -> AsyncIterator[str]:
+    session.phase = Phase.STATUS_ASSESSMENT
+    yield _sse("status", {"message": "Phase 3: assessing whether more questions are needed..."})
+
+    cred_block = credentials_to_block(session.credential_summary)
+
+    # Refresh Credential Summary once after Phase 2 critique - participants
+    # have revealed a lot more about themselves through critique.
+    transcript = _format_history(session.messages)
+    refreshed = await refresh_credential_summary(
+        orchestrator_model_id=_orchestrator_model_id(session),
+        question=session.question,
+        participants=_active_participants(session),
+        existing=session.credential_summary,
+        critique_transcript=transcript,
+        api_log=session.api_log,
+    )
+    _bump_orchestrator_count(session)
+    session.credential_summary = refreshed
+    cred_block = credentials_to_block(session.credential_summary)
+
+    for iteration in range(3):
+        session.status_assessment_iterations = iteration + 1
+        prompt = STATUS_ASSESSMENT_PROMPT.format(
+            question=session.question,
+            credential_summary=cred_block,
+            transcript=_format_history(session.messages),
         )
-        _add_message(session, starter, first_msg, starter_idx, first_elapsed)
-        yield _sse("message", _msg_payload(session.messages[-1], starter_idx))
+        _raw, parsed = await orchestrator_call(
+            orchestrator_model_id=_orchestrator_model_id(session),
+            user_prompt=prompt,
+            label=f"status_assessment_{iteration + 1}",
+            api_log=session.api_log,
+            max_tokens=512,
+        )
+        _bump_orchestrator_count(session)
 
-        reply_prompt = FIRST_REPLY_PROMPT.format(last_message=first_msg)
-        second_msg, second_elapsed = await _call_llm(
-            responder, responder.role_prompt, reply_prompt, session,
-            label=f"first_reply:{responder.name}",
+        opinions_solidified = bool(
+            isinstance(parsed, dict) and parsed.get("opinions_solidified")
         )
-        _add_message(session, responder, second_msg, 1 - starter_idx, second_elapsed)
-        yield _sse("message", _msg_payload(session.messages[-1], 1 - starter_idx))
-
-    # --- Continue loop ---
-    current_idx = starter_idx
-    while not session.finished:
-        current = participants[current_idx]
-        history_text = _format_history(session.messages)
-
-        # Check orchestrator on the last message
-        last_msg_text = session.messages[-1]["text"]
-
-        if not session.end_mode:
-            orch_raw = await _call_orchestrator(
-                ORCHESTRATOR_CHECK_PROMPT.format(message=last_msg_text),
-                session,
-                label="winding_check",
+        open_qs: list[dict[str, Any]] = []
+        if isinstance(parsed, dict):
+            open_qs = parsed.get("open_questions") or []
+
+        if opinions_solidified or not open_qs:
+            yield _sse("orchestrator", {
+                "kind": "status",
+                "text": "Opinions appear solidified - moving to finalization.",
+            })
+            return
+
+        # Otherwise run targeted follow-ups
+        active_ids = {p.participant_id for p in _active_participants(session)}
+        for oq in open_qs:
+            pid = oq.get("participant_id")
+            question_text = (oq.get("question") or "").strip()
+            if not pid or pid not in active_ids or not question_text:
+                continue
+            target = next(p for p in session.participants if p.participant_id == pid)
+            announce = (
+                f"The orchestrator has a follow-up for {target.name}: "
+                f"\"{question_text}\""
+            )
+            announce_msg = _add_orchestrator_message(session, announce, kind="status")
+            yield _sse("orchestrator", _msg_payload(announce_msg))
+
+            transcript = _format_history(session.messages)
+            prompt2 = TARGETED_FOLLOWUP_PROMPT.format(
+                transcript=transcript,
+                credential_summary=cred_block,
+                targeted_question=question_text,
+            )
+            text, elapsed, ok = await _call_participant(
+                session=session, participant=target,
+                user_prompt=prompt2,
+                label="targeted_followup",
+                max_tokens=600,
             )
-            winding = _parse_json_bool(orch_raw, "winding_down")
-
-            if winding:
-                session.end_mode = True
-
-        # Force wrap-up at 8 messages each
-        if not session.end_mode:
-            if session.a_count >= 8 and session.b_count >= 8:
-                session.end_mode = True
-
-        if session.end_mode:
-            # Penultimate message: current speaker wraps up
-            history_text = _format_history(session.messages)
-            wrap_msg, wrap_elapsed = await _call_llm(
-                current, current.role_prompt,
-                WINDING_NEXT_PROMPT.format(history=history_text),
-                session, label=f"winding_next:{current.name}",
+            if not ok or not text.strip():
+                yield _sse("participant_error", {
+                    "participant_id": target.participant_id, "name": target.name,
+                    "phase": session.phase.value,
+                })
+                continue
+            msg = _add_participant_message(
+                session, target, text, phase=session.phase, elapsed=elapsed,
             )
-            _add_message(session, current, wrap_msg, current_idx, wrap_elapsed)
-            yield _sse("message", _msg_payload(session.messages[-1], current_idx))
-
-            # Final message: other speaker closes
-            other_idx = 1 - current_idx
-            other = participants[other_idx]
-            history_text = _format_history(session.messages)
-            final_msg, final_elapsed = await _call_llm(
-                other, other.role_prompt,
-                WINDING_FINAL_PROMPT.format(history=history_text),
-                session, label=f"winding_final:{other.name}",
+            yield _sse("message", _msg_payload(msg))
+
+            if _participant_msg_cap_hit(session):
+                async for chunk in _wait_for_continue(session, "messages"):
+                    yield chunk
+            if _orchestrator_cap_hit(session):
+                async for chunk in _wait_for_continue(session, "orchestrator"):
+                    yield chunk
+
+    yield _sse("orchestrator", {
+        "kind": "status",
+        "text": "Status assessment limit reached - moving to finalization.",
+    })
+
+
+async def _phase_finalization(session: Session) -> AsyncIterator[str]:
+    session.phase = Phase.FINALIZATION
+    yield _sse("status", {"message": "Phase 4: opinion finalization..."})
+
+    cred_block = credentials_to_block(session.credential_summary)
+    actives = _active_participants(session)
+    for p in actives:
+        transcript = _format_history(session.messages)
+        prompt = FINALIZATION_PROMPT.format(
+            question=session.question,
+            credential_summary=cred_block,
+            transcript=transcript,
+        )
+        text, elapsed, ok = await _call_participant(
+            session=session, participant=p,
+            user_prompt=prompt,
+            label="finalization",
+            max_tokens=600,
+        )
+        if not ok or not text.strip():
+            yield _sse("participant_error", {
+                "participant_id": p.participant_id, "name": p.name,
+                "phase": session.phase.value,
+            })
+            continue
+        session.final_opinions[p.participant_id] = text
+        msg = _add_participant_message(
+            session, p, text, phase=session.phase, elapsed=elapsed,
+        )
+        yield _sse("message", _msg_payload(msg))
+
+        if _participant_msg_cap_hit(session):
+            async for chunk in _wait_for_continue(session, "messages"):
+                yield chunk
+
+
+async def _phase_consensus(session: Session) -> AsyncIterator[str]:
+    session.phase = Phase.CONSENSUS
+    yield _sse("status", {"message": "Phase 5: consensus gathering..."})
+
+    cred_block = credentials_to_block(session.credential_summary)
+    actives = _active_participants(session)
+
+    # Initial alliance detection from the finalization-phase opinions
+    groups = await detect_alliances(
+        orchestrator_model_id=_orchestrator_model_id(session),
+        question=session.question,
+        participants=actives,
+        final_opinions=session.final_opinions,
+        api_log=session.api_log,
+    )
+    _bump_orchestrator_count(session)
+    session.alliance_groups = groups
+
+    announce = "Alliance groups detected: " + "; ".join(
+        f"\"{g.get('stance', '')}\" -> [{', '.join(g.get('members') or [])}]"
+        for g in groups
+    )
+    msg = _add_orchestrator_message(session, announce, kind="status")
+    yield _sse("orchestrator", _msg_payload(msg))
+
+    # Round-robin among active participants, but yield to the addressed-to
+    # target whenever the previous message named one explicitly.
+    queue: list[Participant] = list(actives)
+    last_addressed: str | None = None
+
+    # Hard backstop on this phase: if we make a lot of consensus turns
+    # without resolving, exit and let closure handle it. The orchestrator-
+    # call cap will hit before this, but it's a clean upper bound.
+    max_consensus_turns = 6 * len(actives)
+    consensus_turns = 0
+
+    while consensus_turns < max_consensus_turns:
+        consensus_turns += 1
+
+        # Pick speaker
+        if last_addressed:
+            speaker = next(
+                (p for p in actives if p.participant_id == last_addressed),
+                None,
             )
-            _add_message(session, other, final_msg, other_idx, final_elapsed)
-            yield _sse("message", _msg_payload(session.messages[-1], other_idx))
-
-            session.finished = True
-            yield _sse("system", {"text": "End of Chat"})
-            break
-
-        # Normal continue
-        prompt = CONTINUE_PROMPT.format(history=history_text)
-        response, resp_elapsed = await _call_llm(
-            current, current.role_prompt, prompt, session,
-            label=f"continue:{current.name}",
+            if speaker is None:
+                speaker = queue[0] if queue else actives[0]
+            else:
+                queue = [p for p in queue if p.participant_id != speaker.participant_id]
+            last_addressed = None
+        else:
+            if not queue:
+                queue = list(actives)
+            speaker = queue.pop(0)
+
+        # Decide allied vs solo prompt
+        speaker_group, other_groups = _find_speaker_group(speaker, session.alliance_groups)
+        prompt = _build_consensus_prompt(
+            session, speaker, speaker_group, other_groups,
+            actives, cred_block,
         )
-        _add_message(session, current, response, current_idx, resp_elapsed)
-        yield _sse("message", _msg_payload(session.messages[-1], current_idx))
 
-        current_idx = 1 - current_idx
+        text, elapsed, ok = await _call_participant(
+            session=session, participant=speaker,
+            user_prompt=prompt,
+            label="consensus",
+            max_tokens=700,
+        )
+        if not ok or not text.strip():
+            yield _sse("participant_error", {
+                "participant_id": speaker.participant_id, "name": speaker.name,
+                "phase": session.phase.value,
+            })
+            continue
+
+        addressed = await classify_addressed_to(
+            orchestrator_model_id=_orchestrator_model_id(session),
+            participants=actives,
+            speaker_name=speaker.name,
+            message=text,
+            api_log=session.api_log,
+        )
+        _bump_orchestrator_count(session)
+        last_addressed = addressed
+
+        msg = _add_participant_message(
+            session, speaker, text, phase=session.phase, elapsed=elapsed,
+            addressed_to=addressed,
+        )
+        yield _sse("message", _msg_payload(msg))
+
+        if _participant_msg_cap_hit(session):
+            async for chunk in _wait_for_continue(session, "messages"):
+                yield chunk
+        if _orchestrator_cap_hit(session):
+            async for chunk in _wait_for_continue(session, "orchestrator"):
+                yield chunk
+
+        # Status check every full round (every len(actives) turns)
+        if consensus_turns % max(1, len(actives)) == 0:
+            transcript = _format_history(session.messages)
+            status = await assess_consensus_status(
+                orchestrator_model_id=_orchestrator_model_id(session),
+                question=session.question,
+                transcript=transcript,
+                alliance_groups=session.alliance_groups,
+                api_log=session.api_log,
+            )
+            _bump_orchestrator_count(session)
+            if status.get("status") == "majority":
+                session.alliance_groups = await _refresh_alliance_groups(session, actives)
+                yield _sse("orchestrator", {
+                    "kind": "status",
+                    "text": f"Majority reached. {status.get('rationale', '')}".strip(),
+                })
+                return
+            if status.get("status") == "unproductive":
+                yield _sse("orchestrator", {
+                    "kind": "status",
+                    "text": f"Conversation no longer productive. {status.get('rationale', '')}".strip(),
+                })
+                return
+            # else: productive - keep going
+
+
+async def _refresh_alliance_groups(
+    session: Session,
+    actives: list[Participant],
+) -> list[dict[str, Any]]:
+    """Re-cluster after the consensus phase, treating the latest round of
+    consensus statements as each participant's current stance."""
+    latest_by_id: dict[str, str] = {}
+    for m in session.messages:
+        if m.get("role") != "participant":
+            continue
+        if m.get("phase") != Phase.CONSENSUS.value:
+            continue
+        latest_by_id[m["speaker_id"]] = m["text"]
+    # Fall back to finalization opinions for any participant who didn't
+    # speak in the consensus phase yet.
+    merged: dict[str, str] = dict(session.final_opinions)
+    merged.update(latest_by_id)
+    groups = await detect_alliances(
+        orchestrator_model_id=_orchestrator_model_id(session),
+        question=session.question,
+        participants=actives,
+        final_opinions=merged,
+        api_log=session.api_log,
+    )
+    _bump_orchestrator_count(session)
+    return groups
+
+
+def _find_speaker_group(
+    speaker: Participant,
+    groups: list[dict[str, Any]],
+) -> tuple[dict[str, Any] | None, list[dict[str, Any]]]:
+    speaker_group: dict[str, Any] | None = None
+    others: list[dict[str, Any]] = []
+    for g in groups:
+        if speaker.participant_id in (g.get("members") or []):
+            speaker_group = g
+        else:
+            others.append(g)
+    return speaker_group, others
 
-    yield _sse("done", {})
+
+def _build_consensus_prompt(
+    session: Session,
+    speaker: Participant,
+    speaker_group: dict[str, Any] | None,
+    other_groups: list[dict[str, Any]],
+    actives: list[Participant],
+    cred_block: str,
+) -> str:
+    transcript = _format_history(session.messages)
+
+    # If the previous message addressed this speaker by id, route a
+    # targeted-response prompt instead of the standard allied/solo flow.
+    if session.messages:
+        last = session.messages[-1]
+        if (
+            last.get("role") == "participant"
+            and last.get("addressed_to") == speaker.participant_id
+        ):
+            return CONSENSUS_TARGETED_RESPONSE_PROMPT.format(
+                addressed_by_name=last.get("speaker_name", "another participant"),
+                addressed_message=last.get("text", ""),
+                question=session.question,
+                credential_summary=cred_block,
+                transcript=transcript,
+            )
+
+    if speaker_group and len(speaker_group.get("members") or []) > 1:
+        members = ", ".join(
+            p.name for p in actives
+            if p.participant_id in (speaker_group.get("members") or [])
+            and p.participant_id != speaker.participant_id
+        ) or "(no co-allies named)"
+        return CONSENSUS_ALLIED_PROMPT.format(
+            alliance_members=members,
+            alliance_stance=speaker_group.get("stance", "(unspecified)"),
+            question=session.question,
+            credential_summary=cred_block,
+            transcript=transcript,
+        )
+
+    other_groups_block = "\n".join(
+        f"  - \"{g.get('stance', '')}\" supported by " + ", ".join(
+            p.name for p in actives if p.participant_id in (g.get("members") or [])
+        )
+        for g in other_groups
+    ) or "(no other groups)"
+    return CONSENSUS_SOLO_PROMPT.format(
+        your_stance=(speaker_group or {}).get("stance", "(unspecified)"),
+        other_groups_block=other_groups_block,
+        question=session.question,
+        credential_summary=cred_block,
+        transcript=transcript,
+    )
 
 
 # ---------------------------------------------------------------------------
-# SSE helpers
+# Closure
 # ---------------------------------------------------------------------------
 
-def _add_message(session: Session, persona: Persona, text: str, speaker_idx: int, elapsed: float = 0) -> None:
-    session.messages.append({
-        "speaker": persona.name,
-        "speaker_idx": speaker_idx,
-        "model_id": persona.model_id,
-        "model_display": persona.display_name,
-        "text": text,
-        "timestamp": time.time(),
-        "elapsed_seconds": round(elapsed, 2),
-    })
-    if speaker_idx == 0:
-        session.a_count += 1
-    else:
-        session.b_count += 1
+async def _phase_closure(session: Session) -> AsyncIterator[str]:
+    session.phase = Phase.CLOSURE
+    yield _sse("status", {"message": "Phase 6: closure..."})
 
+    cred_block = credentials_to_block(session.credential_summary)
+    transcript = _format_history(session.messages)
 
-def _msg_payload(msg: dict, speaker_idx: int) -> dict:
-    return {
-        "speaker": msg["speaker"],
-        "speaker_idx": speaker_idx,
-        "model_display": msg["model_display"],
-        "text": msg["text"],
-        "timestamp": msg["timestamp"],
-        "elapsed_seconds": msg.get("elapsed_seconds", 0),
+    status = await assess_consensus_status(
+        orchestrator_model_id=_orchestrator_model_id(session),
+        question=session.question,
+        transcript=transcript,
+        alliance_groups=session.alliance_groups,
+        api_log=session.api_log,
+    )
+    _bump_orchestrator_count(session)
+
+    actives = _active_participants(session)
+    if status.get("status") == "majority":
+        idx = status.get("majority_group_index")
+        majority_group = None
+        if isinstance(idx, int) and 0 <= idx < len(session.alliance_groups):
+            majority_group = session.alliance_groups[idx]
+        else:
+            # Fallback: largest group wins
+            if session.alliance_groups:
+                majority_group = max(
+                    session.alliance_groups,
+                    key=lambda g: len(g.get("members") or []),
+                )
+        if majority_group:
+            members_names = [
+                p.name for p in actives
+                if p.participant_id in (majority_group.get("members") or [])
+            ]
+            stance = majority_group.get("stance", "")
+            prompt = MAJORITY_REPORT_PROMPT.format(
+                question=session.question,
+                credential_summary=cred_block,
+                majority_members=", ".join(members_names),
+                majority_stance=stance,
+                transcript=transcript,
+            )
+            raw, _ = await orchestrator_call(
+                orchestrator_model_id=_orchestrator_model_id(session),
+                user_prompt=prompt,
+                label="majority_report",
+                api_log=session.api_log,
+                expect_json=False,
+                max_tokens=900,
+                temperature=0.3,
+            )
+            _bump_orchestrator_count(session)
+            session.final_report = {
+                "kind": "majority",
+                "text": raw,
+                "majority_members": members_names,
+                "majority_stance": stance,
+                "alliance_groups": session.alliance_groups,
+            }
+            msg = _add_orchestrator_message(
+                session, raw, kind="majority_report",
+                extra={"majority_members": members_names, "majority_stance": stance},
+            )
+            yield _sse("orchestrator", _msg_payload(msg))
+            return
+
+    # Not productive / no majority. First time -> surface unaddressed factor.
+    if session.consensus_attempts < 1:
+        session.consensus_attempts += 1
+        factor = await find_unaddressed_factor(
+            orchestrator_model_id=_orchestrator_model_id(session),
+            question=session.question,
+            credential_summary_block=cred_block,
+            transcript=transcript,
+            api_log=session.api_log,
+        )
+        _bump_orchestrator_count(session)
+        if factor and factor.get("factor"):
+            announce = (
+                f"The discussion has stalled. The orchestrator surfaces a new "
+                f"factor for the group to consider: {factor['factor']}"
+            )
+            msg = _add_orchestrator_message(
+                session, announce, kind="factor",
+                extra={"expected_to_shift": factor.get("expected_to_shift") or []},
+            )
+            yield _sse("orchestrator", _msg_payload(msg))
+            # Re-run the consensus phase once more
+            async for chunk in _phase_consensus(session):
+                yield chunk
+            async for chunk in _phase_closure(session):
+                yield chunk
+            return
+
+    # Failed twice (or no factor surfaced) -> emit no-consensus report
+    prompt = NO_CONSENSUS_REPORT_PROMPT.format(
+        question=session.question,
+        credential_summary=cred_block,
+        alliance_block="\n".join(
+            f"  - \"{g.get('stance', '')}\": "
+            + ", ".join(
+                p.name for p in actives
+                if p.participant_id in (g.get("members") or [])
+            )
+            for g in session.alliance_groups
+        ),
+        transcript=transcript,
+    )
+    raw, _ = await orchestrator_call(
+        orchestrator_model_id=_orchestrator_model_id(session),
+        user_prompt=prompt,
+        label="no_consensus_report",
+        api_log=session.api_log,
+        expect_json=False,
+        max_tokens=900,
+        temperature=0.3,
+    )
+    _bump_orchestrator_count(session)
+    session.final_report = {
+        "kind": "no_consensus",
+        "text": raw,
+        "alliance_groups": session.alliance_groups,
     }
+    msg = _add_orchestrator_message(session, raw, kind="no_consensus_report")
+    yield _sse("orchestrator", _msg_payload(msg))
 
 
-def _sse(event: str, data: dict) -> str:
-    return f"event: {event}\ndata: {json.dumps(data)}\n\n"
+# ---------------------------------------------------------------------------
+# Public driver
+# ---------------------------------------------------------------------------
+
+async def run_conversation(session: Session) -> AsyncIterator[str]:
+    """Drive the full six-phase conversation, yielding SSE chunks."""
+    actives = _active_participants(session)
+    if len(actives) < 2:
+        yield _sse("error", {
+            "message": "Need at least 2 active participants to start.",
+        })
+        yield _sse("done", {})
+        return
+    if len(actives) > session.max_participants:
+        # Defense in depth - the API layer should have already enforced this.
+        for extra in actives[session.max_participants:]:
+            extra.enabled = False
+
+    try:
+        async for chunk in _phase_initial_opinions(session):
+            yield chunk
+
+        async for chunk in _phase_critique(session, 1):
+            yield chunk
+        async for chunk in _phase_critique(session, 2):
+            yield chunk
+
+        async for chunk in _phase_status_assessment(session):
+            yield chunk
+
+        async for chunk in _phase_finalization(session):
+            yield chunk
+
+        async for chunk in _phase_consensus(session):
+            yield chunk
+
+        async for chunk in _phase_closure(session):
+            yield chunk
+    except Exception as exc:
+        LOG.exception("Conversation crashed: %s", exc)
+        yield _sse("error", {"message": f"Internal error: {exc}"})
+    finally:
+        session.finished = True
+        session.phase = Phase.FINISHED
+
+    # Build per-participant contribution summaries for the table view.
+    try:
+        await _build_contribution_summaries(session)
+    except Exception as exc:
+        LOG.warning("Failed to build contribution summaries: %s", exc)
+
+    yield _sse("system", {"text": "End of Chat", "phase": session.phase.value})
+    yield _sse("done", {})
+
+
+async def _build_contribution_summaries(session: Session) -> None:
+    actives = _active_participants(session)
+    roster = "\n".join(
+        f"- id: {p.participant_id} | name: {p.name}" for p in actives
+    )
+    transcript = _format_history(session.messages)
+    prompt = CONTRIBUTION_SUMMARY_PROMPT.format(
+        roster_block=roster,
+        transcript=transcript,
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=_orchestrator_model_id(session),
+        user_prompt=prompt,
+        label="contribution_summaries",
+        api_log=session.api_log,
+        max_tokens=900,
+    )
+    session.orchestrator_call_count += 1
+    if isinstance(parsed, dict) and isinstance(parsed.get("contributions"), list):
+        for c in parsed["contributions"]:
+            pid = c.get("participant_id")
+            summary = (c.get("summary") or "").strip()
+            if pid and summary:
+                session.contribution_summaries[pid] = summary

backend/app/services/prompts/__init__.py

@@ -0,0 +1,60 @@
+"""Per-phase prompt templates for the CCAI orchestrator.
+
+Each phase's templates live in their own file so prompt iteration doesn't
+churn the state machine in `orchestrator.py`. All templates here are pure
+strings; they're formatted and combined in `orchestrator.py`.
+"""
+
+from app.services.prompts.directives import (
+    PARTICIPANT_BASE_DIRECTIVE,
+    NO_REASONING_DIRECTIVE,
+    ORCHESTRATOR_BASE_DIRECTIVE,
+)
+from app.services.prompts.initial_opinions import INITIAL_OPINION_PROMPT
+from app.services.prompts.credential_summary import (
+    CREDENTIAL_BUILD_PROMPT,
+    CREDENTIAL_REFRESH_PROMPT,
+)
+from app.services.prompts.critique import CRITIQUE_PROMPT
+from app.services.prompts.status_assessment import (
+    STATUS_ASSESSMENT_PROMPT,
+    TARGETED_FOLLOWUP_PROMPT,
+)
+from app.services.prompts.finalization import FINALIZATION_PROMPT
+from app.services.prompts.consensus import (
+    ALLIANCE_DETECTION_PROMPT,
+    ADDRESSED_TO_PROMPT,
+    CONSENSUS_ALLIED_PROMPT,
+    CONSENSUS_SOLO_PROMPT,
+    CONSENSUS_TARGETED_RESPONSE_PROMPT,
+    CONSENSUS_STATUS_PROMPT,
+)
+from app.services.prompts.closure import (
+    UNADDRESSED_FACTOR_PROMPT,
+    MAJORITY_REPORT_PROMPT,
+    NO_CONSENSUS_REPORT_PROMPT,
+    CONTRIBUTION_SUMMARY_PROMPT,
+)
+
+__all__ = [
+    "PARTICIPANT_BASE_DIRECTIVE",
+    "NO_REASONING_DIRECTIVE",
+    "ORCHESTRATOR_BASE_DIRECTIVE",
+    "INITIAL_OPINION_PROMPT",
+    "CREDENTIAL_BUILD_PROMPT",
+    "CREDENTIAL_REFRESH_PROMPT",
+    "CRITIQUE_PROMPT",
+    "STATUS_ASSESSMENT_PROMPT",
+    "TARGETED_FOLLOWUP_PROMPT",
+    "FINALIZATION_PROMPT",
+    "ALLIANCE_DETECTION_PROMPT",
+    "ADDRESSED_TO_PROMPT",
+    "CONSENSUS_ALLIED_PROMPT",
+    "CONSENSUS_SOLO_PROMPT",
+    "CONSENSUS_TARGETED_RESPONSE_PROMPT",
+    "CONSENSUS_STATUS_PROMPT",
+    "UNADDRESSED_FACTOR_PROMPT",
+    "MAJORITY_REPORT_PROMPT",
+    "NO_CONSENSUS_REPORT_PROMPT",
+    "CONTRIBUTION_SUMMARY_PROMPT",
+]

backend/app/services/prompts/closure.py

@@ -0,0 +1,79 @@
+"""Phase 6: closure prompts (majority report, unaddressed-factor probe,
+no-consensus failure report, and per-participant contribution summaries
+used by the table view).
+"""
+
+UNADDRESSED_FACTOR_PROMPT = (
+    "The discussion has stalled in the consensus-gathering phase. As the "
+    "neutral orchestrator, review the conversation and the Credential "
+    "Summary. Identify ONE important factor that has not been adequately "
+    "discussed and that is likely to shift the opinion of at least one "
+    "current participant if surfaced.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Credential Summary:\n{credential_summary}\n\n"
+    "Conversation so far:\n{transcript}\n\n"
+    "Return JSON ONLY in this exact shape:\n"
+    "{{\n"
+    '  "factor": "<one short paragraph framing the factor as a question or consideration the group should now address>",\n'
+    '  "expected_to_shift": ["<participant_id>", "..."]\n'
+    "}}\n\n"
+    "The factor must be a real consideration that genuinely hasn't been "
+    "raised - not a rephrasing of what was already said. Output JSON only."
+)
+
+MAJORITY_REPORT_PROMPT = (
+    "The group has reached majority agreement in the discussion. As the "
+    "neutral orchestrator, produce a clear final report for the user who "
+    "asked the original question.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Credential Summary (with credibility_for_question scores):\n{credential_summary}\n\n"
+    "Majority alliance: members={majority_members}, stance=\"{majority_stance}\".\n\n"
+    "Full conversation:\n{transcript}\n\n"
+    "Write the report as plain prose (no markdown headers required) covering:\n"
+    "  1. The decision the group reached, in one or two clear sentences.\n"
+    "  2. The strongest reasons the majority gave.\n"
+    "  3. Important dissenting points raised by participants whose "
+    "credibility_for_question >= 0.6 - quote or paraphrase them by name. "
+    "Skip dissent from participants with credibility below 0.6.\n"
+    "  4. Caveats or open questions worth flagging for the user.\n\n"
+    "Stay neutral. Do not editorialize beyond what the participants said. "
+    "Keep the whole report under ~250 words."
+)
+
+NO_CONSENSUS_REPORT_PROMPT = (
+    "The group has tried twice to reach consensus and has not succeeded. "
+    "As the neutral orchestrator, produce a final report for the user who "
+    "asked the original question.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Credential Summary:\n{credential_summary}\n\n"
+    "Final alliance groups:\n{alliance_block}\n\n"
+    "Full conversation:\n{transcript}\n\n"
+    "Write the report as plain prose covering:\n"
+    "  1. A short statement that the group did not reach consensus.\n"
+    "  2. Each major opinion that emerged, who supported it (by name), "
+    "and the strongest reason given for it.\n"
+    "  3. Your own neutral recommendation for the most defensible position, "
+    "based purely on the strength of the arguments and the credibility_for_"
+    "question scores - not your own opinion. Make clear this is a "
+    "recommendation, not a decision.\n"
+    "  4. A brief suggestion that the user weigh these and make their own "
+    "decision.\n\n"
+    "Stay neutral. Keep the report under ~300 words."
+)
+
+CONTRIBUTION_SUMMARY_PROMPT = (
+    "Below is the full transcript of a multi-participant discussion. For "
+    "each listed participant, write a 2-3 sentence neutral summary of "
+    "their overall contribution: the position they took, how it evolved, "
+    "and the strongest argument they made. Do not editorialize. Do not "
+    "rank or grade them.\n\n"
+    "Participants:\n{roster_block}\n\n"
+    "Transcript:\n{transcript}\n\n"
+    "Return JSON ONLY in this exact shape:\n"
+    "{{\n"
+    '  "contributions": [\n'
+    '    {{ "participant_id": "<id>", "summary": "<2-3 sentences>" }}\n'
+    "  ]\n"
+    "}}\n\n"
+    "Output JSON only."
+)

backend/app/services/prompts/consensus.py

@@ -0,0 +1,112 @@
+"""Phase 5: consensus-gathering prompts.
+
+The orchestrator detects "alliance groups" of participants with similar
+revised opinions, then nudges them toward a group decision. Allied
+participants are prompted to argue and recruit; solo participants are
+prompted to seek allies, switch, or propose compromises.
+"""
+
+ALLIANCE_DETECTION_PROMPT = (
+    "Below are each participant's revised opinions from the finalization "
+    "phase. Your job, as the orchestrator, is to cluster them into "
+    "alliance groups: sets of participants whose opinions are similar "
+    "enough that they would naturally team up in a real meeting.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Revised opinions:\n{finalization_block}\n\n"
+    "Return JSON ONLY in this exact shape:\n"
+    "{{\n"
+    '  "groups": [\n'
+    "    {{\n"
+    '      "stance": "<one short sentence describing the shared position>",\n'
+    '      "members": ["<participant_id>", "..."]\n'
+    "    }}\n"
+    "  ]\n"
+    "}}\n\n"
+    "Every participant must appear in exactly one group. Solo participants "
+    "(no allies) get their own single-member group. Output JSON only."
+)
+
+ADDRESSED_TO_PROMPT = (
+    "Below is the most recent message in a multi-participant discussion. "
+    "Decide whether it is primarily aimed at one specific other participant "
+    "(e.g. challenging them, asking them a question, calling on them to "
+    "respond), or whether it is a broadcast to the whole group.\n\n"
+    "Available participants and their ids:\n{roster_block}\n\n"
+    "Speaker: {speaker}\n"
+    "Message: {message}\n\n"
+    "Return JSON ONLY: {{\"addressed_to\": \"<participant_id or null>\"}}. "
+    "Use the literal JSON null (no quotes) when no specific addressee is "
+    "obvious. Output JSON only."
+)
+
+CONSENSUS_ALLIED_PROMPT = (
+    "Phase 5 of the discussion: Consensus Gathering.\n\n"
+    "The orchestrator has clustered the group into alliances based on the "
+    "revised opinions. You are part of an alliance with: {alliance_members}. "
+    "Your shared stance: \"{alliance_stance}\".\n\n"
+    "Other groups currently disagree. Your job, in 4-8 sentences, is to "
+    "advocate for your alliance's position and try to win over participants "
+    "from other groups. Strategies that work in real human meetings:\n"
+    "  - Counter the main points of contrasting opinions with concrete facts "
+    "or arguments (cite specific things others said).\n"
+    "  - Reinforce your own side's main points with additional supporting "
+    "facts or by emphasizing the credibility of an ally on this topic.\n"
+    "  - Address specific participants by name when challenging or inviting "
+    "them.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Credential Summary:\n{credential_summary}\n\n"
+    "Conversation so far:\n{transcript}"
+)
+
+CONSENSUS_SOLO_PROMPT = (
+    "Phase 5 of the discussion: Consensus Gathering.\n\n"
+    "Right now you are the sole holder of your stance: \"{your_stance}\". "
+    "The other groups are: {other_groups_block}. In a real human meeting, "
+    "someone in your position has three good options - pick whichever fits "
+    "your character and what's been said:\n"
+    "  1. Pick the existing group whose stance is closest to yours and try "
+    "to get them to shift toward your view.\n"
+    "  2. Switch your support to whichever group's stance you can honestly "
+    "live with, naming them and explaining why.\n"
+    "  3. Propose a compromise position that both you and at least one "
+    "other group might find acceptable.\n\n"
+    "Respond in 4-8 sentences. Address other participants by name when "
+    "doing so makes sense. Stay in character.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Credential Summary:\n{credential_summary}\n\n"
+    "Conversation so far:\n{transcript}"
+)
+
+CONSENSUS_TARGETED_RESPONSE_PROMPT = (
+    "Phase 5 of the discussion: Consensus Gathering.\n\n"
+    "{addressed_by_name} just spoke and aimed their message at you "
+    "specifically. The orchestrator is giving you the floor to respond.\n\n"
+    "Their message: \"{addressed_message}\"\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Credential Summary:\n{credential_summary}\n\n"
+    "Conversation so far:\n{transcript}\n\n"
+    "Respond directly to {addressed_by_name} in 3-7 sentences. You may "
+    "concede a point, push back with a counter-argument, ask a clarifying "
+    "question, or propose a compromise. Stay in character."
+)
+
+CONSENSUS_STATUS_PROMPT = (
+    "Below is the discussion through the consensus-gathering phase so far. "
+    "As the orchestrator, decide whether (a) a majority has reached "
+    "agreement, (b) opinions are still actively shifting in a productive "
+    "direction, or (c) opinions have stopped shifting and the conversation "
+    "is no longer productive.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Latest alliance groups:\n{alliance_block}\n\n"
+    "Conversation so far:\n{transcript}\n\n"
+    "Return JSON ONLY in this exact shape:\n"
+    "{{\n"
+    '  "status": "<majority|productive|unproductive>",\n'
+    '  "majority_group_index": <integer index into alliance_groups, or null>,\n'
+    '  "rationale": "<one short sentence>"\n'
+    "}}\n\n"
+    "Use \"majority\" only if more than half of all participants now share a "
+    "single stance. Use \"unproductive\" only if the last few exchanges "
+    "have been repetitive or the participants are clearly entrenched. Output "
+    "JSON only."
+)

backend/app/services/prompts/credential_summary.py

@@ -0,0 +1,48 @@
+"""Credential Summary: the orchestrator's neutral assessment of each
+participant's expertise, personality, and credibility on the question.
+
+Built once after Phase 1 from each participant's role prompt + first
+opinion. Refreshed once after Phase 2 critique because participants
+reveal a lot more about themselves through critique than through their
+opening pitch.
+"""
+
+CREDENTIAL_BUILD_PROMPT = (
+    "Below is the question being discussed and, for each participant, "
+    "their role prompt and their first opinion (Phase 1). Build a Credential "
+    "Summary: a neutral, third-person assessment of each participant that "
+    "any other participant could use to weight their statements.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Participants:\n{participants_block}\n\n"
+    "Return JSON ONLY in this exact shape:\n"
+    "{{\n"
+    '  "credentials": [\n'
+    "    {{\n"
+    '      "participant_id": "<participant_id>",\n'
+    '      "name": "<participant_name>",\n'
+    '      "expertise": "<1-2 sentences on what they know about and don\'t know about>",\n'
+    '      "personality": "<1 sentence on debating style / temperament>",\n'
+    '      "credibility_for_question": <number 0.0 to 1.0>,\n'
+    '      "bias_to_watch": "<1 sentence on biases or blind spots>"\n'
+    "    }}\n"
+    "  ]\n"
+    "}}\n\n"
+    "credibility_for_question is YOUR neutral estimate of how much weight "
+    "their voice should carry on THIS specific question, given their stated "
+    "background and how they framed their first opinion. Use the full 0-1 "
+    "scale; do not bunch everyone near the top. Do NOT favor or disfavor "
+    "any participant. Output JSON only - no commentary, no markdown."
+)
+
+CREDENTIAL_REFRESH_PROMPT = (
+    "Below is the original Credential Summary you produced after Phase 1. "
+    "After two rounds of critique, the participants have revealed more "
+    "about themselves. Update the Credential Summary if anything material "
+    "changed: shifts in apparent expertise, observed reasoning quality, "
+    "newly visible biases, or revised credibility for THIS question. Keep "
+    "anything that's still accurate. Return JSON in the same shape as the "
+    "input. JSON only.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Original Credential Summary:\n{credential_summary_json}\n\n"
+    "Critique-round transcript:\n{critique_transcript}"
+)

backend/app/services/prompts/critique.py

@@ -0,0 +1,22 @@
+"""Phase 2: each participant gets two turns of critique."""
+
+CRITIQUE_PROMPT = (
+    "Phase 2 of the discussion: Critique (round {round_number} of 2).\n\n"
+    "The group has been asked the following question:\n\n"
+    "<<<\n{question}\n>>>\n\n"
+    "Here is a Credential Summary the orchestrator built about each "
+    "participant. Use it the way a thoughtful person in a real meeting would: "
+    "weight statements appropriately, but don't let it shut down good ideas "
+    "from less-credentialed voices.\n\n"
+    "Credential Summary:\n{credential_summary}\n\n"
+    "Conversation so far:\n{transcript}\n\n"
+    "It is now your turn. In a focused 5-10 sentence response:\n"
+    "  1. Offer constructive criticism of one or more other participants' "
+    "opinions, naming them directly. Cite specific points, not vibes.\n"
+    "  2. Ask any follow-up questions of specific participants where you "
+    "want a clearer answer.\n"
+    "  3. Revise your own opinion if (and only if) the discussion has "
+    "given you reason to. If you've revised, say so explicitly.\n\n"
+    "Stay in character. Do not try to wrap up the discussion - we are not "
+    "near the end yet."
+)

backend/app/services/prompts/directives.py

@@ -0,0 +1,39 @@
+"""Shared directive blocks injected into every participant / orchestrator call."""
+
+# Always appended to a participant's role_prompt before any phase template.
+# Establishes the CCAI ground rules: you are one of N participants, the
+# orchestrator runs the conversation, you don't speak for anyone else and
+# you don't speak out of turn.
+PARTICIPANT_BASE_DIRECTIVE = (
+    "You are one of {n_participants} participants in a structured group "
+    "discussion facilitated by a neutral orchestrator. The other "
+    "participants are: {other_participants}. The orchestrator will tell "
+    "you when it is your turn, what phase of the discussion you are in, "
+    "and exactly what is being asked of you. Do NOT simulate the other "
+    "participants, do NOT speak out of turn, and do NOT address the "
+    "orchestrator as if it were one of the participants - it has no "
+    "opinion and is not part of the decision."
+)
+
+# Same hard "no reasoning, no meta-commentary" guard the upstream LLMChats3
+# orchestrator used. Always appended to the system message of any
+# participant call. The sanitizer in app.utils.sanitize is the actual
+# guarantee, but this directive makes a lot of models cooperate.
+NO_REASONING_DIRECTIVE = (
+    "IMPORTANT: Respond ONLY with your in-character contribution. Do NOT "
+    "include your reasoning, thought process, analysis of the prompt, "
+    "meta-commentary, internal monologue, scratchpad, draft notes, or any "
+    "tags such as <think>, <reasoning>, or <scratchpad>. Output ONLY the "
+    "words your character would actually say to the group."
+)
+
+# Used as the system prompt for every orchestrator-side LLM call (status
+# checks, alliance detection, addressed-to classification, summaries).
+ORCHESTRATOR_BASE_DIRECTIVE = (
+    "You are the neutral orchestrator of a structured group discussion. "
+    "You do NOT have an opinion on the question being discussed, you do "
+    "NOT pick a side, and you do NOT decide any issue. Your only job is "
+    "to assess the conversation and produce the exact output format the "
+    "instruction asks for. When the instruction asks for JSON, return ONLY "
+    "valid JSON with no surrounding prose, markdown fences, or commentary."
+)

backend/app/services/prompts/finalization.py

@@ -0,0 +1,22 @@
+"""Phase 4: each participant either states a revised post-discussion
+opinion or endorses another participant's revised opinion (with optional
+added comment).
+"""
+
+FINALIZATION_PROMPT = (
+    "Phase 4 of the discussion: Opinion Finalization.\n\n"
+    "The question:\n<<<\n{question}\n>>>\n\n"
+    "Credential Summary:\n{credential_summary}\n\n"
+    "Full conversation so far:\n{transcript}\n\n"
+    "Now, considering everything that has been said, state your post-"
+    "discussion opinion. You have two options:\n\n"
+    "  Option A - State your own revised opinion. If you have moved at all "
+    "from your first opinion, say what changed and why.\n\n"
+    "  Option B - Endorse another participant's revised opinion. Name the "
+    "participant. Optionally add a sentence or two of your own (a caveat, "
+    "an additional argument, a slight tweak).\n\n"
+    "Begin your response with one of:\n"
+    "  - \"My revised opinion:\" (if Option A)\n"
+    "  - \"I agree with <participant name>:\" (if Option B)\n\n"
+    "Keep the whole response under 10 sentences."
+)

backend/app/services/prompts/initial_opinions.py

@@ -0,0 +1,24 @@
+"""Phase 1: each participant offers an *independent* first opinion.
+
+The orchestrator hides every other participant's response until the round
+is finished, so first opinions are genuinely independent. That is what
+makes the Credential Summary in the next step meaningful.
+"""
+
+INITIAL_OPINION_PROMPT = (
+    "Phase 1 of the discussion: First Opinions.\n\n"
+    "The group has been asked the following question:\n\n"
+    "<<<\n{question}\n>>>\n\n"
+    "You are speaking before any other participant has shared their view. "
+    "Read the question carefully, consider it through the lens of who you "
+    "are (your background, expertise, values, and personality), and offer "
+    "your initial opinion.\n\n"
+    "Your first opinion should:\n"
+    "  1. Take a clear, specific position on the question.\n"
+    "  2. Explain the 1-3 most important reasons behind your position, "
+    "drawing on your particular background or expertise.\n"
+    "  3. Acknowledge any uncertainty or trade-offs you see.\n\n"
+    "Speak in the first person. Keep it focused: 4-8 sentences. Do not "
+    "address other participants by name yet - you have not heard them "
+    "speak."
+)

backend/app/services/prompts/status_assessment.py

@@ -0,0 +1,38 @@
+"""Phase 3: orchestrator decides whether the conversation needs more
+targeted follow-ups before moving to finalization.
+"""
+
+STATUS_ASSESSMENT_PROMPT = (
+    "Below is the question being discussed, the current Credential Summary, "
+    "and the conversation transcript through the critique rounds. Your job, "
+    "as the orchestrator, is to decide whether the participants have "
+    "solidified their opinions or whether there are still important open "
+    "questions that warrant a targeted follow-up to specific participants "
+    "before we move on to opinion finalization.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Credential Summary:\n{credential_summary}\n\n"
+    "Conversation so far:\n{transcript}\n\n"
+    "Return JSON ONLY in this exact shape:\n"
+    "{{\n"
+    '  "opinions_solidified": <true|false>,\n'
+    '  "open_questions": [\n'
+    '    {{ "participant_id": "<participant_id>", "question": "<one direct question>" }}\n'
+    "  ],\n"
+    '  "notes": "<one short sentence on the discussion state>"\n'
+    "}}\n\n"
+    "If opinions are clearly solidified, return an empty open_questions list "
+    "and opinions_solidified=true. Otherwise list 1-3 high-leverage "
+    "questions, each aimed at one specific participant by participant_id. "
+    "Each follow-up should target a real ambiguity or unresolved disagreement "
+    "in the transcript - never invent topics that haven't come up. Output "
+    "JSON only."
+)
+
+TARGETED_FOLLOWUP_PROMPT = (
+    "The orchestrator has a follow-up question for you specifically.\n\n"
+    "Conversation so far:\n{transcript}\n\n"
+    "Credential Summary of the group:\n{credential_summary}\n\n"
+    "Follow-up question for you: {targeted_question}\n\n"
+    "Answer the question directly, in 3-6 sentences. You may reference "
+    "other participants' statements by name. Stay in character."
+)

backend/app/utils/sanitize.py

@@ -0,0 +1,81 @@
+"""Centralized sanitizer for LLM responses.
+
+CCAI conversations don't work well when thinking traces leak into chat or
+into orchestrator/summarizer/Credential-Summary inputs, so every LLM
+response funnels through `strip_thinking` before being stored, displayed,
+or forwarded to another LLM.
+"""
+from __future__ import annotations
+
+import re
+
+# Top-level reasoning blocks emitted as XML-ish tags. DOTALL so we catch
+# multi-line reasoning blocks; non-greedy so adjacent blocks don't merge.
+_THINK_TAG_RE = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
+_REASONING_BLOCK_RE = re.compile(
+    r"<(reasoning|reflection|inner_thoughts|scratchpad|analysis|plan)>.*?</\1>",
+    re.DOTALL | re.IGNORECASE,
+)
+
+# Bare "thought:" / "reasoning:" prologues some models emit before content
+# (only at the very start of the response, otherwise we'd nuke the body).
+_PROLOGUE_RE = re.compile(
+    r"^\s*(thought|thinking|reasoning|analysis|scratchpad)\s*:\s*"
+    r".*?(?=\n\n|\Z)",
+    re.DOTALL | re.IGNORECASE,
+)
+
+# Some providers wrap thinking in special framing tokens. We try to strip
+# the *paired* form (open ... close) first so the body in between is
+# removed, and fall back to stripping any leftover bare markers.
+_PAIRED_FRAMING_RES = [
+    re.compile(r"<\|reasoning\|>.*?<\|/reasoning\|>", re.DOTALL | re.IGNORECASE),
+    re.compile(r"<\|think\|>.*?<\|/think\|>", re.DOTALL | re.IGNORECASE),
+]
+_FRAMING_TOKENS = ["<|reasoning|>", "<|/reasoning|>", "<|think|>", "<|/think|>"]
+
+
+def strip_thinking(text: str | None) -> str:
+    """Return `text` with all reasoning artifacts removed.
+
+    Safe to call on empty, whitespace-only, or None inputs (returns empty
+    string in those cases). Idempotent: calling twice yields the same result.
+    """
+    if not text:
+        return ""
+
+    out = _THINK_TAG_RE.sub("", text)
+    out = _REASONING_BLOCK_RE.sub("", out)
+
+    for paired in _PAIRED_FRAMING_RES:
+        out = paired.sub("", out)
+    for tok in _FRAMING_TOKENS:
+        out = out.replace(tok, "")
+
+    out = _PROLOGUE_RE.sub("", out)
+
+    return out.strip()
+
+
+def response_has_thinking(text: str | None, msg: dict | None = None) -> bool:
+    """Return True if the raw response had any thinking artifact.
+
+    Checks both the textual content and any `reasoning_content` /
+    `reasoning` fields the OpenAI-compat client may have surfaced.
+    """
+    if msg is not None:
+        if msg.get("reasoning_content") or msg.get("reasoning"):
+            return True
+
+    if not text:
+        return False
+
+    if _THINK_TAG_RE.search(text):
+        return True
+    if _REASONING_BLOCK_RE.search(text):
+        return True
+    if any(tok in text for tok in _FRAMING_TOKENS):
+        return True
+    if _PROLOGUE_RE.match(text):
+        return True
+    return False

backend/requirements.txt

@@ -5,4 +5,5 @@ pydantic-settings>=2.6.0
 python-multipart>=0.0.12
 python-dotenv>=1.0.0
 huggingface_hub>=0.25.0
-itsdangerous>=2.2.0
+itsdangerous>=2.2.0
+pytest>=8.0.0

backend/tests/test_context_budget.py

@@ -0,0 +1,97 @@
+from app.services.context_budget import (
+    ContextSummary,
+    DEFAULT_CONTEXT,
+    DEFAULT_REPLY_BUDGET,
+    SUMMARIZE_THRESHOLD,
+    TRIM_THRESHOLD,
+    build_compressed_messages,
+    context_window_for,
+    estimate_messages_tokens,
+    select_summarizer_model_id,
+    should_summarize,
+)
+
+
+def test_context_window_known_model():
+    assert context_window_for("gpt-4.1-mini") == 128_000
+
+
+def test_context_window_unknown_falls_back():
+    assert context_window_for("totally-unknown") == DEFAULT_CONTEXT
+
+
+def test_context_window_neon_falls_back():
+    assert context_window_for("neon:Foo/Bar@2025.10.01:Researcher") == DEFAULT_CONTEXT
+
+
+def test_estimate_tokens_grows_with_text():
+    a = estimate_messages_tokens([{"role": "user", "content": "hi"}])
+    b = estimate_messages_tokens([{"role": "user", "content": "hi" * 1000}])
+    assert b > a
+
+
+def test_should_summarize_below_threshold():
+    """A small ~10-token prompt against a 1M-token gemini window: never
+    should we trigger summarize.
+    """
+    summary = ContextSummary()
+    api = [{"role": "user", "content": "hello"}]
+    needs_sum, needs_trim, _ = should_summarize("gemini-2.5-flash", api, summary)
+    assert needs_sum is False
+    assert needs_trim is False
+
+
+def test_should_summarize_above_threshold_triggers_summarize():
+    summary = ContextSummary()
+    big = "x" * 10_000  # ~2500 estimated tokens
+    api = [
+        {"role": "system", "content": big},
+        {"role": "user", "content": big},
+    ]
+    # Small 8K-window model -> 6K input budget -> 55% = 3300; we're way over.
+    needs_sum, _, budget = should_summarize("totally-unknown", api, summary)
+    assert needs_sum is True
+    assert budget >= 2_048
+
+
+def test_should_trim_only_when_summary_exists():
+    """Even at 70%, trim should only happen once we already have a
+    running summary - otherwise we'd drop history with no replacement.
+    """
+    summary = ContextSummary()
+    big = "x" * 30_000
+    api = [
+        {"role": "system", "content": big},
+        {"role": "user", "content": big},
+    ]
+    _, needs_trim_no_sum, _ = should_summarize("totally-unknown", api, summary)
+    assert needs_trim_no_sum is False
+
+    summary.summary_text = "Previously, the group discussed X."
+    _, needs_trim_yes_sum, _ = should_summarize("totally-unknown", api, summary)
+    assert needs_trim_yes_sum is True
+
+
+def test_build_compressed_keeps_system_and_recent():
+    summary = ContextSummary(summary_text="condensed history")
+    msgs = [
+        {"role": "system", "content": "you are X"},
+        {"role": "user", "content": "old1"},
+        {"role": "assistant", "content": "oldA"},
+        {"role": "user", "content": "old2"},
+        {"role": "assistant", "content": "oldB"},
+        {"role": "user", "content": "recent"},
+    ]
+    out = build_compressed_messages(msgs, summary, needs_trim=True)
+    # head + summary + last KEEP_RECENT_MESSAGES (=6) <= len(msgs) so we
+    # might end up with everything; the contract is just that the
+    # original system and the running summary are preserved.
+    assert out[0] == msgs[0]
+    assert any("Summary of earlier" in m["content"] for m in out)
+
+
+def test_select_summarizer_falls_back():
+    # Override wins
+    assert select_summarizer_model_id("custom", "orch") == "custom"
+    # Falls back to orchestrator if no override
+    assert select_summarizer_model_id(None, "orch") == "orch"

backend/tests/test_csv_export.py

@@ -0,0 +1,98 @@
+from app.api.chat import _export_csv_table
+from app.services.models import Phase, Session
+from app.services.models import Participant
+
+
+def _mk_session():
+    s = Session()
+    s.question = "Will \"AI\" change, education? Yes, no, maybe.\nNew lines too."
+    p1 = Participant(
+        participant_id="extra_a",
+        name="Alice",
+        role_prompt="rp",
+        model_id="model-a",
+        kind="extra",
+        display_name="Provider/Model A",
+    )
+    p2 = Participant(
+        participant_id="expert_b",
+        name="Bob, Ph.D.",
+        role_prompt="rp",
+        model_id="model-b",
+        kind="expert",
+        display_name="Provider/Model B",
+    )
+    s.participants = [p1, p2]
+    s.initial_opinions = {
+        "extra_a": "Alice's, opinion has commas, and \"quotes\".",
+        "expert_b": "Bob's\nmulti-line\nopinion.",
+    }
+    s.contribution_summaries = {
+        "extra_a": "Stayed firm.",
+        "expert_b": "Pushed hard.",
+    }
+    s.final_opinions = {
+        "extra_a": "Final A",
+        "expert_b": "Final B",
+    }
+    s.messages = [
+        {
+            "speaker_id": "extra_a", "speaker_name": "Alice",
+            "role": "participant", "phase": Phase.CONSENSUS.value,
+            "text": "Final consensus statement A",
+        },
+        {
+            "speaker_id": "expert_b", "speaker_name": "Bob, Ph.D.",
+            "role": "participant", "phase": Phase.CONSENSUS.value,
+            "text": "Final consensus statement B",
+        },
+    ]
+    s.final_report = {"kind": "majority", "text": "Group decided X."}
+    return s
+
+
+def test_csv_export_roundtrips_through_csv_module():
+    """Ensure values containing commas, quotes, and newlines get quoted
+    correctly per RFC 4180."""
+    import csv
+    import io
+
+    s = _mk_session()
+    out = _export_csv_table(s)
+    assert out["filename"] == "ccai_chat_table.csv"
+    parsed = list(csv.reader(io.StringIO(out["content"])))
+    # Header is question, then final, then blank, then column row.
+    assert parsed[0][0] == "Question"
+    assert "AI" in parsed[0][1] and "education" in parsed[0][1]
+    assert parsed[1][0] == "Final Group Opinion"
+    assert "Group decided X." in parsed[1][1]
+    # blank row
+    assert parsed[2] == []
+    # column header row
+    assert parsed[3] == [
+        "Participant",
+        "First opinion",
+        "Conversation contribution",
+        "Revised opinion",
+        "Final opinion",
+    ]
+    alice_row = parsed[4]
+    assert alice_row[0] == "Alice"
+    assert "\"quotes\"" in alice_row[1]  # csv module preserved the quotes
+    bob_row = parsed[5]
+    assert bob_row[0] == "Bob, Ph.D."
+    assert "multi-line" in bob_row[1]
+
+
+def test_csv_export_no_field_count_drift():
+    """Every row after the header should have exactly 5 columns even when
+    payload contains pathological characters."""
+    import csv
+    import io
+
+    s = _mk_session()
+    out = _export_csv_table(s)
+    rows = list(csv.reader(io.StringIO(out["content"])))
+    data_rows = rows[4:]
+    for row in data_rows:
+        assert len(row) == 5

backend/tests/test_json_calls.py

@@ -0,0 +1,48 @@
+from app.services.json_calls import parse_json_response
+
+
+def test_plain_json_object():
+    assert parse_json_response('{"a": 1}') == {"a": 1}
+
+
+def test_plain_json_array():
+    assert parse_json_response('[1, 2, 3]') == [1, 2, 3]
+
+
+def test_markdown_fence():
+    raw = "```json\n{\"a\": 1}\n```"
+    assert parse_json_response(raw) == {"a": 1}
+
+
+def test_markdown_fence_no_lang():
+    raw = "```\n{\"a\": 1}\n```"
+    assert parse_json_response(raw) == {"a": 1}
+
+
+def test_prose_then_json():
+    raw = "Sure, here's the result:\n\n{\"a\": 1, \"b\": [2,3]}"
+    assert parse_json_response(raw) == {"a": 1, "b": [2, 3]}
+
+
+def test_json_then_prose():
+    raw = "{\"a\": 1}\nThe end."
+    assert parse_json_response(raw) == {"a": 1}
+
+
+def test_nested_braces_ok():
+    raw = "Look:\n{\"outer\": {\"inner\": [1, {\"k\": \"v\"}]}}"
+    assert parse_json_response(raw) == {"outer": {"inner": [1, {"k": "v"}]}}
+
+
+def test_string_with_braces_doesnt_confuse_balancer():
+    raw = '{"text": "this has } and { in it", "ok": true}'
+    assert parse_json_response(raw) == {"text": "this has } and { in it", "ok": True}
+
+
+def test_unparseable_returns_none():
+    assert parse_json_response("not json at all") is None
+
+
+def test_empty_returns_none():
+    assert parse_json_response("") is None
+    assert parse_json_response(None) is None

backend/tests/test_sanitize.py

@@ -0,0 +1,60 @@
+from app.utils.sanitize import strip_thinking, response_has_thinking
+
+
+def test_strip_simple_think_tag():
+    assert strip_thinking("<think>plan</think>final") == "final"
+
+
+def test_strip_multiline_think_tag():
+    raw = "<think>line1\nline2\n</think>actual reply"
+    assert strip_thinking(raw) == "actual reply"
+
+
+def test_strip_nested_reasoning_blocks():
+    raw = (
+        "<reasoning>step 1\nstep 2</reasoning>"
+        "<analysis>more thinking</analysis>"
+        "real text"
+    )
+    assert strip_thinking(raw) == "real text"
+
+
+def test_strip_multiple_think_blocks():
+    raw = "<think>a</think>middle<think>b</think>end"
+    assert strip_thinking(raw) == "middleend"
+
+
+def test_strip_uppercase_tag():
+    assert strip_thinking("<THINK>plan</THINK>final") == "final"
+
+
+def test_idempotent():
+    cleaned = strip_thinking("<think>foo</think>bar")
+    assert strip_thinking(cleaned) == cleaned
+
+
+def test_empty_inputs_safe():
+    assert strip_thinking(None) == ""
+    assert strip_thinking("") == ""
+    assert strip_thinking("   \n\t  ") == ""
+
+
+def test_thought_prologue():
+    raw = "Thought: I should probably mention X.\n\nReal response here."
+    assert strip_thinking(raw) == "Real response here."
+
+
+def test_response_has_thinking_via_text():
+    assert response_has_thinking("<think>plan</think>x")
+    assert not response_has_thinking("just plain text")
+
+
+def test_response_has_thinking_via_msg_field():
+    assert response_has_thinking("plain text", {"reasoning_content": "stuff"})
+    assert response_has_thinking("plain text", {"reasoning": "stuff"})
+    assert not response_has_thinking("plain text", {"content": "x"})
+
+
+def test_strip_framing_tokens():
+    raw = "<|reasoning|>plan<|/reasoning|>final"
+    assert strip_thinking(raw) == "final"

docker-compose.yml

@@ -2,9 +2,12 @@ services:
   app:
     build: .
     ports:
-      - "8000:8000"
+      # Match the HuggingFace Space app_port so docker compose and HF
+      # behave identically. The container always listens on 7860.
+      - "7860:7860"
     env_file:
       - .env
     environment:
-      CORS_ORIGINS: "http://localhost:8000,http://localhost:3000"
+      CORS_ORIGINS: "http://localhost:7860,http://localhost:3000"
+      HF_RATE_LIMIT_DAILY: "30"
     restart: unless-stopped

frontend/package-lock.json

@@ -16725,23 +16725,6 @@
         }
       }
     },
-    "node_modules/tailwindcss/node_modules/yaml": {
-      "version": "2.8.3",
-      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.3.tgz",
-      "integrity": "sha512-AvbaCLOO2Otw/lW5bmh9d/WEdcDFdQp2Z2ZUH3pX9U2ihyUY0nvLv7J6TrWowklRGPYbB/IuIMfYgxaCPg5Bpg==",
-      "license": "ISC",
-      "optional": true,
-      "peer": true,
-      "bin": {
-        "yaml": "bin.mjs"
-      },
-      "engines": {
-        "node": ">= 14.6"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/eemeli"
-      }
-    },
     "node_modules/tapable": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.0.tgz",

frontend/src/App.js

@@ -1,81 +1,102 @@
 import React, { useState, useEffect, useCallback, useRef, useMemo } from 'react';
-import { Sun, Moon } from 'lucide-react';
-import LLMSelector from './components/LLMSelector';
-import PersonaAccordion from './components/PersonaAccordion';
+import Header from './components/Header';
+import ParticipantSidebar from './components/ParticipantSidebar';
 import ChatControls from './components/ChatControls';
 import ChatArea from './components/ChatArea';
-import DevMenu from './components/DevMenu';
-import AuthBadge from './components/AuthBadge';
-import { fetchModels, generateRole, generateRoleFreeform, startChat, getOrchestrator, setOrchestrator, getSpeedPriority, setSpeedPriority, exportChat, exportApiLog, getAuthStatus } from './utils/api';
+import ExpertPersonaModal from './components/ExpertPersonaModal';
+import ChatTableView from './components/ChatTableView';
+import {
+  fetchModels, fetchPersonas, fetchDemoQuestions,
+  startChat, continueChat, getOrchestrator, setOrchestrator,
+  getSpeedPriority, setSpeedPriority, getAuthStatus,
+  exportChat, exportApiLog, fetchTableView, getRateLimitStatus,
+} from './utils/api';
+import * as storage from './utils/storage';
 import './styles/variables.css';
 import './styles/layout.css';
 import './styles/components.css';
+import './styles/ccai.css';
 
-const EMPTY_PERSONA = { name: '', profile: '', identity: '', samples: '' };
-
-function getDisplayName(modelId, providers, neonModels) {
-  if (!modelId) return '';
-  if (modelId.startsWith('neon:')) {
-    return modelId.split(':')[2] || modelId;
-  }
-  for (const p of (providers || [])) {
-    for (const m of p.models) {
-      if (m.id === modelId) return m.name;
-    }
-  }
-  return modelId;
+function pickRandom(list) {
+  if (!list || list.length === 0) return null;
+  return list[Math.floor(Math.random() * list.length)];
 }
 
 export default function App() {
-  const [theme, setTheme] = useState(() =>
-    window.matchMedia?.('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'
+  // Persistent state
+  const persisted = useMemo(() => storage.loadState(), []);
+  const [theme, setTheme] = useState(() => persisted.theme
+    || (window.matchMedia?.('(prefers-color-scheme: dark)').matches ? 'dark' : 'light')
   );
+  const [expertPersonas, setExpertPersonas] = useState(persisted.expert_personas || []);
+  const [selectedIds, setSelectedIds] = useState(persisted.participants_selected || []);
+  const [enabledMap, setEnabledMap] = useState(persisted.participants_enabled || {});
+  const [modelAssignments, setModelAssignments] = useState(persisted.model_assignments || {});
+  const [orchestratorModel, setOrchestratorModelState] = useState(persisted.orchestrator_model_id);
+  const [summarizerModel, setSummarizerModelState] = useState(persisted.summarizer_model_id);
+  const [maxParticipants, setMaxParticipants] = useState(persisted.max_participants || 5);
+
+  // Backend catalog
   const [providers, setProviders] = useState([]);
   const [neonModels, setNeonModels] = useState([]);
-  const [selections, setSelections] = useState([]);
-  const [personaA, setPersonaA] = useState({ ...EMPTY_PERSONA });
-  const [personaB, setPersonaB] = useState({ ...EMPTY_PERSONA });
-  const [accordionOpen, setAccordionOpen] = useState(true);
+  const [catalog, setCatalog] = useState({ neon: [], extra: [] });
+  const [demoQuestions, setDemoQuestions] = useState([]);
+
+  // Display options
+  const [speedPriority, setSpeedPriorityState] = useState(false);
+  const [showResponseTime, setShowResponseTime] = useState(false);
+  const [showChatStats, setShowChatStats] = useState(false);
+
+  // Auth + rate limit
+  const [auth, setAuth] = useState(null);
+  const [dailyLimit, setDailyLimit] = useState(30);
+
+  // Conversation state
   const [messages, setMessages] = useState([]);
   const [systemMessages, setSystemMessages] = useState([]);
   const [isRunning, setIsRunning] = useState(false);
   const [statusText, setStatusText] = useState('');
   const [sessionId, setSessionId] = useState(null);
-  const [chatFinished, setChatFinished] = useState(false);
-  const [orchestratorModel, setOrchestratorModel] = useState('');
-  const [personaMode, setPersonaMode] = useState('freeform');
-  const [roleStyle, setRoleStyle] = useState('ai_completed');
-  const [speedPriority, setSpeedPriorityState] = useState(false);
-  const [auth, setAuth] = useState(null);
-  const [showResponseTime, setShowResponseTime] = useState(false);
-  const [showChatStats, setShowChatStats] = useState(false);
-  const [rolePrompts, setRolePrompts] = useState(null);
-  const [rolePromptsOpen, setRolePromptsOpen] = useState(false);
+  const [sessionParticipants, setSessionParticipants] = useState([]);
+  const [pause, setPause] = useState(null);
+
+  // Modals
+  const [expertModalOpen, setExpertModalOpen] = useState(false);
+  const [expertEditing, setExpertEditing] = useState(null);
+  const [tableData, setTableData] = useState(null);
+  const [tableOpen, setTableOpen] = useState(false);
+
   const abortRef = useRef(null);
-  const lastRoleConfigRef = useRef(null);
 
+  // ─── Apply theme ────────────────────────────────────────────────
   useEffect(() => {
     document.documentElement.setAttribute('data-theme', theme);
+    storage.setTheme(theme);
   }, [theme]);
 
-
-
+  // ─── Load catalogs ──────────────────────────────────────────────
   useEffect(() => {
-    fetchModels()
-      .then(data => {
-        setProviders(data.providers || []);
-        setNeonModels(data.neon_models || []);
-      })
-      .catch(err => console.error('Failed to load models:', err));
-    getOrchestrator()
-      .then(data => setOrchestratorModel(data.model_id || ''))
-      .catch(() => {});
-    getSpeedPriority()
-      .then(data => setSpeedPriorityState(!!data.enabled))
-      .catch(() => {});
+    fetchModels().then(d => {
+      setProviders(d.providers || []);
+      setNeonModels(d.neon_models || []);
+    }).catch(err => console.error('Failed to load models:', err));
+    fetchPersonas().then(setCatalog).catch(err => console.error('Failed to load personas:', err));
+    fetchDemoQuestions().then(d => setDemoQuestions(d.questions || []))
+      .catch(err => console.error('Failed to load demo questions:', err));
+    getOrchestrator().then(d => {
+      // Only sync if user hasn't explicitly chosen one (localStorage wins)
+      if (!persisted.orchestrator_model_id && d?.model_id) {
+        setOrchestratorModelState(d.model_id);
+      }
+    }).catch(() => {});
+    getSpeedPriority().then(d => setSpeedPriorityState(!!d.enabled)).catch(() => {});
     getAuthStatus().then(setAuth).catch(() => {});
-  }, []);
+    getRateLimitStatus().then(d => {
+      if (d?.daily_limit) setDailyLimit(d.daily_limit);
+    }).catch(() => {});
+  }, [persisted.orchestrator_model_id]);
 
+  // ─── Build a flat list of all models for pickers ────────────────
   const allModelsFlat = useMemo(() => {
     const list = [];
     for (const p of providers) {
@@ -96,31 +117,127 @@ export default function App() {
     return list;
   }, [providers, neonModels]);
 
+  // ─── Active participants resolved from selectedIds ──────────────
+  const allCatalogParticipants = useMemo(() => {
+    const map = {};
+    for (const p of (catalog.neon || [])) map[p.participant_id] = p;
+    for (const p of (catalog.extra || [])) map[p.participant_id] = p;
+    for (const p of (expertPersonas || [])) map[p.participant_id] = p;
+    return map;
+  }, [catalog, expertPersonas]);
+
+  const selectedParticipants = useMemo(() => {
+    return selectedIds
+      .map(id => allCatalogParticipants[id])
+      .filter(Boolean);
+  }, [selectedIds, allCatalogParticipants]);
+
+  const enabledSelectedCount = useMemo(() => {
+    return selectedParticipants.filter(p => enabledMap[p.participant_id] !== false).length;
+  }, [selectedParticipants, enabledMap]);
+
+  // ─── Persistence ────────────────────────────────────────────────
+  useEffect(() => { storage.setExpertPersonas(expertPersonas); }, [expertPersonas]);
+  useEffect(() => { storage.setParticipantsSelected(selectedIds); }, [selectedIds]);
+  useEffect(() => { storage.setParticipantsEnabled(enabledMap); }, [enabledMap]);
+  useEffect(() => { storage.setModelAssignments(modelAssignments); }, [modelAssignments]);
+  useEffect(() => { storage.setOrchestratorModelId(orchestratorModel); }, [orchestratorModel]);
+  useEffect(() => { storage.setSummarizerModelId(summarizerModel); }, [summarizerModel]);
+  useEffect(() => { storage.setMaxParticipants(maxParticipants); }, [maxParticipants]);
+
+  // ─── Settings handlers ──────────────────────────────────────────
   const handleOrchestratorChange = useCallback(async (modelId) => {
     try {
       await setOrchestrator(modelId || '');
-      setOrchestratorModel(modelId || '');
+      setOrchestratorModelState(modelId || null);
     } catch (err) {
       console.error('Failed to set orchestrator:', err);
     }
   }, []);
-
-  const handlePersonaModeChange = useCallback((mode) => {
-    setPersonaMode(mode);
-    setRoleStyle(mode === 'freeform' ? 'ai_completed' : 'exact');
+  const handleSummarizerChange = useCallback((modelId) => {
+    setSummarizerModelState(modelId || null);
   }, []);
-
   const handleSpeedPriorityChange = useCallback(async (enabled) => {
     try {
       await setSpeedPriority(enabled);
       setSpeedPriorityState(enabled);
-    } catch (err) {
-      console.error('Failed to set speed priority:', err);
+    } catch (err) { console.error('Failed to set speed priority:', err); }
+  }, []);
+  const handleMaxParticipantsChange = useCallback((n) => {
+    const clamped = Math.max(3, Math.min(9, n));
+    setMaxParticipants(clamped);
+    if (selectedIds.length > clamped) {
+      setSelectedIds(prev => prev.slice(0, clamped));
     }
+  }, [selectedIds]);
+  const handleModelAssignmentChange = useCallback((participantId, modelId) => {
+    setModelAssignments(prev => {
+      const next = { ...prev };
+      if (modelId) next[participantId] = modelId;
+      else delete next[participantId];
+      return next;
+    });
+  }, []);
+
+  // ─── Participant ops ────────────────────────────────────────────
+  const handleToggleParticipant = useCallback((participant, kind) => {
+    const id = participant.participant_id;
+    setSelectedIds(prev => {
+      if (prev.includes(id)) {
+        // Deselect entirely
+        setEnabledMap(em => {
+          const next = { ...em };
+          delete next[id];
+          return next;
+        });
+        return prev.filter(x => x !== id);
+      }
+      if (prev.length >= maxParticipants) return prev;
+      setEnabledMap(em => ({ ...em, [id]: true }));
+      return [...prev, id];
+    });
+  }, [maxParticipants]);
+
+  const handleSidebarToggleEnabled = useCallback((participantId, enabled) => {
+    setEnabledMap(em => ({ ...em, [participantId]: enabled }));
+  }, []);
+
+  const handleSidebarRemove = useCallback((participantId) => {
+    setSelectedIds(prev => prev.filter(x => x !== participantId));
+    setEnabledMap(em => {
+      const next = { ...em };
+      delete next[participantId];
+      return next;
+    });
   }, []);
 
-  const downloadFile = useCallback((filename, content) => {
-    const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
+  // ─── Expert persona ops ─────────────────────────────────────────
+  const handleOpenExpertModal = useCallback((personaOrNull) => {
+    setExpertEditing(personaOrNull);
+    setExpertModalOpen(true);
+  }, []);
+  const handleSaveExpert = useCallback((persona) => {
+    setExpertPersonas(prev => {
+      const idx = prev.findIndex(p => p.participant_id === persona.participant_id);
+      if (idx === -1) return [...prev, persona];
+      const next = [...prev];
+      next[idx] = persona;
+      return next;
+    });
+    setExpertModalOpen(false);
+    setExpertEditing(null);
+  }, []);
+  const handleDeleteExpert = useCallback((id) => {
+    setExpertPersonas(prev => prev.filter(p => p.participant_id !== id));
+    setSelectedIds(prev => prev.filter(x => x !== id));
+    setEnabledMap(em => { const n = { ...em }; delete n[id]; return n; });
+    setExpertModalOpen(false);
+    setExpertEditing(null);
+  }, []);
+
+  // ─── Downloads ──────────────────────────────────────────────────
+  const downloadFile = useCallback((filename, content, mime = 'text/plain;charset=utf-8') => {
+    const blob = new Blob([content], { type: mime });
     const url = URL.createObjectURL(blob);
     const a = document.createElement('a');
     a.href = url;
@@ -128,125 +245,152 @@ export default function App() {
     a.click();
     URL.revokeObjectURL(url);
   }, []);
-
   const handleDownloadTxt = useCallback(async () => {
     if (!sessionId) return;
     try {
-      const result = await exportChat(sessionId, 'txt');
-      downloadFile(result.filename, result.content);
+      const r = await exportChat(sessionId, 'txt');
+      downloadFile(r.filename, r.content);
     } catch (err) { console.error('Export failed:', err); }
   }, [sessionId, downloadFile]);
-
   const handleDownloadMd = useCallback(async () => {
     if (!sessionId) return;
     try {
-      const result = await exportChat(sessionId, 'md');
-      downloadFile(result.filename, result.content);
+      const r = await exportChat(sessionId, 'md');
+      downloadFile(r.filename, r.content);
     } catch (err) { console.error('Export failed:', err); }
   }, [sessionId, downloadFile]);
-
+  const handleDownloadCsvTable = useCallback(async () => {
+    if (!sessionId) return;
+    try {
+      const r = await exportChat(sessionId, 'csv-table');
+      downloadFile(r.filename, r.content, 'text/csv;charset=utf-8');
+    } catch (err) { console.error('CSV export failed:', err); }
+  }, [sessionId, downloadFile]);
   const handleDownloadApiLog = useCallback(async () => {
     if (!sessionId) return;
     try {
-      const result = await exportApiLog(sessionId);
-      downloadFile('api_log.json', JSON.stringify(result, null, 2));
+      const r = await exportApiLog(sessionId);
+      downloadFile('api_log.json', JSON.stringify(r, null, 2), 'application/json');
     } catch (err) { console.error('API log export failed:', err); }
   }, [sessionId, downloadFile]);
 
-  const selectedNameA = selections[0] ? getDisplayName(selections[0], providers, neonModels) : '';
-  const selectedNameB = selections[1] ? getDisplayName(selections[1], providers, neonModels) : '';
-
-  const canStart = selections.length === 2 && !isRunning;
-
+  // ─── Table view ─────────────────────────────────────────────────
+  const handleShowTableView = useCallback(async () => {
+    if (!sessionId) return;
+    try {
+      const data = await fetchTableView(sessionId);
+      setTableData(data);
+      setTableOpen(true);
+    } catch (err) { console.error('Table fetch failed:', err); }
+  }, [sessionId]);
+
+  // ─── Build start payload ────────────────────────────────────────
+  const buildStartPayload = useCallback((theQuestion) => {
+    const enabledParticipants = selectedParticipants.filter(
+      p => enabledMap[p.participant_id] !== false,
+    );
+    const participants = enabledParticipants.map(p => ({
+      participant_id: p.participant_id,
+      kind: p.kind || (p.participant_id.startsWith('neon:') ? 'neon'
+        : (p.participant_id.startsWith('extra_') ? 'extra' : 'expert')),
+      name: p.name,
+      role_prompt: p.role_prompt || null,
+      model_id_override: modelAssignments[p.participant_id] || null,
+    }));
+    const expert_payload = enabledParticipants
+      .filter(p => (p.kind || '').startsWith('expert'))
+      .map(p => ({
+        participant_id: p.participant_id,
+        name: p.name,
+        model_id: modelAssignments[p.participant_id] || p.model_id,
+        role_prompt: p.role_prompt,
+      }));
+    return {
+      question: theQuestion,
+      participants,
+      expert_personas: expert_payload,
+      model_assignments: modelAssignments,
+      orchestrator_model_id: orchestratorModel,
+      summarizer_model_id: summarizerModel,
+      max_participants: maxParticipants,
+    };
+  }, [selectedParticipants, enabledMap, modelAssignments, orchestratorModel, summarizerModel, maxParticipants]);
+
+  // ─── Stop / continue ────────────────────────────────────────────
   const handleStop = useCallback(() => {
-    if (abortRef.current) {
-      abortRef.current.abort();
-      abortRef.current = null;
-    }
+    if (abortRef.current) { abortRef.current.abort(); abortRef.current = null; }
     setIsRunning(false);
-    setChatFinished(true);
     setStatusText('');
+    setPause(null);
     setSystemMessages(prev => [...prev, { text: 'Chat stopped by user.' }]);
   }, []);
+  const handleContinuePause = useCallback(async (reason) => {
+    if (!sessionId) return;
+    try {
+      await continueChat(sessionId, reason);
+      setPause(null);
+    } catch (err) { console.error('Continue failed:', err); }
+  }, [sessionId]);
 
-  const handleStart = useCallback(async (starterText) => {
-    if (selections.length < 2) return;
+  // ─── Start chat ─────────────────────────────────────────────────
+  const handleStart = useCallback(async (theQuestion) => {
+    if (!theQuestion || !theQuestion.trim()) return;
+    if (enabledSelectedCount < 2) return;
 
     const controller = new AbortController();
     abortRef.current = controller;
-
     setIsRunning(true);
-    setAccordionOpen(false);
     setMessages([]);
     setSystemMessages([]);
-    setChatFinished(false);
+    setStatusText('Starting conversation...');
+    setSessionId(null);
+    setSessionParticipants([]);
+    setPause(null);
 
     try {
-      const currentConfig = JSON.stringify({
-        selections, personaMode, roleStyle,
-        a: personaMode === 'freeform'
-          ? { name: personaA.name, freeform: personaA.freeform || '' }
-          : { name: personaA.name, profile: personaA.profile, identity: personaA.identity, samples: personaA.samples },
-        b: personaMode === 'freeform'
-          ? { name: personaB.name, freeform: personaB.freeform || '' }
-          : { name: personaB.name, profile: personaB.profile, identity: personaB.identity, samples: personaB.samples },
-      });
-
-      let cachedPrompts = rolePrompts;
-      const configChanged = currentConfig !== lastRoleConfigRef.current;
-
-      if (configChanged || !cachedPrompts) {
-        setStatusText('Generating expert persona roles...');
-
-        const genA = personaMode === 'freeform'
-          ? generateRoleFreeform({ model_id: selections[0], name: personaA.name, text: personaA.freeform || '', role_style: roleStyle })
-          : generateRole({ model_id: selections[0], name: personaA.name, profile: personaA.profile, identity: personaA.identity, samples: personaA.samples, role_style: roleStyle });
-        const genB = personaMode === 'freeform'
-          ? generateRoleFreeform({ model_id: selections[1], name: personaB.name, text: personaB.freeform || '', role_style: roleStyle })
-          : generateRole({ model_id: selections[1], name: personaB.name, profile: personaB.profile, identity: personaB.identity, samples: personaB.samples, role_style: roleStyle });
-
-        const [roleA, roleB] = await Promise.all([genA, genB]);
-
-        if (controller.signal.aborted) return;
-
-        cachedPrompts = {
-          a: { name: personaA.name || 'Expert Persona A', model: getDisplayName(selections[0], providers, neonModels), prompt: roleA.role_prompt },
-          b: { name: personaB.name || 'Expert Persona B', model: getDisplayName(selections[1], providers, neonModels), prompt: roleB.role_prompt },
-        };
-        setRolePrompts(cachedPrompts);
-        lastRoleConfigRef.current = currentConfig;
-      }
-
-      setStatusText('Starting conversation...');
-
       await startChat(
+        buildStartPayload(theQuestion),
         {
-          persona_a_model_id: selections[0],
-          persona_a_name: cachedPrompts.a.name,
-          persona_a_role: cachedPrompts.a.prompt,
-          persona_b_model_id: selections[1],
-          persona_b_name: cachedPrompts.b.name,
-          persona_b_role: cachedPrompts.b.prompt,
-          starter_text: starterText,
-        },
-        {
-          onSession: (data) => setSessionId(data.session_id),
+          onSession: (data) => {
+            setSessionId(data.session_id);
+            setSessionParticipants(data.participants || []);
+          },
           onMessage: (data) => {
             setMessages(prev => [...prev, data]);
             setStatusText('Conversation in progress...');
           },
+          onOrchestrator: (data) => {
+            // Orchestrator events with kind == "status" but no text are
+            // status banners; bubble them into a message-style entry so
+            // they render with the orchestrator pill.
+            if (data && data.text) {
+              setMessages(prev => [...prev, { ...data, role: 'orchestrator' }]);
+            } else if (data?.message) {
+              setStatusText(data.message);
+            }
+          },
+          onStatus: (data) => setStatusText(data.message || ''),
           onSystem: (data) => {
             setSystemMessages(prev => [...prev, data]);
             if (data.text === 'End of Chat') {
-              setChatFinished(true);
               setStatusText('');
             }
           },
-          onStatus: (data) => setStatusText(data.message || ''),
           onError: (data) => {
             setStatusText('');
             setSystemMessages(prev => [...prev, { text: `Error: ${data.message}` }]);
           },
+          onParticipantError: (data) => {
+            setSystemMessages(prev => [...prev, {
+              text: `${data.name || 'A participant'} couldn't respond this turn.`,
+            }]);
+          },
+          onFailsafePause: (data) => {
+            setPause({ reason: 'messages', ...data });
+          },
+          onOrchestratorCapPause: (data) => {
+            setPause({ reason: 'orchestrator', ...data });
+          },
           onDone: () => {
             setIsRunning(false);
             setStatusText('');
@@ -260,7 +404,7 @@ export default function App() {
       const isRateLimit = err.message && err.message.includes('Daily conversation limit');
       setSystemMessages(prev => [...prev, {
         text: isRateLimit
-          ? 'Daily conversation limit reached (20/day). Sign in with HuggingFace for unlimited access.'
+          ? `Daily conversation limit reached (${dailyLimit}/day). Sign in with HuggingFace for unlimited access.`
           : `Error: ${err.message}`,
       }]);
     } finally {
@@ -268,84 +412,85 @@ export default function App() {
       abortRef.current = null;
       getAuthStatus().then(setAuth).catch(() => {});
     }
-  }, [selections, personaA, personaB, personaMode, roleStyle, rolePrompts]);
+  }, [buildStartPayload, enabledSelectedCount, dailyLimit]);
+
+  const handleStartRandom = useCallback(() => {
+    if (demoQuestions.length === 0) {
+      setSystemMessages(prev => [...prev, { text: 'No demo questions available.' }]);
+      return;
+    }
+    const q = pickRandom(demoQuestions);
+    handleStart(q.text);
+  }, [demoQuestions, handleStart]);
+
+  const startDisabled = isRunning || enabledSelectedCount < 2;
+  const startDisabledReason = enabledSelectedCount < 2
+    ? 'Add at least 2 active participants to start.'
+    : '';
 
   return (
     <div className="app">
-      <header className="app-header">
-        <div className="header-left">
-          <a href="https://www.neon.ai/" target="_blank" rel="noopener noreferrer" className="header-brand-link">
-            <img src="/neon-logo.png" alt="Neon.ai" className="app-logo" />
-          </a>
-          <h1 className="app-title"><a href="https://www.neon.ai/" target="_blank" rel="noopener noreferrer" className="app-title-link">Neon.ai</a> - AI to AI Conversations</h1>
-        </div>
-        <div className="header-right">
-          <AuthBadge auth={auth} />
-          <button
-            className="icon-btn"
-            onClick={() => setTheme(t => t === 'light' ? 'dark' : 'light')}
-            title="Toggle theme"
-          >
-            {theme === 'light' ? <Moon size={16} /> : <Sun size={16} />}
-          </button>
-          <DevMenu
-            allModels={allModelsFlat}
-            orchestratorModel={orchestratorModel}
-            onOrchestratorChange={handleOrchestratorChange}
-            personaMode={personaMode}
-            onPersonaModeChange={handlePersonaModeChange}
-            roleStyle={roleStyle}
-            onRoleStyleChange={setRoleStyle}
-            speedPriority={speedPriority}
-            onSpeedPriorityChange={handleSpeedPriorityChange}
-            showResponseTime={showResponseTime}
-            onShowResponseTimeChange={setShowResponseTime}
-            showChatStats={showChatStats}
-            onShowChatStatsChange={setShowChatStats}
-            rolePrompts={rolePrompts}
-            onShowRolePrompts={() => setRolePromptsOpen(true)}
-            onDownloadChatTxt={handleDownloadTxt}
-            onDownloadChatMd={handleDownloadMd}
-            onDownloadApiLog={handleDownloadApiLog}
-            hasChat={messages.length > 0}
-            hasApiLog={!!sessionId}
-          />
-        </div>
-      </header>
+      <Header
+        theme={theme}
+        onToggleTheme={() => setTheme(t => t === 'light' ? 'dark' : 'light')}
+        auth={auth}
+        dailyLimit={dailyLimit}
+        catalog={catalog}
+        expertPersonas={expertPersonas}
+        selectedIds={selectedIds}
+        maxParticipants={maxParticipants}
+        onToggleParticipant={handleToggleParticipant}
+        onOpenExpertModal={handleOpenExpertModal}
+
+        allModels={allModelsFlat}
+        orchestratorModel={orchestratorModel}
+        onOrchestratorChange={handleOrchestratorChange}
+        summarizerModel={summarizerModel}
+        onSummarizerChange={handleSummarizerChange}
+        speedPriority={speedPriority}
+        onSpeedPriorityChange={handleSpeedPriorityChange}
+        showResponseTime={showResponseTime}
+        onShowResponseTimeChange={setShowResponseTime}
+        showChatStats={showChatStats}
+        onShowChatStatsChange={setShowChatStats}
+        onMaxParticipantsChange={handleMaxParticipantsChange}
+        participants={selectedParticipants}
+        modelAssignments={modelAssignments}
+        onModelAssignmentChange={handleModelAssignmentChange}
+        onShowTableView={handleShowTableView}
+        onDownloadChatTxt={handleDownloadTxt}
+        onDownloadChatMd={handleDownloadMd}
+        onDownloadCsvTable={handleDownloadCsvTable}
+        onDownloadApiLog={handleDownloadApiLog}
+        hasApiLog={!!sessionId}
+        hasChat={messages.length > 0}
+      />
 
       <main className="app-main">
-        <LLMSelector
-          providers={providers}
-          neonModels={neonModels}
-          selections={selections}
-          onSelectionsChange={setSelections}
+        <ParticipantSidebar
+          participants={selectedParticipants}
+          enabledMap={enabledMap}
+          modelAssignments={modelAssignments}
+          onToggleEnabled={handleSidebarToggleEnabled}
+          onRemove={handleSidebarRemove}
         />
-
         <div className="content">
-          <PersonaAccordion
-            isOpen={accordionOpen}
-            onToggle={() => setAccordionOpen(o => !o)}
-            personaA={personaA}
-            personaB={personaB}
-            onChangeA={setPersonaA}
-            onChangeB={setPersonaB}
-            selectedNameA={selectedNameA}
-            selectedNameB={selectedNameB}
-            mode={personaMode}
-          />
-
           <ChatControls
-            onStart={handleStart}
+            onStartRandom={handleStartRandom}
+            onStartTyped={handleStart}
             onStop={handleStop}
-            disabled={!canStart}
+            disabled={startDisabled}
             isRunning={isRunning}
+            disabledReason={startDisabledReason}
           />
-
           <ChatArea
             messages={messages}
             systemMessages={systemMessages}
             isRunning={isRunning}
             statusText={statusText}
+            pause={pause}
+            onContinuePause={handleContinuePause}
+            participants={sessionParticipants.length > 0 ? sessionParticipants : selectedParticipants}
             showResponseTime={showResponseTime}
             showChatStats={showChatStats}
           />
@@ -356,25 +501,21 @@ export default function App() {
         <a href="https://www.neon.ai/contact" target="_blank" rel="noopener noreferrer">Patents and licensing</a>
       </footer>
 
-      {rolePromptsOpen && rolePrompts && (
-        <div className="modal-overlay" onClick={() => setRolePromptsOpen(false)}>
-          <div className="modal-content" onClick={e => e.stopPropagation()}>
-            <div className="modal-header">
-              <h2>Generated Role Prompts</h2>
-              <button className="modal-close" onClick={() => setRolePromptsOpen(false)}>&times;</button>
-            </div>
-            <div className="modal-body">
-              <div className="role-prompt-section">
-                <h3>{rolePrompts.a.name} <span className="role-prompt-model">({rolePrompts.a.model})</span></h3>
-                <pre className="role-prompt-text">{rolePrompts.a.prompt}</pre>
-              </div>
-              <div className="role-prompt-section">
-                <h3>{rolePrompts.b.name} <span className="role-prompt-model">({rolePrompts.b.model})</span></h3>
-                <pre className="role-prompt-text">{rolePrompts.b.prompt}</pre>
-              </div>
-            </div>
-          </div>
-        </div>
+      <ExpertPersonaModal
+        isOpen={expertModalOpen}
+        initial={expertEditing}
+        onClose={() => { setExpertModalOpen(false); setExpertEditing(null); }}
+        onSave={handleSaveExpert}
+        onDelete={handleDeleteExpert}
+        allModels={allModelsFlat}
+        defaultModelId={orchestratorModel || ''}
+      />
+      {tableOpen && (
+        <ChatTableView
+          data={tableData}
+          onClose={() => setTableOpen(false)}
+          onExportCsv={handleDownloadCsvTable}
+        />
       )}
     </div>
   );

frontend/src/components/AuthBadge.js

@@ -1,8 +1,9 @@
 import React from 'react';
 import { LogIn, LogOut, User } from 'lucide-react';
 
-export default function AuthBadge({ auth }) {
+export default function AuthBadge({ auth, dailyLimit }) {
   if (!auth) return null;
+  const cap = dailyLimit || 30;
 
   if (auth.logged_in) {
     return (
@@ -23,7 +24,7 @@ export default function AuthBadge({ auth }) {
   return (
     <div className="auth-badge">
       {auth.remaining_conversations >= 0 && (
-        <span className="auth-remaining">{auth.remaining_conversations}/20 chats</span>
+        <span className="auth-remaining">{auth.remaining_conversations}/{cap} chats</span>
       )}
       <a href="/oauth/huggingface/login" className="auth-link auth-login">
         <LogIn size={13} /> Sign in

frontend/src/components/ChatArea.js

@@ -1,35 +1,73 @@
 import React, { useEffect, useRef, useMemo } from 'react';
 import MessageBubble from './MessageBubble';
+import OrchestratorMessage from './OrchestratorMessage';
+import FailsafePauseBanner from './FailsafePauseBanner';
 
-export default function ChatArea({ messages, systemMessages, isRunning, statusText, showResponseTime, showChatStats }) {
+/**
+ * Renders the conversation: a mix of participant bubbles, orchestrator
+ * status banners, and the failsafe-pause continue control. Participant
+ * coloring is derived from each participant's index in the active
+ * roster, so colors are stable per-participant for the whole chat.
+ */
+export default function ChatArea({
+  messages,
+  systemMessages,
+  isRunning,
+  statusText,
+  pause,
+  onContinuePause,
+  participants,
+  showResponseTime,
+  showChatStats,
+}) {
   const endRef = useRef(null);
 
   useEffect(() => {
     endRef.current?.scrollIntoView({ behavior: 'smooth' });
-  }, [messages, systemMessages]);
+  }, [messages, systemMessages, statusText, pause]);
 
-  const hasContent = messages.length > 0 || systemMessages.length > 0;
-  const chatEnded = systemMessages.some(s => s.text === 'End of Chat');
+  const speakerIdxFor = useMemo(() => {
+    const map = {};
+    (participants || []).forEach((p, i) => {
+      map[p.participant_id] = i;
+    });
+    return map;
+  }, [participants]);
+
+  const hasContent = (messages?.length || 0) + (systemMessages?.length || 0) > 0;
+  const chatEnded = (systemMessages || []).some(s => s.text === 'End of Chat');
 
   const stats = useMemo(() => {
-    if (!chatEnded || messages.length === 0) return null;
-    const totalTime = messages.reduce((sum, m) => sum + (m.elapsed_seconds || 0), 0);
-    return { count: messages.length, totalTime: totalTime.toFixed(1) };
+    if (!chatEnded || !messages || messages.length === 0) return null;
+    const participantMsgs = messages.filter(m => m.role !== 'orchestrator');
+    const totalTime = participantMsgs.reduce(
+      (sum, m) => sum + (m.elapsed_seconds || 0), 0,
+    );
+    return { count: participantMsgs.length, totalTime: totalTime.toFixed(1) };
   }, [chatEnded, messages]);
 
   return (
     <div className="chat-area">
       {!hasContent && !isRunning && (
         <div className="chat-empty">
-          Select two LLMs, configure expert personas, and start a conversation.
+          Add at least 2 participants from the header dropdown, then start a conversation.
         </div>
       )}
-
-      {messages.map((msg, i) => (
-        <MessageBubble key={i} message={msg} showResponseTime={showResponseTime} />
-      ))}
-
-      {systemMessages.map((sys, i) => (
+      {(messages || []).map((msg, i) => {
+        if (msg.role === 'orchestrator') {
+          return <OrchestratorMessage key={i} message={msg} />;
+        }
+        const idx = speakerIdxFor[msg.speaker_id] ?? i;
+        return (
+          <MessageBubble
+            key={i}
+            message={msg}
+            idx={idx}
+            showResponseTime={showResponseTime}
+          />
+        );
+      })}
+      {(systemMessages || []).map((sys, i) => (
         <div
           key={`sys-${i}`}
           className={`system-message ${sys.text === 'End of Chat' ? 'end-of-chat' : ''}`}
@@ -37,20 +75,18 @@ export default function ChatArea({ messages, systemMessages, isRunning, statusTe
           {sys.text}
         </div>
       ))}
-
       {showChatStats && stats && (
         <div className="chat-stats">
-          {stats.count} messages &middot; {stats.totalTime}s total generation time
+          {stats.count} participant messages &middot; {stats.totalTime}s total generation time
         </div>
       )}
-
+      <FailsafePauseBanner pause={pause} onContinue={onContinuePause} />
       {isRunning && statusText && (
         <div className="status-bar">
           <div className="spinner" />
           <span>{statusText}</span>
         </div>
       )}
-
       <div ref={endRef} />
     </div>
   );

frontend/src/components/ChatControls.js

@@ -1,21 +1,29 @@
 import React, { useState } from 'react';
 import { Play, Shuffle, Square } from 'lucide-react';
 
-export default function ChatControls({ onStart, onStop, disabled, isRunning }) {
-  const [starterText, setStarterText] = useState('');
-
-  const handleStartWithText = () => {
-    onStart(starterText.trim() || null);
-  };
-
-  const handleAutoStart = () => {
-    onStart(null);
-  };
-
+/**
+ * "Let Them Start" picks a random demo question from the bank.
+ * "Start Chat With My Prompt" uses the typed-in question.
+ *
+ * Both require >=2 enabled participants - that's enforced upstream and
+ * mirrored here as a disabled state.
+ */
+export default function ChatControls({
+  onStartRandom,
+  onStartTyped,
+  onStop,
+  disabled,
+  isRunning,
+  disabledReason,
+}) {
+  const [text, setText] = useState('');
+  const placeholder = disabled
+    ? (disabledReason || 'Add participants to start a conversation')
+    : 'Or type your own question for the group...';
   return (
     <div className="chat-controls">
       {isRunning ? (
-        <button className="btn-stop" onClick={onStop} title="Stop the conversation">
+        <button className="btn-stop" onClick={onStop}>
           <Square size={14} style={{ verticalAlign: 'middle', marginRight: 4 }} />
           Stop Chat
         </button>
@@ -23,28 +31,29 @@ export default function ChatControls({ onStart, onStop, disabled, isRunning }) {
         <>
           <button
             className="btn-primary"
-            onClick={handleAutoStart}
             disabled={disabled}
-            title="Let the LLMs start on their own"
+            onClick={() => onStartRandom()}
+            title="Pick a random demo question and start"
           >
             <Shuffle size={14} style={{ verticalAlign: 'middle', marginRight: 4 }} />
             Let Them Start
           </button>
           <input
             type="text"
-            placeholder="Let them start on their own, or enter a conversation starter here"
-            value={starterText}
-            onChange={e => setStarterText(e.target.value)}
+            value={text}
+            placeholder={placeholder}
             disabled={disabled}
+            onChange={e => setText(e.target.value)}
             onKeyDown={e => {
-              if (e.key === 'Enter' && !disabled) handleStartWithText();
+              if (e.key === 'Enter' && !disabled && text.trim()) {
+                onStartTyped(text.trim());
+              }
             }}
           />
           <button
             className="btn-primary"
-            onClick={handleStartWithText}
-            disabled={disabled}
-            title="Start with your message"
+            disabled={disabled || !text.trim()}
+            onClick={() => onStartTyped(text.trim())}
           >
             <Play size={14} style={{ verticalAlign: 'middle', marginRight: 4 }} />
             Start Chat With My Prompt

frontend/src/components/ChatTableView.js

@@ -0,0 +1,72 @@
+import React from 'react';
+
+/**
+ * Phase-by-phase summary of the conversation rendered as a table.
+ * Question on top, final group opinion under it, one row per
+ * participant with first / contribution / revised / final columns.
+ *
+ * Driven by the GET /api/chat/{id}/table endpoint - so this component
+ * just renders the JSON response.
+ */
+export default function ChatTableView({ data, onClose, onExportCsv }) {
+  if (!data) return null;
+  return (
+    <div className="ccai-table-overlay">
+      <div className="ccai-table-card">
+        <div className="ccai-table-header">
+          <h2>Conversation Summary Table</h2>
+          <div className="ccai-tab-spacer" />
+          <button
+            className="btn-sm btn-outline"
+            onClick={onExportCsv}
+            title="Export this table as CSV"
+          >
+            Export CSV
+          </button>
+          <button className="modal-close" onClick={onClose}>&times;</button>
+        </div>
+        <div className="ccai-table-body">
+          <div className="ccai-table-question">
+            <strong>Question:</strong>
+            <div>{data.question}</div>
+          </div>
+          <div className="ccai-table-final">
+            <strong>Final group opinion:</strong>
+            <div>
+              {data.final_report ? data.final_report : (
+                <em>No final report yet.</em>
+              )}
+            </div>
+          </div>
+          <div className="ccai-table-scroll">
+            <table className="ccai-table">
+              <thead>
+                <tr>
+                  <th>Participant</th>
+                  <th>First opinion</th>
+                  <th>Conversation contribution</th>
+                  <th>Revised opinion</th>
+                  <th>Final opinion</th>
+                </tr>
+              </thead>
+              <tbody>
+                {(data.rows || []).map(row => (
+                  <tr key={row.participant_id}>
+                    <td className="ccai-table-name">
+                      <div>{row.name}</div>
+                      <small>{row.model_display}</small>
+                    </td>
+                    <td>{row.first_opinion}</td>
+                    <td>{row.contribution_summary || <em>(no summary)</em>}</td>
+                    <td>{row.revised_opinion}</td>
+                    <td>{row.final_opinion}</td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/DevMenu.js

@@ -1,43 +1,60 @@
 import React, { useState, useMemo, useRef, useEffect } from 'react';
-import { ChevronRight, Download, Settings2, Search, Check, Eye, EyeOff, FileText, Square, CheckSquare } from 'lucide-react';
+import {
+  ChevronRight, Download, Settings2, Search,
+  Square, CheckSquare, UserPlus, Table2,
+} from 'lucide-react';
 
+/**
+ * Settings menu, structurally identical to LLMChats3 but populated with
+ * CCAI controls:
+ *   - Orchestrator model (searchable)
+ *   - Summarizer model (searchable, with "Same as Orchestrator" default)
+ *   - Max participants (3-9, default 5)
+ *   - Per-participant model assignments
+ *   - "Create Expert Persona..." shortcut
+ *   - Display options + downloads (txt / md / csv-table / api-log)
+ */
 export default function DevMenu({
   allModels,
   orchestratorModel,
   onOrchestratorChange,
-  personaMode,
-  onPersonaModeChange,
-  roleStyle,
-  onRoleStyleChange,
+  summarizerModel,
+  onSummarizerChange,
   speedPriority,
   onSpeedPriorityChange,
   showResponseTime,
   onShowResponseTimeChange,
   showChatStats,
   onShowChatStatsChange,
-  rolePrompts,
-  onShowRolePrompts,
-  onDownloadApiLog,
+  maxParticipants,
+  onMaxParticipantsChange,
+  participants,
+  modelAssignments,
+  onModelAssignmentChange,
+  onOpenExpertModal,
+  onShowTableView,
   onDownloadChatTxt,
   onDownloadChatMd,
+  onDownloadCsvTable,
+  onDownloadApiLog,
   hasApiLog,
   hasChat,
 }) {
   const [open, setOpen] = useState(false);
-  const [orchOpen, setOrchOpen] = useState(false);
+  const [activeSub, setActiveSub] = useState(null); // null | "orch" | "sum" | <participant_id>
   const [q, setQ] = useState('');
   const wrapRef = useRef(null);
   const searchRef = useRef(null);
 
   useEffect(() => {
-    if (orchOpen && searchRef.current) searchRef.current.focus();
-  }, [orchOpen]);
+    if (activeSub && searchRef.current) searchRef.current.focus();
+  }, [activeSub]);
 
   useEffect(() => {
     function handleClickOutside(e) {
       if (wrapRef.current && !wrapRef.current.contains(e.target)) {
         setOpen(false);
-        setOrchOpen(false);
+        setActiveSub(null);
         setQ('');
       }
     }
@@ -54,11 +71,21 @@ export default function DevMenu({
     });
   }, [allModels, q]);
 
-  const currentName = useMemo(() => {
-    if (!orchestratorModel) return 'Default (backend)';
-    const m = allModels.find(m => m.id === orchestratorModel);
-    return m ? m.name : orchestratorModel;
-  }, [orchestratorModel, allModels]);
+  const nameForModel = (id) => {
+    if (!id) return null;
+    const m = allModels.find(x => x.id === id);
+    return m ? m.name : id;
+  };
+  const orchName = nameForModel(orchestratorModel) || 'Default (backend)';
+  const sumName = summarizerModel
+    ? (nameForModel(summarizerModel) || summarizerModel)
+    : 'Same as Orchestrator';
+
+  const onPickForSubject = (id, subject) => {
+    if (subject === 'orch') onOrchestratorChange(id);
+    else if (subject === 'sum') onSummarizerChange(id);
+    else if (subject) onModelAssignmentChange(subject, id);
+  };
 
   return (
     <div className="dev-wrap" ref={wrapRef}>
@@ -69,17 +96,84 @@ export default function DevMenu({
         <button className="btn-sm btn-outline" disabled={!hasChat} onClick={onDownloadChatMd}>
           <Download size={14} /> .md
         </button>
+        <button
+          className="btn-sm btn-outline"
+          disabled={!hasChat}
+          onClick={onShowTableView}
+          title="Open the conversation summary table"
+        >
+          <Table2 size={14} /> Table
+        </button>
+        <button
+          className="btn-sm btn-outline"
+          disabled={!hasChat}
+          onClick={onDownloadCsvTable}
+          title="Download the table view as CSV"
+        >
+          <Download size={14} /> .csv
+        </button>
       </div>
 
       <div className="dev-dropdown-header">
-        <button className="icon-btn" onClick={() => { setOpen(o => !o); setOrchOpen(false); setQ(''); }} title="Settings">
+        <button
+          className="icon-btn"
+          onClick={() => { setOpen(o => !o); setActiveSub(null); setQ(''); }}
+          title="Settings"
+        >
           <Settings2 size={16} />
         </button>
         {open && (
           <div className="dev-panel">
-            <button onClick={() => { setOrchOpen(o => !o); setQ(''); }}>
-              Orchestrator model… <ChevronRight size={12} style={{ marginLeft: 'auto', opacity: 0.5 }} />
+            <button onClick={() => { setActiveSub(s => s === 'orch' ? null : 'orch'); setQ(''); }}>
+              Orchestrator model… <span className="dev-panel-hint">{orchName}</span>
+              <ChevronRight size={12} style={{ marginLeft: 'auto', opacity: 0.5 }} />
+            </button>
+            <button onClick={() => { setActiveSub(s => s === 'sum' ? null : 'sum'); setQ(''); }}>
+              Summarizer model… <span className="dev-panel-hint">{sumName}</span>
+              <ChevronRight size={12} style={{ marginLeft: 'auto', opacity: 0.5 }} />
             </button>
+
+            <div className="dev-panel-divider" />
+            <div className="dev-panel-label">Max participants ({maxParticipants})</div>
+            <div className="ccai-stepper-row">
+              <button
+                className="btn-sm btn-outline ccai-stepper-btn"
+                disabled={maxParticipants <= 3}
+                onClick={() => onMaxParticipantsChange(Math.max(3, maxParticipants - 1))}
+              >−</button>
+              <div className="ccai-stepper-val">{maxParticipants}</div>
+              <button
+                className="btn-sm btn-outline ccai-stepper-btn"
+                disabled={maxParticipants >= 9}
+                onClick={() => onMaxParticipantsChange(Math.min(9, maxParticipants + 1))}
+              >+</button>
+              <span className="dev-panel-hint">3-9</span>
+            </div>
+
+            <div className="dev-panel-divider" />
+            <div className="dev-panel-label">Participants</div>
+            <button onClick={() => { onOpenExpertModal(null); setOpen(false); }}>
+              <UserPlus size={14} className="dev-check-icon" />
+              Create Expert Persona…
+            </button>
+            {(participants || []).length > 0 && (
+              <div className="dev-panel-label">Per-participant model</div>
+            )}
+            {(participants || []).map(p => {
+              const assigned = modelAssignments[p.participant_id];
+              const labelName = assigned ? nameForModel(assigned)
+                : (p.default_model_id ? nameForModel(p.default_model_id) : '(default)');
+              return (
+                <button
+                  key={p.participant_id}
+                  onClick={() => { setActiveSub(s => s === p.participant_id ? null : p.participant_id); setQ(''); }}
+                >
+                  {p.name}<span className="dev-panel-hint"> {labelName}</span>
+                  <ChevronRight size={12} style={{ marginLeft: 'auto', opacity: 0.5 }} />
+                </button>
+              );
+            })}
+
             <div className="dev-panel-divider" />
             <div className="dev-panel-label">Response priority</div>
             <button
@@ -96,38 +190,7 @@ export default function DevMenu({
               {speedPriority ? <CheckSquare size={16} className="dev-check-icon" /> : <Square size={16} className="dev-check-icon" />}
               Prioritize conversation speed
             </button>
-            <div className="dev-panel-divider" />
-            <div className="dev-panel-label">Expert persona input</div>
-            <button
-              className={`dev-panel-choice ${personaMode === 'structured' ? 'dev-panel-choice-active' : ''}`}
-              onClick={() => onPersonaModeChange('structured')}
-            >
-              {personaMode === 'structured' ? <CheckSquare size={16} className="dev-check-icon" /> : <Square size={16} className="dev-check-icon" />}
-              Structured expert persona input
-            </button>
-            <button
-              className={`dev-panel-choice ${personaMode === 'freeform' ? 'dev-panel-choice-active' : ''}`}
-              onClick={() => onPersonaModeChange('freeform')}
-            >
-              {personaMode === 'freeform' ? <CheckSquare size={16} className="dev-check-icon" /> : <Square size={16} className="dev-check-icon" />}
-              Freeform expert persona input
-            </button>
-            <div className="dev-panel-divider" />
-            <div className="dev-panel-label">Role generation</div>
-            <button
-              className={`dev-panel-choice ${roleStyle === 'ai_completed' ? 'dev-panel-choice-active' : ''}`}
-              onClick={() => onRoleStyleChange('ai_completed')}
-            >
-              {roleStyle === 'ai_completed' ? <CheckSquare size={16} className="dev-check-icon" /> : <Square size={16} className="dev-check-icon" />}
-              AI completed roles
-            </button>
-            <button
-              className={`dev-panel-choice ${roleStyle === 'exact' ? 'dev-panel-choice-active' : ''}`}
-              onClick={() => onRoleStyleChange('exact')}
-            >
-              {roleStyle === 'exact' ? <CheckSquare size={16} className="dev-check-icon" /> : <Square size={16} className="dev-check-icon" />}
-              Exact user roles
-            </button>
+
             <div className="dev-panel-divider" />
             <div className="dev-panel-label">Display options</div>
             <button
@@ -144,10 +207,7 @@ export default function DevMenu({
               {showChatStats ? <CheckSquare size={16} className="dev-check-icon" /> : <Square size={16} className="dev-check-icon" />}
               Chat stats after end
             </button>
-            <button className="dev-panel-choice" disabled={!rolePrompts} onClick={() => { onShowRolePrompts(); setOpen(false); }}>
-              <FileText size={14} className="dev-check-icon" />
-              View role prompts
-            </button>
+
             <div className="dev-panel-divider" />
             <button disabled={!hasChat} className="dev-panel-download-item" onClick={() => { onDownloadChatTxt(); setOpen(false); }}>
               Download chat as .txt
@@ -155,17 +215,32 @@ export default function DevMenu({
             <button disabled={!hasChat} className="dev-panel-download-item" onClick={() => { onDownloadChatMd(); setOpen(false); }}>
               Download chat as .md
             </button>
+            <button disabled={!hasChat} className="dev-panel-download-item" onClick={() => { onDownloadCsvTable(); setOpen(false); }}>
+              Download summary table as .csv
+            </button>
             <button disabled={!hasApiLog} onClick={() => { onDownloadApiLog(); setOpen(false); }}>
               Download full API history
             </button>
           </div>
         )}
 
-        {open && orchOpen && (
+        {open && activeSub && (
           <div className="dev-sub-panel">
             <div className="dev-sub-header">
-              <span className="dev-sub-title">Orchestrator</span>
-              <span className="dev-sub-current">{currentName}</span>
+              <span className="dev-sub-title">
+                {activeSub === 'orch' && 'Orchestrator model'}
+                {activeSub === 'sum' && 'Summarizer model'}
+                {activeSub !== 'orch' && activeSub !== 'sum' && (
+                  <>Model for {participants.find(p => p.participant_id === activeSub)?.name || activeSub}</>
+                )}
+              </span>
+              <span className="dev-sub-current">
+                {activeSub === 'orch' && orchName}
+                {activeSub === 'sum' && sumName}
+                {activeSub !== 'orch' && activeSub !== 'sum' && (
+                  nameForModel(modelAssignments[activeSub]) || '(default)'
+                )}
+              </span>
             </div>
             <div className="dev-sub-search">
               <Search size={14} className="dev-sub-search-icon" />
@@ -178,26 +253,56 @@ export default function DevMenu({
               />
             </div>
             <ul className="dev-sub-list">
-              <li>
-                <button
-                  className={`dev-sub-item ${!orchestratorModel ? 'dev-sub-item-active' : ''}`}
-                  onClick={() => { onOrchestratorChange(null); setOrchOpen(false); setOpen(false); setQ(''); }}
-                >
-                  <strong>Default (backend)</strong>
-                  <span className="dev-sub-provider">Use server default</span>
-                </button>
-              </li>
-              {filtered.map(m => (
-                <li key={m.id}>
+              {activeSub === 'sum' && (
+                <li>
+                  <button
+                    className={`dev-sub-item ${!summarizerModel ? 'dev-sub-item-active' : ''}`}
+                    onClick={() => { onPickForSubject(null, 'sum'); setActiveSub(null); setQ(''); }}
+                  >
+                    <strong>Same as Orchestrator (default)</strong>
+                    <span className="dev-sub-provider">Use whichever model is currently the orchestrator</span>
+                  </button>
+                </li>
+              )}
+              {activeSub === 'orch' && (
+                <li>
+                  <button
+                    className={`dev-sub-item ${!orchestratorModel ? 'dev-sub-item-active' : ''}`}
+                    onClick={() => { onPickForSubject(null, 'orch'); setActiveSub(null); setQ(''); }}
+                  >
+                    <strong>Default (backend)</strong>
+                    <span className="dev-sub-provider">Use server default</span>
+                  </button>
+                </li>
+              )}
+              {activeSub !== 'orch' && activeSub !== 'sum' && (
+                <li>
                   <button
-                    className={`dev-sub-item ${orchestratorModel === m.id ? 'dev-sub-item-active' : ''}`}
-                    onClick={() => { onOrchestratorChange(m.id); setOrchOpen(false); setOpen(false); setQ(''); }}
+                    className={`dev-sub-item ${!modelAssignments[activeSub] ? 'dev-sub-item-active' : ''}`}
+                    onClick={() => { onPickForSubject(null, activeSub); setActiveSub(null); setQ(''); }}
                   >
-                    <strong>{m.name}</strong>
-                    <span className="dev-sub-provider">{m.provider}</span>
+                    <strong>(persona default)</strong>
+                    <span className="dev-sub-provider">Use the persona's bundled or saved default</span>
                   </button>
                 </li>
-              ))}
+              )}
+              {filtered.map(m => {
+                const currentId =
+                  activeSub === 'orch' ? orchestratorModel
+                    : activeSub === 'sum' ? summarizerModel
+                    : modelAssignments[activeSub];
+                return (
+                  <li key={m.id}>
+                    <button
+                      className={`dev-sub-item ${currentId === m.id ? 'dev-sub-item-active' : ''}`}
+                      onClick={() => { onPickForSubject(m.id, activeSub); setActiveSub(null); setQ(''); }}
+                    >
+                      <strong>{m.name}</strong>
+                      <span className="dev-sub-provider">{m.provider}</span>
+                    </button>
+                  </li>
+                );
+              })}
             </ul>
           </div>
         )}

frontend/src/components/ExpertPersonaModal.js

@@ -0,0 +1,302 @@
+import React, { useState, useEffect, useRef } from 'react';
+import { Upload, Save, Trash2 } from 'lucide-react';
+import { generateRole, generateRoleFreeform } from '../utils/api';
+
+/**
+ * Single source of truth for creating Expert Personas. Replaces the
+ * inline PersonaAccordion + DevMenu persona-mode/role-style settings
+ * from LLMChats3 - those choices now live inside this modal.
+ *
+ * Tabs: Structured | Freeform
+ * Role-style toggle: AI-completed | Exact (matches LLMChats3 semantics)
+ * Freeform tab supports a file upload for writing samples.
+ */
+export default function ExpertPersonaModal({
+  isOpen,
+  initial,                   // existing persona to edit, or null for new
+  onClose,
+  onSave,
+  onDelete,
+  allModels,                 // [{ id, name, provider }]
+  defaultModelId,
+}) {
+  const [activeTab, setActiveTab] = useState('freeform');
+  const [name, setName] = useState('');
+  const [profile, setProfile] = useState('');
+  const [identity, setIdentity] = useState('');
+  const [samples, setSamples] = useState('');
+  const [freeText, setFreeText] = useState('');
+  const [roleStyle, setRoleStyle] = useState('ai_completed');
+  const [modelId, setModelId] = useState(defaultModelId || '');
+  const [generatedPrompt, setGeneratedPrompt] = useState('');
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState('');
+  const fileInputRef = useRef(null);
+
+  useEffect(() => {
+    if (!isOpen) return;
+    if (initial) {
+      setActiveTab(initial.input_mode || 'freeform');
+      setName(initial.name || '');
+      setProfile(initial.profile || '');
+      setIdentity(initial.identity || '');
+      setSamples(initial.samples || '');
+      setFreeText(initial.freeform || '');
+      setRoleStyle(initial.role_style || 'ai_completed');
+      setModelId(initial.model_id || defaultModelId || '');
+      setGeneratedPrompt(initial.role_prompt || '');
+    } else {
+      setActiveTab('freeform');
+      setName('');
+      setProfile('');
+      setIdentity('');
+      setSamples('');
+      setFreeText('');
+      setRoleStyle('ai_completed');
+      setModelId(defaultModelId || '');
+      setGeneratedPrompt('');
+    }
+    setError('');
+  }, [isOpen, initial, defaultModelId]);
+
+  if (!isOpen) return null;
+
+  const handleFileUpload = async (e) => {
+    const file = e.target.files?.[0];
+    if (!file) return;
+    try {
+      const text = await file.text();
+      setFreeText(prev => (prev ? prev + '\n\n' : '') + text);
+    } catch (err) {
+      setError(`File read failed: ${err.message}`);
+    }
+    e.target.value = '';
+  };
+
+  const handleGenerate = async () => {
+    setError('');
+    if (!modelId) {
+      setError('Pick a model to power this persona first.');
+      return;
+    }
+    if (!name.trim()) {
+      setError('Persona needs a name.');
+      return;
+    }
+    setBusy(true);
+    try {
+      const result = activeTab === 'freeform'
+        ? await generateRoleFreeform({
+          model_id: modelId,
+          name: name.trim(),
+          text: freeText,
+          role_style: roleStyle,
+        })
+        : await generateRole({
+          model_id: modelId,
+          name: name.trim(),
+          profile,
+          identity,
+          samples,
+          role_style: roleStyle,
+        });
+      setGeneratedPrompt(result.role_prompt || '');
+    } catch (err) {
+      setError(err.message || String(err));
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  const canSave = name.trim() && modelId && generatedPrompt.trim();
+  const handleSave = () => {
+    if (!canSave) return;
+    onSave({
+      participant_id: initial?.participant_id || `expert_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      kind: 'expert',
+      name: name.trim(),
+      model_id: modelId,
+      role_prompt: generatedPrompt.trim(),
+      input_mode: activeTab,
+      role_style: roleStyle,
+      profile,
+      identity,
+      samples,
+      freeform: freeText,
+    });
+  };
+
+  return (
+    <div className="modal-overlay" onClick={onClose}>
+      <div
+        className="modal-content ccai-expert-modal"
+        onClick={e => e.stopPropagation()}
+      >
+        <div className="modal-header">
+          <h2>{initial ? `Edit Expert Persona: ${initial.name}` : 'Create Expert Persona'}</h2>
+          <button className="modal-close" onClick={onClose}>&times;</button>
+        </div>
+        <div className="modal-body">
+          <div className="ccai-expert-row">
+            <div className="ccai-expert-field">
+              <label>Name</label>
+              <input
+                type="text"
+                value={name}
+                placeholder="e.g. Dr. Patel - Pediatric Cardiologist"
+                onChange={e => setName(e.target.value)}
+              />
+            </div>
+            <div className="ccai-expert-field">
+              <label>Powered by LLM</label>
+              <select
+                value={modelId}
+                onChange={e => setModelId(e.target.value)}
+              >
+                <option value="">Pick a model...</option>
+                {(allModels || []).map(m => (
+                  <option key={m.id} value={m.id}>
+                    {m.name} {m.provider ? `(${m.provider})` : ''}
+                  </option>
+                ))}
+              </select>
+            </div>
+          </div>
+
+          <div className="ccai-tab-row">
+            <button
+              className={'ccai-tab-btn' + (activeTab === 'freeform' ? ' ccai-tab-btn-active' : '')}
+              onClick={() => setActiveTab('freeform')}
+            >
+              Freeform
+            </button>
+            <button
+              className={'ccai-tab-btn' + (activeTab === 'structured' ? ' ccai-tab-btn-active' : '')}
+              onClick={() => setActiveTab('structured')}
+            >
+              Structured
+            </button>
+            <div className="ccai-tab-spacer" />
+            <label className="ccai-role-style">
+              <input
+                type="radio"
+                name="role-style"
+                checked={roleStyle === 'ai_completed'}
+                onChange={() => setRoleStyle('ai_completed')}
+              />
+              AI-completed
+            </label>
+            <label className="ccai-role-style">
+              <input
+                type="radio"
+                name="role-style"
+                checked={roleStyle === 'exact'}
+                onChange={() => setRoleStyle('exact')}
+              />
+              Exact (no inferring)
+            </label>
+          </div>
+
+          {activeTab === 'freeform' ? (
+            <div className="ccai-expert-freeform">
+              <div className="freeform-label-row">
+                <label>Persona description, writing samples, anything you want the LLM to know:</label>
+                <button
+                  className="btn-sm btn-outline upload-btn"
+                  onClick={() => fileInputRef.current?.click()}
+                >
+                  <Upload size={12} /> Upload .txt
+                </button>
+                <input
+                  type="file"
+                  accept=".txt,.md"
+                  ref={fileInputRef}
+                  onChange={handleFileUpload}
+                  style={{ display: 'none' }}
+                />
+              </div>
+              <textarea
+                className="freeform-textarea"
+                value={freeText}
+                placeholder="Drop in any background, transcript, writing samples, biography, etc. Sparse input is fine - the AI-completed mode will fill in plausible details."
+                onChange={e => setFreeText(e.target.value)}
+              />
+            </div>
+          ) : (
+            <div className="ccai-expert-structured">
+              <div className="ccai-expert-field">
+                <label>Identity statement</label>
+                <input
+                  type="text"
+                  value={identity}
+                  onChange={e => setIdentity(e.target.value)}
+                  placeholder="One-sentence 'who are you'"
+                />
+              </div>
+              <div className="ccai-expert-field">
+                <label>Profile / background</label>
+                <textarea
+                  value={profile}
+                  onChange={e => setProfile(e.target.value)}
+                  rows={3}
+                />
+              </div>
+              <div className="ccai-expert-field">
+                <label>Writing / speech samples</label>
+                <textarea
+                  value={samples}
+                  onChange={e => setSamples(e.target.value)}
+                  rows={3}
+                />
+              </div>
+            </div>
+          )}
+
+          <div className="ccai-expert-actions">
+            <button
+              className="btn-secondary"
+              onClick={handleGenerate}
+              disabled={busy || !modelId || !name.trim()}
+            >
+              {busy ? 'Generating role prompt...' : 'Generate role prompt'}
+            </button>
+          </div>
+
+          {generatedPrompt && (
+            <div className="ccai-expert-prompt">
+              <label>Generated role prompt (editable)</label>
+              <textarea
+                value={generatedPrompt}
+                onChange={e => setGeneratedPrompt(e.target.value)}
+                rows={6}
+              />
+            </div>
+          )}
+
+          {error && <div className="ccai-expert-error">{error}</div>}
+
+          <div className="ccai-expert-footer">
+            {initial && onDelete && (
+              <button
+                className="btn-sm ccai-remove-btn"
+                onClick={() => onDelete(initial.participant_id)}
+              >
+                <Trash2 size={12} /> Delete
+              </button>
+            )}
+            <div className="ccai-tab-spacer" />
+            <button className="btn-secondary" onClick={onClose}>Cancel</button>
+            <button
+              className="btn-primary"
+              disabled={!canSave}
+              onClick={handleSave}
+            >
+              <Save size={14} style={{ marginRight: 4, verticalAlign: 'middle' }} />
+              {initial ? 'Save changes' : 'Save persona'}
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/ExportBar.js

@@ -1,79 +0,0 @@
-import React, { useState, useRef, useEffect } from 'react';
-import { Download, Settings } from 'lucide-react';
-import { exportChat, exportApiLog } from '../utils/api';
-
-export default function ExportBar({ sessionId }) {
-  const [devOpen, setDevOpen] = useState(false);
-  const dropdownRef = useRef(null);
-
-  useEffect(() => {
-    const handleClickOutside = (e) => {
-      if (dropdownRef.current && !dropdownRef.current.contains(e.target)) {
-        setDevOpen(false);
-      }
-    };
-    document.addEventListener('mousedown', handleClickOutside);
-    return () => document.removeEventListener('mousedown', handleClickOutside);
-  }, []);
-
-  const downloadFile = (filename, content) => {
-    const blob = new Blob([content], { type: 'text/plain;charset=utf-8' });
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = filename;
-    a.click();
-    URL.revokeObjectURL(url);
-  };
-
-  const handleExport = async (fmt) => {
-    try {
-      const result = await exportChat(sessionId, fmt);
-      downloadFile(result.filename, result.content);
-    } catch (err) {
-      console.error('Export failed:', err);
-    }
-  };
-
-  const handleApiLogExport = async () => {
-    try {
-      const result = await exportApiLog(sessionId);
-      downloadFile('api_log.json', JSON.stringify(result, null, 2));
-      setDevOpen(false);
-    } catch (err) {
-      console.error('API log export failed:', err);
-    }
-  };
-
-  if (!sessionId) return null;
-
-  return (
-    <div className="export-bar">
-      <button className="btn-secondary" onClick={() => handleExport('txt')}>
-        <Download size={14} style={{ verticalAlign: 'middle', marginRight: 4 }} />
-        Download .txt
-      </button>
-      <button className="btn-secondary" onClick={() => handleExport('md')}>
-        <Download size={14} style={{ verticalAlign: 'middle', marginRight: 4 }} />
-        Download .md
-      </button>
-
-      <div className="dev-dropdown" ref={dropdownRef}>
-        <button
-          className="icon-btn"
-          onClick={() => setDevOpen(o => !o)}
-          title="Developer Options"
-        >
-          <Settings size={16} />
-        </button>
-        {devOpen && (
-          <div className="dev-dropdown-menu">
-            <button onClick={handleApiLogExport}>
-              Download Full API Log
-            </button>
-          </div>
-        )}
-      </div>
-    </div>
-  );
-}

frontend/src/components/FailsafePauseBanner.js

@@ -0,0 +1,27 @@
+import React from 'react';
+import { Play } from 'lucide-react';
+
+/**
+ * Inline banner shown when the orchestrator hits one of the two
+ * failsafes (60+20 messages, 100+50 orchestrator calls). User clicks
+ * Continue to grant another batch.
+ */
+export default function FailsafePauseBanner({ pause, onContinue }) {
+  if (!pause) return null;
+  const incLabel = pause.reason === 'messages' ? '+20 messages' : '+50 orchestrator calls';
+  const titleLabel = pause.reason === 'messages'
+    ? 'Conversation paused (message cap)'
+    : 'Conversation paused (orchestrator call cap)';
+  return (
+    <div className="ccai-failsafe-banner">
+      <div>
+        <div className="ccai-failsafe-title">{titleLabel}</div>
+        <div className="ccai-failsafe-text">{pause.message}</div>
+      </div>
+      <button className="btn-primary" onClick={() => onContinue(pause.reason)}>
+        <Play size={14} style={{ verticalAlign: 'middle', marginRight: 4 }} />
+        Continue conversation ({incLabel})
+      </button>
+    </div>
+  );
+}

frontend/src/components/Header.js

@@ -0,0 +1,64 @@
+import React from 'react';
+import { Sun, Moon } from 'lucide-react';
+import AuthBadge from './AuthBadge';
+import ParticipantDropdown from './ParticipantDropdown';
+import DevMenu from './DevMenu';
+
+/**
+ * Header bar: brand on the left; on the right, participant dropdown,
+ * settings, exports, table-view toggle, and the rate-limit-aware auth
+ * badge.
+ */
+export default function Header({
+  theme,
+  onToggleTheme,
+  auth,
+  dailyLimit,
+
+  catalog,
+  expertPersonas,
+  selectedIds,
+  maxParticipants,
+  onToggleParticipant,
+  onOpenExpertModal,
+
+  // dev menu props passed straight through
+  ...devProps
+}) {
+  return (
+    <header className="app-header">
+      <div className="header-left">
+        <a href="https://www.neon.ai/" target="_blank" rel="noopener noreferrer" className="header-brand-link">
+          <img src="/neon-logo.png" alt="Neon.ai" className="app-logo" />
+        </a>
+        <h1 className="app-title">
+          <a href="https://www.neon.ai/" target="_blank" rel="noopener noreferrer" className="app-title-link">
+            Neon.ai
+          </a> - CCAI Vibe Demo
+        </h1>
+      </div>
+      <div className="header-right">
+        <AuthBadge auth={auth} dailyLimit={dailyLimit} />
+        <ParticipantDropdown
+          catalog={catalog}
+          expertPersonas={expertPersonas}
+          selectedIds={selectedIds}
+          maxParticipants={maxParticipants}
+          onToggleParticipant={onToggleParticipant}
+          onOpenExpertModal={onOpenExpertModal}
+        />
+        <button
+          className="icon-btn"
+          onClick={onToggleTheme}
+          title="Toggle theme"
+        >
+          {theme === 'light' ? <Moon size={16} /> : <Sun size={16} />}
+        </button>
+        <DevMenu
+          {...devProps}
+          onOpenExpertModal={onOpenExpertModal}
+        />
+      </div>
+    </header>
+  );
+}

frontend/src/components/LLMSelector.js

@@ -1,159 +0,0 @@
-import React, { useCallback, useState } from 'react';
-import { Cloud, ChevronDown, ChevronRight, User } from 'lucide-react';
-
-export default function LLMSelector({ providers, neonModels, selections, onSelectionsChange }) {
-  const [openGroups, setOpenGroups] = useState({});
-
-  const toggleGroup = (key) => {
-    setOpenGroups(prev => ({ ...prev, [key]: !prev[key] }));
-  };
-
-  const handleClick = useCallback((modelId) => {
-    onSelectionsChange(prev => {
-      const isSelected = prev.includes(modelId);
-      const isBoth = prev.length === 2 && prev[0] === modelId && prev[1] === modelId;
-
-      if (isBoth) return [];
-
-      if (isSelected) return [modelId, modelId];
-
-      if (prev.length < 2) return [...prev, modelId];
-
-      return [prev[1], modelId];
-    });
-  }, [onSelectionsChange]);
-
-  const getIndicatorClass = (modelId) => {
-    const [a, b] = selections;
-    if (a === modelId && b === modelId) return 'select-indicator double-selected';
-    if (a === modelId) return 'select-indicator selected-a';
-    if (b === modelId) return 'select-indicator selected-b';
-    return 'select-indicator';
-  };
-
-  const getLabel = (modelId) => {
-    const [a, b] = selections;
-    if (a === modelId && b === modelId) return 'AB';
-    if (a === modelId) return 'A';
-    if (b === modelId) return 'B';
-    return '';
-  };
-
-  const shortName = (name) => name.split('/').pop() || name;
-
-  const renderModel = (model) => (
-    <button
-      key={model.id}
-      className="model-btn"
-      onClick={() => handleClick(model.id)}
-    >
-      <div className={getIndicatorClass(model.id)}>
-        {getLabel(model.id) && <span className="selection-label">{getLabel(model.id)}</span>}
-      </div>
-      <span className="model-name">{model.name}</span>
-      {model.params && <span className="model-params">{model.params}</span>}
-    </button>
-  );
-
-  const renderNeonPersona = (persona) => (
-    <button
-      key={persona.id}
-      className="neon-persona-item"
-      onClick={() => handleClick(persona.id)}
-    >
-      <div className={getIndicatorClass(persona.id)}>
-        {getLabel(persona.id) && <span className="selection-label">{getLabel(persona.id)}</span>}
-      </div>
-      <div className="persona-details">
-        <div className="persona-name-row">
-          <User size={12} />
-          {persona.name}
-        </div>
-        {persona.systemPrompt && (
-          <div className="persona-prompt-preview">
-            {persona.systemPrompt.slice(0, 120)}
-            {persona.systemPrompt.length > 120 ? '…' : ''}
-          </div>
-        )}
-        {!persona.systemPrompt && (
-          <div className="persona-prompt-preview">No system prompt (vanilla)</div>
-        )}
-      </div>
-    </button>
-  );
-
-  return (
-    <div className="sidebar">
-      <h2 className="sidebar-title">AI Models</h2>
-
-      {(neonModels || []).length > 0 && (
-        <div className="sidebar-section">
-          <h3 className="selector-title">
-            <img src="/neon-logo.png" alt="" className="selector-title-icon" />
-            Neon.ai Models
-          </h3>
-          <div className="neon-model-list">
-            {[...(neonModels || [])].sort((a, b) => shortName(a.name).localeCompare(shortName(b.name))).map(model => {
-              const key = `neon-${model.model_id}`;
-              const isOpen = !!openGroups[key];
-              const activePersonas = (model.personas || []).filter(p => p.enabled !== false);
-              return (
-                <div key={key} className="neon-model-card">
-                  <button
-                    className="neon-model-header"
-                    onClick={() => toggleGroup(key)}
-                  >
-                    <div className="neon-model-info">
-                      <span className="neon-model-name">{shortName(model.name)}</span>
-                      {model.version && <span className="neon-model-version">v{model.version}</span>}
-                    </div>
-                    <div className="neon-model-meta">
-                      {isOpen ? <ChevronDown size={16} /> : <ChevronRight size={16} />}
-                    </div>
-                  </button>
-                  {isOpen && (
-                    <div className="neon-persona-list">
-                      {activePersonas.map(persona => renderNeonPersona({
-                        id: `neon:${model.model_id}:${persona.persona_name}`,
-                        name: persona.persona_name,
-                        systemPrompt: persona.system_prompt || '',
-                      }))}
-                    </div>
-                  )}
-                </div>
-              );
-            })}
-          </div>
-        </div>
-      )}
-
-      {(providers || []).length > 0 && (
-        <div className="sidebar-section">
-          <h3 className="selector-title">
-            <Cloud size={16} />
-            Other Models
-          </h3>
-          {[...(providers || [])].sort((a, b) => a.name.localeCompare(b.name)).map(provider => {
-            const key = `prov-${provider.id}`;
-            const isOpen = !!openGroups[key];
-            return (
-              <div key={key} className="provider-group comp-group">
-                <button className="provider-accordion-header" onClick={() => toggleGroup(key)}>
-                  <span className="provider-accordion-title">{provider.name}</span>
-                  <span className="provider-accordion-meta">
-                    {isOpen ? <ChevronDown size={14} /> : <ChevronRight size={14} />}
-                  </span>
-                </button>
-                {isOpen && (
-                  <div className="model-list">
-                    {provider.models.map(renderModel)}
-                  </div>
-                )}
-              </div>
-            );
-          })}
-        </div>
-      )}
-    </div>
-  );
-}

frontend/src/components/MessageBubble.js

@@ -2,19 +2,52 @@ import React from 'react';
 import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 
-export default function MessageBubble({ message, showResponseTime }) {
-  const isA = message.speaker_idx === 0;
-  const side = isA ? 'a' : 'b';
-  const initial = message.speaker ? message.speaker.charAt(0).toUpperCase() : (isA ? 'A' : 'B');
-  const elapsed = message.elapsed_seconds;
+const PALETTE = [
+  { color: '#6366F1', bg: '#EEF2FF' },   // indigo
+  { color: '#059669', bg: '#ECFDF5' },   // emerald
+  { color: '#D97706', bg: '#FFFBEB' },   // amber
+  { color: '#DC2626', bg: '#FEE2E2' },   // red
+  { color: '#0891B2', bg: '#ECFEFF' },   // cyan
+  { color: '#7C3AED', bg: '#F5F3FF' },   // violet
+  { color: '#0D9488', bg: '#F0FDFA' },   // teal
+  { color: '#DB2777', bg: '#FDF2F8' },   // pink
+  { color: '#65A30D', bg: '#F7FEE7' },   // lime
+];
+
+function colorForIdx(idx) {
+  return PALETTE[idx % PALETTE.length];
+}
 
+/**
+ * Generic participant bubble. The CCAI demo can have up to 9 active
+ * participants, so we colorize by their index in the active roster
+ * rather than the original A/B scheme.
+ */
+export default function MessageBubble({ message, idx, showResponseTime }) {
+  const tone = colorForIdx(idx);
+  const initial = (message.speaker_name || '?').charAt(0).toUpperCase();
+  const elapsed = message.elapsed_seconds;
   return (
-    <div className={`message-row speaker-${side}`}>
-      <div className={`avatar avatar-${side}`}>
+    <div className="message-row ccai-message-row">
+      <div
+        className="avatar"
+        style={{ background: tone.color, borderRadius: '50%' }}
+      >
         {initial}
       </div>
-      <div className={`message-bubble bubble-${side}`}>
-        <div className="message-speaker">{message.speaker}</div>
+      <div
+        className="message-bubble ccai-bubble"
+        style={{
+          background: tone.bg,
+          border: `1px solid ${tone.color}33`,
+        }}
+      >
+        <div className="message-speaker" style={{ color: tone.color }}>
+          {message.speaker_name}
+          {message.model_display && (
+            <span className="ccai-bubble-model"> &middot; {message.model_display}</span>
+          )}
+        </div>
         <ReactMarkdown remarkPlugins={[remarkGfm]}>
           {message.text}
         </ReactMarkdown>

frontend/src/components/OrchestratorMessage.js

@@ -0,0 +1,32 @@
+import React from 'react';
+import ReactMarkdown from 'react-markdown';
+import remarkGfm from 'remark-gfm';
+
+/**
+ * Distinct rendering for orchestrator messages. Centered, italic, and
+ * a different color than participant bubbles so users always know who's
+ * speaking. Used for status updates, follow-up announcements, factor
+ * surfacing, and the final majority/no-consensus reports.
+ */
+export default function OrchestratorMessage({ message }) {
+  const isReport = message.kind === 'majority_report' || message.kind === 'no_consensus_report';
+  const className = (
+    'ccai-orchestrator-msg' +
+    (isReport ? ' ccai-orchestrator-msg-report' : '')
+  );
+  return (
+    <div className={className}>
+      <div className="ccai-orchestrator-msg-label">
+        Orchestrator{message.kind === 'majority_report' ? ' - Majority Report'
+          : message.kind === 'no_consensus_report' ? ' - No-Consensus Report'
+          : message.kind === 'factor' ? ' - New Consideration'
+          : ''}
+      </div>
+      <div className="ccai-orchestrator-msg-body">
+        <ReactMarkdown remarkPlugins={[remarkGfm]}>
+          {message.text || ''}
+        </ReactMarkdown>
+      </div>
+    </div>
+  );
+}

frontend/src/components/ParticipantDropdown.js

@@ -0,0 +1,136 @@
+import React, { useState, useRef, useEffect } from 'react';
+import { Users, Plus, ChevronDown } from 'lucide-react';
+
+/**
+ * Header dropdown that lists every available participant the user can
+ * pull into the conversation. Three sections:
+ *   - Neon (HANA personas, vanilla/RAG already filtered server-side)
+ *   - Extra (the four bundled non-Neon-LLM personas)
+ *   - Expert (user-created, stored in localStorage)
+ *
+ * Selecting a participant adds them to the active conversation list. The
+ * "Create Expert Persona..." entry opens the modal.
+ */
+export default function ParticipantDropdown({
+  catalog,
+  expertPersonas,
+  selectedIds,
+  maxParticipants,
+  onToggleParticipant,
+  onOpenExpertModal,
+}) {
+  const [open, setOpen] = useState(false);
+  const ref = useRef(null);
+
+  useEffect(() => {
+    function handleClickOutside(e) {
+      if (open && ref.current && !ref.current.contains(e.target)) {
+        setOpen(false);
+      }
+    }
+    document.addEventListener('mousedown', handleClickOutside);
+    return () => document.removeEventListener('mousedown', handleClickOutside);
+  }, [open]);
+
+  const isSelected = (id) => selectedIds.includes(id);
+  const atCap = selectedIds.length >= maxParticipants;
+
+  return (
+    <div className="ccai-dropdown-wrap" ref={ref}>
+      <button
+        className="btn-sm btn-outline ccai-dropdown-trigger"
+        onClick={() => setOpen(o => !o)}
+        title="Add or remove participants"
+      >
+        <Users size={14} />
+        <span>Participants ({selectedIds.length}/{maxParticipants})</span>
+        <ChevronDown size={12} />
+      </button>
+      {open && (
+        <div className="ccai-dropdown-panel">
+          <div className="ccai-dropdown-section">
+            <div className="ccai-dropdown-section-title">Neon.ai Personas</div>
+            {(catalog?.neon || []).length === 0 && (
+              <div className="ccai-dropdown-empty">
+                Neon personas unavailable - check HANA auth.
+              </div>
+            )}
+            {(catalog?.neon || []).map((p) => (
+              <DropdownItem
+                key={p.participant_id}
+                participant={p}
+                checked={isSelected(p.participant_id)}
+                disabledForAdd={atCap && !isSelected(p.participant_id)}
+                onToggle={() => onToggleParticipant(p, 'neon')}
+              />
+            ))}
+          </div>
+          <div className="ccai-dropdown-divider" />
+          <div className="ccai-dropdown-section">
+            <div className="ccai-dropdown-section-title">Extra Personas</div>
+            {(catalog?.extra || []).map((p) => (
+              <DropdownItem
+                key={p.participant_id}
+                participant={p}
+                checked={isSelected(p.participant_id)}
+                disabledForAdd={atCap && !isSelected(p.participant_id)}
+                onToggle={() => onToggleParticipant(p, 'extra')}
+              />
+            ))}
+          </div>
+          <div className="ccai-dropdown-divider" />
+          <div className="ccai-dropdown-section">
+            <div className="ccai-dropdown-section-title">Expert Personas</div>
+            {(expertPersonas || []).length === 0 && (
+              <div className="ccai-dropdown-empty">
+                You haven't created any expert personas yet.
+              </div>
+            )}
+            {(expertPersonas || []).map((p) => (
+              <DropdownItem
+                key={p.participant_id}
+                participant={p}
+                checked={isSelected(p.participant_id)}
+                disabledForAdd={atCap && !isSelected(p.participant_id)}
+                onToggle={() => onToggleParticipant(p, 'expert')}
+              />
+            ))}
+            <button
+              className="ccai-dropdown-create-btn"
+              onClick={() => { setOpen(false); onOpenExpertModal(null); }}
+            >
+              <Plus size={12} />
+              Create Expert Persona...
+            </button>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function DropdownItem({ participant, checked, disabledForAdd, onToggle }) {
+  return (
+    <label
+      className={
+        'ccai-dropdown-item' +
+        (checked ? ' ccai-dropdown-item-checked' : '') +
+        (disabledForAdd ? ' ccai-dropdown-item-disabled' : '')
+      }
+      title={disabledForAdd ? 'Participant cap reached' : ''}
+    >
+      <input
+        type="checkbox"
+        checked={checked}
+        disabled={disabledForAdd}
+        onChange={onToggle}
+      />
+      <div className="ccai-dropdown-item-text">
+        <div className="ccai-dropdown-item-name">{participant.name}</div>
+        <div className="ccai-dropdown-item-sub">
+          {participant.model_display || participant.default_model_id || ''}
+        </div>
+      </div>
+    </label>
+  );
+}