Merge pull request #1 from NeonClary/dev-cursor

Adding better chat formatting, menu items, title change & more

.cursor/rules/docker-build.mdc

@@ -0,0 +1,87 @@
+---
+description: Docker build cache conventions for CCAI-Vibe-Demo
+globs: Dockerfile,docker-compose*.yml,.dockerignore,backend/requirements.txt,frontend/package*.json
+alwaysApply: false
+---
+
+# Docker build cache conventions
+
+This project uses **BuildKit cache mounts** so `npm ci` and `pip install`
+skip the network when only source files change. Don't replace them
+with plain `RUN` commands - that reintroduces full re-downloads on every
+dependency change.
+
+## Required Dockerfile pattern
+
+The Dockerfile MUST start with the BuildKit syntax directive:
+
+```dockerfile
+# syntax=docker/dockerfile:1.7
+```
+
+### Frontend stage (root user, node:22-alpine)
+
+```dockerfile
+COPY frontend/package.json frontend/package-lock.json ./
+RUN --mount=type=cache,target=/root/.npm \
+    npm ci
+```
+
+### Backend stage (USER user, uid 1000, python:3.12-slim)
+
+```dockerfile
+COPY --chown=user backend/requirements.txt ./
+RUN --mount=type=cache,target=/home/user/.cache/pip,uid=1000,gid=1000 \
+    pip install --user -r requirements.txt
+```
+
+The `uid=1000,gid=1000` flags are mandatory because the cache target
+sits inside the unprivileged user's home dir. Without them the cache
+is created root-owned and pip cannot write to it.
+
+## Don'ts
+
+- **Don't** pass `--no-cache-dir` to `pip install`. It defeats the
+  cache mount. The mount lives outside the image, so wheels never
+  bloat the final layer either way.
+- **Don't** `COPY .` blindly. Layers must be copy-deps-first,
+  copy-source-second so a source edit doesn't bust the deps layer.
+- **Don't** add new files outside `backend/`, `frontend/` or the
+  lockfiles to a `COPY` line without first checking `.dockerignore`.
+
+## Build context (`.dockerignore`)
+
+The ignore list excludes `.git/`, `node_modules/`, `frontend/build/`,
+`agent-transcripts/`, `__pycache__`, secrets (`.env*`),
+`docker-compose.override.yml`, `backend/tests/`, and editor metadata.
+If you need a previously-ignored path inside the image, add a narrow
+`!path/to/keep` exception rather than removing the broad ignore.
+
+## Verifying the cache works
+
+After a Dockerfile or deps-file change, run two builds back to back:
+
+```powershell
+docker compose build
+docker compose build  # second time
+```
+
+The second build's `npm ci` / `pip install` step should print a
+`CACHED` line (when nothing in the deps file changed) or a
+near-instant `=> [internal] load build context` finish (when only
+source files changed). If it re-downloads, the cache mount is
+mis-configured.
+
+If a build ever errors with `the --mount option requires BuildKit`,
+opt in explicitly:
+
+```powershell
+$env:DOCKER_BUILDKIT=1; docker compose build
+```
+
+## HuggingFace Spaces compatibility
+
+HuggingFace's Docker Space builder honors the `# syntax=` directive
+and BuildKit cache mounts. Older builders silently treat the mounts
+as no-ops, so this Dockerfile remains forward-compatible with any
+plain-Docker environment.

.dockerignore

@@ -0,0 +1,61 @@
+# Build context exclusions for `docker build` / `docker compose build`.
+# Trimming the context speeds the daemon transfer and keeps cache hashes
+# stable: changes to ignored paths do NOT invalidate Dockerfile layers.
+
+# ── Git / VCS metadata ───────────────────────────────────────────────
+.git
+.gitignore
+.gitattributes
+.github
+
+# ── Cursor / agent transcripts (local IDE state, never needed in image)
+.cursor
+agent-transcripts
+.commit-msg.txt
+
+# ── Editor / OS junk ─────────────────────────────────────────────────
+.vscode
+.idea
+.DS_Store
+Thumbs.db
+*.swp
+
+# ── Secrets / env (image gets env at runtime via docker-compose)
+.env
+.env.*
+*.env
+!**/.env.example
+
+# ── Python local caches ──────────────────────────────────────────────
+**/__pycache__
+*.pyc
+*.pyo
+*.pyd
+*.egg-info
+.pytest_cache
+.mypy_cache
+.ruff_cache
+.venv
+venv
+
+# ── Node local caches & build outputs ────────────────────────────────
+# Lockfiles ARE included on purpose so `npm ci` is reproducible.
+**/node_modules
+frontend/build
+frontend/.next
+frontend/.cache
+**/.cache
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# ── Local-only docker compose overrides ──────────────────────────────
+# The base docker-compose.yml is needed for `docker compose build` from
+# the build dir, but the local override (which references absolute host
+# paths to a secrets file outside this repo) shouldn't end up in the
+# image build context.
+docker-compose.override.yml
+
+# ── Tests aren't shipped in the runtime image ────────────────────────
+# (Re-enable if you want to run pytest inside the deployed container.)
+backend/tests

Dockerfile

@@ -1,11 +1,29 @@
+# syntax=docker/dockerfile:1.7
+#
+# BuildKit cache mounts speed up rebuilds by persisting npm and pip
+# package caches across builds (outside the image - they don't bloat
+# the final layer). The first `docker compose build` is unchanged;
+# subsequent rebuilds skip the network for any unchanged dependency.
+#
+# The `# syntax=` directive auto-opts into BuildKit on Docker Desktop
+# 20.10+; HuggingFace Spaces also supports this directive. Older
+# builders silently treat the cache mounts as no-ops, so this file
+# remains forward-compatible.
+
 FROM node:22-alpine AS frontend-build
 WORKDIR /app/frontend
+
+# Copy lockfile + manifest first so the layer hash only changes when
+# deps actually change, not on every source edit.
 COPY frontend/package.json frontend/package-lock.json ./
-RUN npm ci
+RUN --mount=type=cache,target=/root/.npm \
+    npm ci
+
 COPY frontend/ ./
 ENV REACT_APP_API_URL=
 RUN npm run build
 
+
 FROM python:3.12-slim
 
 RUN useradd -m -u 1000 user
@@ -16,8 +34,11 @@ ENV HOME=/home/user \
 
 WORKDIR $HOME/app
 
+# Lockfile-equivalent first; cache mount targets the unprivileged
+# user's pip cache (uid/gid 1000 matches the `user` account).
 COPY --chown=user backend/requirements.txt ./
-RUN pip install --no-cache-dir -r requirements.txt
+RUN --mount=type=cache,target=/home/user/.cache/pip,uid=1000,gid=1000 \
+    pip install --user -r requirements.txt
 
 COPY --chown=user backend/ ./
 COPY --chown=user --from=frontend-build /app/frontend/build ./static

README.md

@@ -1,5 +1,5 @@
 ---
-title: CCAI Vibe Demo
+title: Collaborative Conversational AI (CCAI) Demo
 emoji: 🤝
 colorFrom: blue
 colorTo: purple
@@ -11,7 +11,7 @@ hf_oauth_scopes:
 pinned: false
 ---
 
-# CCAI Vibe Demo
+# Collaborative Conversational AI (CCAI) Demo
 
 A demo of **Collaborative Conversational AI (CCAI)** - Neon.ai's patented
 group-discussion technology. Up to 9 participants (any mix of AI personas,

backend/app/api/chat.py

@@ -21,13 +21,19 @@ from app.middleware.rate_limit import (
 )
 from app.services.extra_personas import get_extra_persona
 from app.services.models import (
+    CONVERSATION_LIMIT_BOUNDS,
+    CONVERSATION_LIMIT_DESCRIPTIONS,
+    ConversationLimits,
     DEFAULT_MAX_PARTICIPANTS,
     MAX_MAX_PARTICIPANTS,
     MIN_MAX_PARTICIPANTS,
     Participant,
     Phase,
     Session,
+    clamp_conversation_limits,
 )
+from app.services.auto_select import auto_select_participants
+from app.services.prompts.catalog import build_prompt_catalog
 from app.services.orchestrator import (
     create_session,
     get_session,
@@ -93,6 +99,27 @@ class ParticipantSelectionPayload(BaseModel):
     model_id_override: str | None = None
 
 
+class AutoSelectCandidate(BaseModel):
+    """One row of the candidate pool sent to the auto-select endpoint."""
+
+    participant_id: str
+    name: str
+    role_prompt: str = ""
+    kind: str = ""
+    model_id: str = ""
+
+
+class AutoSelectRequest(BaseModel):
+    """Body of POST /api/chat/auto-select-participants."""
+
+    question: str
+    count: int = 5
+    candidates: list[AutoSelectCandidate]
+    # Optional: pin the orchestrator model used for ranking. Defaults
+    # to the configured global orchestrator model.
+    orchestrator_model_id: str | None = None
+
+
 class StartChatRequest(BaseModel):
     question: str | None = None
 
@@ -103,6 +130,11 @@ class StartChatRequest(BaseModel):
     orchestrator_model_id: str | None = None
     summarizer_model_id: str | None = None
     max_participants: int = DEFAULT_MAX_PARTICIPANTS
+    # User-supplied overrides for the conversation's repetition /
+    # failsafe limits. Any field that is missing or out of range is
+    # silently clamped to the server-side default; see
+    # `clamp_conversation_limits` in services.models.
+    limits: dict[str, int] | None = None
 
 
 # ---------------------------------------------------------------------------
@@ -163,6 +195,87 @@ async def api_generate_role_freeform(req: GenerateRoleFreeformRequest):
     return result
 
 
+# ---------------------------------------------------------------------------
+# Prompt catalog (Transparency: "View current chat prompts")
+# ---------------------------------------------------------------------------
+
+@router.get("/chat/prompts/catalog")
+async def api_chat_prompts_catalog():
+    """Return every prompt template the orchestrator and participants
+    use during a chat, grouped by phase, each with a short purpose and
+    a list of runtime template variables. Used by the
+    PromptCatalogModal in the settings menu's Transparency section.
+
+    Shape:
+      {"groups": [{"title": "...", "items": [{"name", "purpose",
+       "variables", "template"}]}, ...]}
+    """
+    return build_prompt_catalog()
+
+
+# ---------------------------------------------------------------------------
+# Auto-select participants (LLM-based ranking for "Select N Automatically")
+# ---------------------------------------------------------------------------
+
+@router.post("/chat/auto-select-participants")
+async def api_auto_select_participants(req: AutoSelectRequest):
+    """Rank the candidate pool by relevance to the question and return
+    the top `count` participant_ids. The frontend calls this just
+    before /chat/start when the user has the auto-select toggle on.
+
+    Returns: {"selected": [id, ...], "rationale": "short string"}.
+    `selected` is exactly `count` long unless the candidate pool is
+    smaller. Invalid / hallucinated ids are silently dropped and
+    padded with the next unused candidates.
+    """
+    if not req.question or not req.question.strip():
+        raise HTTPException(400, "Question is required")
+    if not req.candidates:
+        raise HTTPException(400, "At least one candidate is required")
+    if req.count < 1:
+        raise HTTPException(400, "count must be >= 1")
+
+    candidates_payload = [c.dict() for c in req.candidates]
+    orchestrator_id = req.orchestrator_model_id or settings.orchestrator_model
+    result = await auto_select_participants(
+        orchestrator_model_id=orchestrator_id,
+        question=req.question,
+        candidates=candidates_payload,
+        count=req.count,
+    )
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Conversation limits (steppers in the settings menu)
+# ---------------------------------------------------------------------------
+
+@router.get("/chat/limits/defaults")
+async def api_chat_limits_defaults():
+    """Return defaults, bounds, and human-readable descriptions for the
+    `ConversationLimits` knobs the user can tune in the settings menu.
+
+    The frontend uses the `defaults` to initialize the steppers, the
+    `bounds` to set min/max and clamp on input, and the `descriptions`
+    to render the section headers and per-field help text. Keeping
+    this server-driven means we add a knob in one place
+    (services.models) and the UI picks it up without a frontend
+    change beyond rendering.
+    """
+    defaults = ConversationLimits()
+    return {
+        "defaults": {
+            field_name: getattr(defaults, field_name)
+            for field_name in CONVERSATION_LIMIT_BOUNDS.keys()
+        },
+        "bounds": {
+            field_name: {"min": lo, "max": hi}
+            for field_name, (lo, hi) in CONVERSATION_LIMIT_BOUNDS.items()
+        },
+        "descriptions": CONVERSATION_LIMIT_DESCRIPTIONS,
+    }
+
+
 # ---------------------------------------------------------------------------
 # Demo questions
 # ---------------------------------------------------------------------------
@@ -310,6 +423,12 @@ async def api_start_chat(req: StartChatRequest, request: Request):
     session.orchestrator_model_id = req.orchestrator_model_id
     session.summarizer_model_id = req.summarizer_model_id
     session.max_participants = max_p
+    # Attach the user-tunable limits and seed the runtime failsafe
+    # caps from them. clamp_conversation_limits silently coerces any
+    # missing or out-of-range values back to the defaults / bounds.
+    session.limits = clamp_conversation_limits(req.limits)
+    session.participant_message_cap = session.limits.participant_message_pause_at
+    session.orchestrator_call_cap = session.limits.orchestrator_call_pause_at
 
     async def event_stream():
         yield (
@@ -365,6 +484,23 @@ async def api_export_chat(session_id: str, fmt: str = "txt"):
     return _export_txt(session)
 
 
+@router.get("/chat/{session_id}/credentials")
+async def api_credentials(session_id: str):
+    """Return the orchestrator-generated Credential Summary for the
+    current session. Built after Phase 1 and refreshed once after Phase 2
+    critique - so the response can be empty if the user opens the modal
+    before Phase 1 finishes.
+    """
+    session = get_session(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    return {
+        "session_id": session_id,
+        "question": session.question,
+        "credentials": session.credential_summary or [],
+    }
+
+
 @router.get("/chat/{session_id}/api-log")
 async def api_export_log(session_id: str):
     session = get_session(session_id)
@@ -426,6 +562,88 @@ def _format_participants_block(session: Session) -> list[str]:
     ]
 
 
+def _credentials_intro_line() -> str:
+    """One-liner that explains where this block came from. Repeated in TXT
+    and MD exports so the file is self-explanatory without the UI."""
+    return (
+        "Orchestrator-generated assessments of each participant's "
+        "expertise, debating style, credibility on this question, and "
+        "biases to watch. Built after Phase 1 (initial opinions) and "
+        "refreshed once after Phase 2 (critique)."
+    )
+
+
+def _format_credential_block_txt(session: Session) -> list[str]:
+    """Plain-text Credential Summary section. Returns [] if no summary
+    has been built yet (e.g. user exports mid-Phase-1)."""
+    creds = session.credential_summary or []
+    if not creds:
+        return []
+    lines = ["Credential Summary", "-" * 40, _credentials_intro_line(), ""]
+    for c in creds:
+        name = c.get("name") or c.get("participant_id") or "(unknown)"
+        lines.append(f"{name}")
+        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:
+            try:
+                score = float(c["credibility_for_question"])
+                lines.append(f"  Credibility: {score:.2f} (0-1)")
+            except (TypeError, ValueError):
+                pass
+        if c.get("bias_to_watch"):
+            lines.append(f"  Bias:        {c['bias_to_watch']}")
+        lines.append("")
+    return lines
+
+
+def _format_credential_block_md(session: Session) -> list[str]:
+    """Markdown Credential Summary section. Returns [] when empty."""
+    creds = session.credential_summary or []
+    if not creds:
+        return []
+    lines = ["## Credential Summary", "", f"_{_credentials_intro_line()}_", ""]
+    for c in creds:
+        name = c.get("name") or c.get("participant_id") or "(unknown)"
+        lines.append(f"### {name}")
+        lines.append("")
+        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:
+            try:
+                score = float(c["credibility_for_question"])
+                lines.append(f"- **Credibility on this question:** {score:.2f} (0-1)")
+            except (TypeError, ValueError):
+                pass
+        if c.get("bias_to_watch"):
+            lines.append(f"- **Bias to watch:** {c['bias_to_watch']}")
+        lines.append("")
+    return lines
+
+
+def _credential_for(session: Session, participant_id: str) -> dict:
+    """Lookup helper used by the CSV writer. Empty dict if not built yet."""
+    for c in session.credential_summary or []:
+        if c.get("participant_id") == participant_id:
+            return c
+    return {}
+
+
+def _format_credibility_score(value: object) -> str:
+    """CSV-safe formatting for the credibility number (rounded float).
+    Returns "" when the value is missing or not numeric."""
+    if value is None:
+        return ""
+    try:
+        return f"{float(value):.2f}"
+    except (TypeError, ValueError):
+        return ""
+
+
 def _export_txt(session: Session) -> dict:
     lines = ["CCAI Conversation Log", "=" * 40, ""]
     lines.append("Question:")
@@ -434,6 +652,9 @@ def _export_txt(session: Session) -> dict:
     lines.append("Participants:")
     lines.extend(_format_participants_block(session))
     lines.append("")
+    cred_lines = _format_credential_block_txt(session)
+    if cred_lines:
+        lines.extend(cred_lines)
     for m in session.messages:
         speaker = m.get("speaker_name") or "(anon)"
         if m.get("role") == "orchestrator":
@@ -457,7 +678,12 @@ def _export_md(session: Session) -> dict:
     lines.append("")
     for p in session.participants:
         lines.append(f"- **{p.name}** (*{p.display_name}*)")
-    lines.append("\n---\n")
+    lines.append("")
+    cred_lines = _format_credential_block_md(session)
+    if cred_lines:
+        lines.extend(cred_lines)
+    lines.append("---")
+    lines.append("")
     for m in session.messages:
         speaker = m.get("speaker_name") or "(anon)"
         is_orch = m.get("role") == "orchestrator"
@@ -478,7 +704,12 @@ def _export_md(session: Session) -> dict:
 
 
 def _export_csv_table(session: Session) -> dict:
-    """RFC-4180 compliant CSV. csv.writer handles quoting/escaping."""
+    """RFC-4180 compliant CSV. csv.writer handles quoting/escaping.
+
+    Columns include the orchestrator-generated Credential Summary so
+    the table is self-contained: who each participant is (per the
+    orchestrator's read), then what they said and how it evolved.
+    """
     buf = io.StringIO()
     writer = csv.writer(buf, quoting=csv.QUOTE_MINIMAL, lineterminator="\n")
 
@@ -488,14 +719,23 @@ def _export_csv_table(session: Session) -> dict:
     writer.writerow([])
     writer.writerow([
         "Participant",
+        "Expertise (orchestrator's read)",
+        "Style",
+        "Credibility on this question (0-1)",
+        "Bias to watch",
         "First opinion",
         "Conversation contribution",
         "Revised opinion",
         "Final opinion",
     ])
     for p in session.participants:
+        cred = _credential_for(session, p.participant_id)
         writer.writerow([
             p.name,
+            cred.get("expertise", ""),
+            cred.get("personality", ""),
+            _format_credibility_score(cred.get("credibility_for_question")),
+            cred.get("bias_to_watch", ""),
             (session.initial_opinions or {}).get(p.participant_id, ""),
             (session.contribution_summaries or {}).get(p.participant_id, ""),
             (session.final_opinions or {}).get(p.participant_id, ""),

backend/app/data/demo_questions.json

@@ -50,10 +50,10 @@
       "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": "four_day_workweek",
+      "category": "workplace / management",
+      "title": "Whether a 220-person firm should adopt a permanent 4-day work week",
+      "text": "I'm the COO of a 220-person professional-services firm in the Midwest US (architecture and engineering consulting). Two of our regional competitors have piloted 4-day work weeks for the past year and are leaning on it heavily in their recruiting; we've lost three good candidates to them in the last six months. Our partners are split on whether to follow. The case for: better retention, a stronger applicant pipeline, well-publicized productivity gains in some studies, and our work is mostly project-based so client deliverables don't strictly need a Friday. The case against: about 30% of our work involves real-time coordination with construction crews and government agencies that operate Mon-Fri; some senior partners worry it signals we are unserious; to absorb the cost we'd need to either stretch hours into longer days, cut staffing slightly, or accept lower billable utilization for at least the first year; and we have no clean way to roll it back if it doesn't work. Roughly half our staff are early-career employees with young kids; the other half are senior people who built the firm working 60-hour weeks and have mixed feelings about offering juniors a shorter week. Should we do it, what structure makes sense if we do, and how would we know at the 12-month mark whether it's working?"
     },
     {
       "id": "community_park_grant",

backend/app/main.py

@@ -41,7 +41,11 @@ async def lifespan(app: FastAPI):
     await close_shared_client()
 
 
-app = FastAPI(title="CCAI Vibe Demo", version="1.0.0", lifespan=lifespan)
+app = FastAPI(
+    title="Collaborative Conversational AI (CCAI) Demo",
+    version="1.0.0",
+    lifespan=lifespan,
+)
 
 app.add_middleware(
     SessionMiddleware,

backend/app/services/auto_select.py

@@ -0,0 +1,142 @@
+"""Auto-select N participants for a question.
+
+Backs the optional "Select N Automatically" toggle in the participants
+dropdown. The orchestrator LLM ranks the full candidate pool for
+relevance to the question and returns the top N. The service:
+
+- formats a compact candidates block (id + name + role role-prompt
+  snippet) so the LLM can pick deliberately;
+- runs the call through `orchestrator_call` (which strips think
+  traces and is JSON-tolerant);
+- validates every returned id against the candidate pool, drops
+  invented ones, and pads with the next-best unused candidates if the
+  LLM under-delivered.
+
+If the orchestrator call fails entirely, we fall back to the first N
+candidates in the order received, so the user still gets a working
+chat instead of a hard error.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from app.services.json_calls import orchestrator_call
+from app.services.prompts import AUTO_SELECT_PARTICIPANTS_PROMPT
+
+LOG = logging.getLogger(__name__)
+
+_ROLE_SNIPPET_CHARS = 320
+
+
+def _candidate_block(candidates: list[dict[str, Any]]) -> str:
+    """Render one line per candidate: id, name, kind, model, role snippet.
+
+    Role prompts are truncated so a roster of ~30 candidates fits in
+    a single orchestrator call without crowding out the question.
+    """
+    lines: list[str] = []
+    for i, c in enumerate(candidates, start=1):
+        role = (c.get("role_prompt") or "").strip()
+        if len(role) > _ROLE_SNIPPET_CHARS:
+            role = role[:_ROLE_SNIPPET_CHARS].rstrip() + "..."
+        lines.append(
+            f"{i}. id={c.get('participant_id')} | name={c.get('name')} "
+            f"| kind={c.get('kind')} | model={c.get('model_id')}\n"
+            f"   role: {role or '(no role description)'}"
+        )
+    return "\n".join(lines)
+
+
+def _validate_and_pad(
+    selected_raw: list[str] | None,
+    candidates: list[dict[str, Any]],
+    count: int,
+) -> list[str]:
+    """Keep only LLM-returned ids that exist in the candidate pool,
+    de-dupe while preserving the LLM's ranking, and pad with the next
+    unused candidates (in input order) up to `count`.
+    """
+    valid_ids = {c.get("participant_id") for c in candidates if c.get("participant_id")}
+    chosen: list[str] = []
+    seen: set[str] = set()
+    for sid in selected_raw or []:
+        if not isinstance(sid, str):
+            continue
+        if sid in valid_ids and sid not in seen:
+            chosen.append(sid)
+            seen.add(sid)
+        if len(chosen) == count:
+            break
+
+    if len(chosen) < count:
+        # Pad with the first unused candidates in the order received.
+        for c in candidates:
+            pid = c.get("participant_id")
+            if not pid or pid in seen:
+                continue
+            chosen.append(pid)
+            seen.add(pid)
+            if len(chosen) == count:
+                break
+
+    return chosen[:count]
+
+
+async def auto_select_participants(
+    *,
+    orchestrator_model_id: str,
+    question: str,
+    candidates: list[dict[str, Any]],
+    count: int,
+    api_log: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Return {"selected": [participant_id, ...], "rationale": str}.
+
+    `selected` is always exactly `count` long (padded from the
+    candidate pool if the LLM under-delivers). Never raises on LLM
+    errors - those degrade to a first-N fallback so the caller can
+    proceed to /chat/start.
+    """
+    n_target = max(1, min(count, len(candidates)))
+
+    if not candidates:
+        return {"selected": [], "rationale": "No candidates provided."}
+
+    # Single-candidate / under-supplied pools have nothing to pick from.
+    if len(candidates) <= n_target:
+        return {
+            "selected": [c["participant_id"] for c in candidates if c.get("participant_id")],
+            "rationale": "Candidate pool was at or below the requested count; using all.",
+        }
+
+    prompt = AUTO_SELECT_PARTICIPANTS_PROMPT.format(
+        question=question.strip(),
+        candidates_block=_candidate_block(candidates),
+        count=n_target,
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=orchestrator_model_id,
+        user_prompt=prompt,
+        label="auto_select_participants",
+        api_log=api_log,
+        max_tokens=512,
+        temperature=0.2,
+    )
+
+    selected_raw: list[str] | None = None
+    rationale = ""
+    if isinstance(parsed, dict):
+        if isinstance(parsed.get("selected"), list):
+            selected_raw = [str(x) for x in parsed["selected"]]
+        if isinstance(parsed.get("rationale"), str):
+            rationale = parsed["rationale"].strip()
+
+    selected = _validate_and_pad(selected_raw, candidates, n_target)
+
+    if not rationale:
+        rationale = "Selected by relevance to the question."
+    if not selected_raw:
+        rationale = "Auto-select fell back to the first candidates (LLM unavailable)."
+
+    return {"selected": selected, "rationale": rationale}

backend/app/services/models.py

@@ -16,8 +16,13 @@ from app.services.context_budget import ContextSummary
 
 class Phase(str, Enum):
     INITIAL_OPINIONS = "initial_opinions"
+    # Critique-round phases: up to 4 rounds are supported (matches the
+    # max value of `ConversationLimits.critique_rounds`). The state
+    # machine looks the active phase up via `_critique_phase_for(n)`.
     CRITIQUE_ROUND_1 = "critique_round_1"
     CRITIQUE_ROUND_2 = "critique_round_2"
+    CRITIQUE_ROUND_3 = "critique_round_3"
+    CRITIQUE_ROUND_4 = "critique_round_4"
     STATUS_ASSESSMENT = "status_assessment"
     FINALIZATION = "finalization"
     CONSENSUS = "consensus"
@@ -35,12 +40,192 @@ 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).
+# These remain the *defaults* for ConversationLimits; the runtime values
+# come from Session.limits so the user can tune them per-conversation.
 PARTICIPANT_MESSAGE_PAUSE_AT = 60
 PARTICIPANT_MESSAGE_PAUSE_INC = 20
 ORCHESTRATOR_CALL_PAUSE_AT = 100
 ORCHESTRATOR_CALL_PAUSE_INC = 50
 
 
+@dataclass
+class ConversationLimits:
+    """Tunable repetition and failsafe limits for one CCAI session.
+
+    Defaults match the historical hard-coded values; the API layer
+    clamps user-supplied overrides via `clamp_conversation_limits` so
+    out-of-range values don't break the orchestrator. The frontend
+    gets the defaults + bounds + descriptions from
+    GET /api/chat/limits/defaults so the settings UI is server-driven.
+    """
+
+    # ── Discussion structure ──────────────────────────────────────
+    # How many critique turns each participant gets in Phase 2.
+    critique_rounds: int = 2
+    # How many times Phase 3 will surface a follow-up question
+    # (orchestrator-synthesized or relayed from a participant) before
+    # moving on to finalization. 0 skips Phase 3 entirely.
+    status_assessment_max: int = 3
+    # Phase 5 turn budget = this number x active participants. Higher
+    # means more back-and-forth before the conversation auto-ends.
+    consensus_turns_per_participant: int = 6
+    # In Phase 5, how many consecutive "addressed-to" routings (one
+    # participant addresses another, then is answered, etc.) before
+    # we force a round-robin pick. Prevents two participants from
+    # monopolizing the floor.
+    dyad_cap: int = 2
+    # If consensus fails the first time, how many additional attempts
+    # the orchestrator makes by surfacing a new factor for the group
+    # to consider. 0 disables retries.
+    stall_recovery_attempts: int = 1
+
+    # ── Reliability ──────────────────────────────────────────────
+    # If a participant's LLM call fails this many times in a row, the
+    # orchestrator auto-disables them for the rest of the chat.
+    auto_disable_failures: int = 3
+
+    # ── Failsafes ────────────────────────────────────────────────
+    # First pause point for participant messages (then increments).
+    participant_message_pause_at: int = PARTICIPANT_MESSAGE_PAUSE_AT
+    participant_message_pause_inc: int = PARTICIPANT_MESSAGE_PAUSE_INC
+    # First pause point for orchestrator-side LLM calls (then increments).
+    orchestrator_call_pause_at: int = ORCHESTRATOR_CALL_PAUSE_AT
+    orchestrator_call_pause_inc: int = ORCHESTRATOR_CALL_PAUSE_INC
+
+
+# (min, max) bounds for each limit field. Any user-supplied value is
+# clamped to this range server-side. Keep these conservative enough
+# to stop runaway conversations and tight enough to keep behavior
+# recognizable; widening is fine if a real use case emerges.
+CONVERSATION_LIMIT_BOUNDS: dict[str, tuple[int, int]] = {
+    "critique_rounds":                  (1, 4),
+    "status_assessment_max":            (0, 5),
+    "consensus_turns_per_participant":  (2, 12),
+    "dyad_cap":                         (1, 5),
+    "stall_recovery_attempts":          (0, 3),
+    "auto_disable_failures":            (1, 10),
+    "participant_message_pause_at":     (10, 500),
+    "participant_message_pause_inc":    (5, 100),
+    "orchestrator_call_pause_at":       (20, 500),
+    "orchestrator_call_pause_inc":      (10, 200),
+}
+
+
+# Human-readable descriptions surfaced in the settings UI alongside
+# each stepper. Group key controls the section header.
+CONVERSATION_LIMIT_DESCRIPTIONS: dict[str, dict[str, str]] = {
+    "critique_rounds": {
+        "group": "Discussion structure",
+        "label": "Critique rounds",
+        "help": (
+            "How many times each participant speaks in Phase 2 "
+            "(critique). More rounds give the group more chances to "
+            "challenge each other; fewer rounds wraps faster."
+        ),
+    },
+    "status_assessment_max": {
+        "group": "Discussion structure",
+        "label": "Status-assessment iterations",
+        "help": (
+            "Max number of follow-up questions the orchestrator may "
+            "surface in Phase 3 before moving to opinion finalization. "
+            "Set to 0 to skip the follow-up phase entirely."
+        ),
+    },
+    "consensus_turns_per_participant": {
+        "group": "Discussion structure",
+        "label": "Consensus turns per participant",
+        "help": (
+            "Multiplier on the Phase 5 (consensus) turn budget. The "
+            "actual cap is this number times the count of active "
+            "participants. Higher = more debate before timeout."
+        ),
+    },
+    "dyad_cap": {
+        "group": "Discussion structure",
+        "label": "Dyad cap",
+        "help": (
+            "In Phase 5, how many consecutive addressed-to replies "
+            "(A->B->A->...) are allowed before the orchestrator forces "
+            "a round-robin pick. Keeps two voices from monopolizing."
+        ),
+    },
+    "stall_recovery_attempts": {
+        "group": "Discussion structure",
+        "label": "Stall recovery attempts",
+        "help": (
+            "If the group can't reach majority and the conversation "
+            "stalls, how many extra attempts the orchestrator makes "
+            "by surfacing a new factor for the group to consider."
+        ),
+    },
+    "auto_disable_failures": {
+        "group": "Reliability",
+        "label": "Auto-disable after N failures",
+        "help": (
+            "If a participant's LLM fails this many times in a row, "
+            "the orchestrator removes them from the rest of the chat "
+            "rather than keep trying."
+        ),
+    },
+    "participant_message_pause_at": {
+        "group": "Failsafes",
+        "label": "First pause: participant messages",
+        "help": (
+            "Total participant messages allowed before the "
+            "conversation pauses for a 'Continue' confirmation."
+        ),
+    },
+    "participant_message_pause_inc": {
+        "group": "Failsafes",
+        "label": "Each subsequent pause: +N messages",
+        "help": (
+            "After the first pause, this many additional participant "
+            "messages are allowed before the next pause."
+        ),
+    },
+    "orchestrator_call_pause_at": {
+        "group": "Failsafes",
+        "label": "First pause: orchestrator calls",
+        "help": (
+            "Total orchestrator-side LLM calls (assessments, "
+            "summaries, classifications) allowed before the "
+            "conversation pauses for a 'Continue' confirmation."
+        ),
+    },
+    "orchestrator_call_pause_inc": {
+        "group": "Failsafes",
+        "label": "Each subsequent pause: +N orchestrator calls",
+        "help": (
+            "After the first orchestrator-call pause, this many "
+            "additional calls are allowed before the next pause."
+        ),
+    },
+}
+
+
+def clamp_conversation_limits(payload: dict[str, Any] | None) -> ConversationLimits:
+    """Build a ConversationLimits from a partial dict. Each field is
+    clamped to its declared (min, max) range; missing or non-int values
+    fall back to the dataclass default. Never raises - any failure
+    silently degrades to the default for that one field.
+    """
+    limits = ConversationLimits()
+    if not payload:
+        return limits
+    for field_name, (lo, hi) in CONVERSATION_LIMIT_BOUNDS.items():
+        if field_name not in payload:
+            continue
+        raw = payload.get(field_name)
+        try:
+            v = int(raw)
+        except (TypeError, ValueError):
+            continue
+        v = max(lo, min(hi, v))
+        setattr(limits, field_name, v)
+    return limits
+
+
 @dataclass
 class Participant:
     """One member of the CCAI forum.
@@ -122,7 +307,16 @@ class Session:
     # Per-participant contribution summaries for the table view
     contribution_summaries: dict[str, str] = field(default_factory=dict)
 
-    # Failsafes
+    # User-tunable limits for this conversation. Defaults match the
+    # legacy hard-coded values; the API layer overrides via
+    # `clamp_conversation_limits` from the request payload. The
+    # orchestrator reads only from `session.limits.*`, never the
+    # module-level constants, so behavior is fully driven by config.
+    limits: ConversationLimits = field(default_factory=ConversationLimits)
+
+    # Failsafes (runtime state). The *_cap fields start at the limits'
+    # configured first-pause point and grow by the configured increment
+    # each time the user clicks Continue.
     total_participant_messages: int = 0
     participant_message_cap: int = PARTICIPANT_MESSAGE_PAUSE_AT
     orchestrator_call_count: int = 0

backend/app/services/orchestrator.py

@@ -59,8 +59,6 @@ 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,
@@ -249,25 +247,30 @@ async def _wait_for_continue(
     session: Session,
     reason: str,
 ) -> AsyncIterator[str]:
-    """Pause the state machine until the user clicks Continue."""
+    """Pause the state machine until the user clicks Continue.
+
+    Increment values come from `session.limits`, which the user can
+    tune via the settings menu. Defaults match the historical
+    PARTICIPANT_MESSAGE_PAUSE_INC / ORCHESTRATOR_CALL_PAUSE_INC.
+    """
     session.paused_for_continue = True
     session.pause_reason = reason
     if reason == "messages":
+        bump_inc = session.limits.participant_message_pause_inc
         msg = (
             f"Conversation paused after {session.total_participant_messages} "
             "participant messages. Click Continue to allow another "
-            f"{PARTICIPANT_MESSAGE_PAUSE_INC} messages."
+            f"{bump_inc} messages."
         )
         evt = "failsafe_pause"
-        bump_inc = PARTICIPANT_MESSAGE_PAUSE_INC
     else:
+        bump_inc = session.limits.orchestrator_call_pause_inc
         msg = (
             f"Conversation paused after {session.orchestrator_call_count} "
             "orchestrator calls. Click Continue to allow another "
-            f"{ORCHESTRATOR_CALL_PAUSE_INC} orchestrator calls."
+            f"{bump_inc} orchestrator calls."
         )
         evt = "orchestrator_cap_pause"
-        bump_inc = ORCHESTRATOR_CALL_PAUSE_INC
 
     yield _sse(evt, {
         "reason": reason,
@@ -498,10 +501,13 @@ async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
                 "name": p.name,
                 "phase": session.phase.value,
             })
-            if p.consecutive_failures >= 3:
+            if p.consecutive_failures >= session.limits.auto_disable_failures:
                 p.enabled = False
                 yield _sse("status", {
-                    "message": f"{p.name} auto-disabled after 3 failures.",
+                    "message": (
+                        f"{p.name} auto-disabled after "
+                        f"{session.limits.auto_disable_failures} failures."
+                    ),
                 })
             continue
         msg = _add_participant_message(session, p, text, phase=session.phase, elapsed=elapsed)
@@ -522,14 +528,36 @@ async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
     )
     _bump_orchestrator_count(session)
     session.credential_summary = creds
+    # Surface the freshly-built summary so the frontend can enable the
+    # "View Credential Summary" menu item and cache its snapshot. The
+    # full list also stays available via GET /api/chat/{id}/credentials.
+    yield _sse("credentials_updated", {
+        "stage": "built",
+        "credentials": session.credential_summary,
+    })
+
+
+_CRITIQUE_PHASES = {
+    1: Phase.CRITIQUE_ROUND_1,
+    2: Phase.CRITIQUE_ROUND_2,
+    3: Phase.CRITIQUE_ROUND_3,
+    4: Phase.CRITIQUE_ROUND_4,
+}
+
+
+def _critique_phase_for(round_number: int) -> Phase:
+    """Map a critique round number to the matching Phase enum value.
+    Falls back to CRITIQUE_ROUND_2 for unknown numbers - the API layer
+    clamps `critique_rounds` to the bounds, so this fallback is purely
+    defensive."""
+    return _CRITIQUE_PHASES.get(round_number, Phase.CRITIQUE_ROUND_2)
 
 
 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
-    )
+    session.phase = _critique_phase_for(round_number)
+    round_total = session.limits.critique_rounds
     yield _sse("status", {
-        "message": f"Phase 2: critique round {round_number} of 2...",
+        "message": f"Phase 2: critique round {round_number} of {round_total}...",
     })
     cred_block = credentials_to_block(session.credential_summary)
     actives = _active_participants(session)
@@ -542,6 +570,7 @@ async def _phase_critique(session: Session, round_number: int) -> AsyncIterator[
         pending_block = _format_pending_block(pending)
         prompt = CRITIQUE_PROMPT.format(
             round_number=round_number,
+            round_total=round_total,
             question=session.question,
             credential_summary=cred_block,
             transcript=transcript,
@@ -558,9 +587,14 @@ async def _phase_critique(session: Session, round_number: int) -> AsyncIterator[
                 "participant_id": p.participant_id, "name": p.name,
                 "phase": session.phase.value,
             })
-            if p.consecutive_failures >= 3:
+            if p.consecutive_failures >= session.limits.auto_disable_failures:
                 p.enabled = False
-                yield _sse("status", {"message": f"{p.name} auto-disabled after 3 failures."})
+                yield _sse("status", {
+                    "message": (
+                        f"{p.name} auto-disabled after "
+                        f"{session.limits.auto_disable_failures} failures."
+                    ),
+                })
             continue
 
         # Detect addressed_to so the consensus phase's targeted-response
@@ -607,10 +641,15 @@ async def _phase_status_assessment(session: Session) -> AsyncIterator[str]:
         api_log=session.api_log,
     )
     _bump_orchestrator_count(session)
-    session.credential_summary = refreshed
+    if refreshed != session.credential_summary:
+        session.credential_summary = refreshed
+        yield _sse("credentials_updated", {
+            "stage": "refreshed",
+            "credentials": session.credential_summary,
+        })
     cred_block = credentials_to_block(session.credential_summary)
 
-    for iteration in range(3):
+    for iteration in range(session.limits.status_assessment_max):
         session.status_assessment_iterations = iteration + 1
         prompt = STATUS_ASSESSMENT_PROMPT.format(
             question=session.question,
@@ -802,17 +841,19 @@ async def _phase_consensus(session: Session) -> AsyncIterator[str]:
     # Round-robin among active participants, but yield to the addressed-to
     # target whenever the previous message named one explicitly. To keep
     # two participants from monopolizing the floor with an A->B->A->B
-    # loop, we cap consecutive addressed-to routings at DYAD_CAP. After
-    # that many in a row, we force a round-robin pick on the next turn.
+    # loop, we cap consecutive addressed-to routings at the configured
+    # `dyad_cap`. After that many in a row, we force a round-robin pick.
     queue: list[Participant] = list(actives)
     last_addressed: str | None = None
     dyad_run: int = 0
-    DYAD_CAP = 2  # one full A->B->A exchange, then rotate
+    dyad_cap = session.limits.dyad_cap
 
     # 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)
+    # call cap will usually hit before this, but it's a clean upper bound.
+    max_consensus_turns = (
+        session.limits.consensus_turns_per_participant * len(actives)
+    )
     consensus_turns = 0
 
     while consensus_turns < max_consensus_turns:
@@ -821,7 +862,7 @@ async def _phase_consensus(session: Session) -> AsyncIterator[str]:
         # Pick speaker. Prefer the addressed-to target (dyadic exchange)
         # only while we're under the consecutive-routing cap. Once the
         # cap is hit, force a round-robin pick so a third voice can join.
-        if last_addressed and dyad_run < DYAD_CAP:
+        if last_addressed and dyad_run < dyad_cap:
             speaker = next(
                 (p for p in actives if p.participant_id == last_addressed),
                 None,
@@ -1081,8 +1122,10 @@ async def _phase_closure(session: Session) -> AsyncIterator[str]:
             yield _sse("orchestrator", _msg_payload(msg))
             return
 
-    # Not productive / no majority. First time -> surface unaddressed factor.
-    if session.consensus_attempts < 1:
+    # Not productive / no majority. We may surface an unaddressed
+    # factor and re-run consensus up to `stall_recovery_attempts` times
+    # before giving up and emitting the no-consensus report.
+    if session.consensus_attempts < session.limits.stall_recovery_attempts:
         session.consensus_attempts += 1
         factor = await find_unaddressed_factor(
             orchestrator_model_id=_orchestrator_model_id(session),
@@ -1164,10 +1207,9 @@ async def run_conversation(session: Session) -> AsyncIterator[str]:
         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
+        for round_n in range(1, session.limits.critique_rounds + 1):
+            async for chunk in _phase_critique(session, round_n):
+                yield chunk
 
         async for chunk in _phase_status_assessment(session):
             yield chunk

backend/app/services/prompts/__init__.py

@@ -35,6 +35,7 @@ from app.services.prompts.closure import (
     NO_CONSENSUS_REPORT_PROMPT,
     CONTRIBUTION_SUMMARY_PROMPT,
 )
+from app.services.prompts.auto_select import AUTO_SELECT_PARTICIPANTS_PROMPT
 
 __all__ = [
     "PARTICIPANT_BASE_DIRECTIVE",
@@ -57,4 +58,5 @@ __all__ = [
     "MAJORITY_REPORT_PROMPT",
     "NO_CONSENSUS_REPORT_PROMPT",
     "CONTRIBUTION_SUMMARY_PROMPT",
+    "AUTO_SELECT_PARTICIPANTS_PROMPT",
 ]

backend/app/services/prompts/auto_select.py

@@ -0,0 +1,28 @@
+"""Prompt for the optional "Select N Automatically" mode.
+
+The user can enable an auto-select toggle in the participants dropdown;
+when they start a chat, the orchestrator LLM ranks every available
+candidate persona for relevance to the question and returns the top N.
+"""
+
+AUTO_SELECT_PARTICIPANTS_PROMPT = (
+    "You are helping pick the most relevant participants for a CCAI "
+    "group discussion. The user has asked the following question:\n\n"
+    "<<<\n{question}\n>>>\n\n"
+    "Here are the candidate participants. Each has a `participant_id`, "
+    "a display `name`, and a role description (`role_prompt`).\n\n"
+    "{candidates_block}\n\n"
+    "Pick the {count} participants whose expertise and perspective are "
+    "MOST relevant and complementary for this question. Aim for "
+    "diversity of viewpoint as well as topical fit - a group of five "
+    "experts who all think the same way is less useful than five who "
+    "will productively disagree.\n\n"
+    "Reply with ONLY a JSON object of the exact shape:\n"
+    "{{\n"
+    "  \"selected\": [\"participant_id_1\", \"participant_id_2\", ...],\n"
+    "  \"rationale\": \"one short sentence explaining the mix\"\n"
+    "}}\n\n"
+    "`selected` MUST contain exactly {count} ids drawn ONLY from the "
+    "candidate list above, in order of relevance (most relevant first). "
+    "Do not invent ids."
+)

backend/app/services/prompts/catalog.py

@@ -0,0 +1,308 @@
+"""Hand-curated catalog of every prompt template the CCAI orchestrator
+and participants use, organized by the order they fire during a chat.
+
+This backs GET /api/chat/prompts/catalog, which feeds the "View current
+chat prompts" modal in the settings menu. The goal is user-facing
+transparency: a non-technical user should be able to scroll the modal
+and understand exactly what the orchestrator asks each participant to
+do at each phase.
+
+The catalog is intentionally explicit (rather than auto-discovered) so
+the per-prompt `purpose` strings can stay readable and so the
+ordering matches the live conversation flow even when prompts are
+imported from different modules.
+"""
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from app.services.prompts import (
+    ADDRESSED_TO_PROMPT,
+    ALLIANCE_DETECTION_PROMPT,
+    AUTO_SELECT_PARTICIPANTS_PROMPT,
+    CONSENSUS_ALLIED_PROMPT,
+    CONSENSUS_SOLO_PROMPT,
+    CONSENSUS_STATUS_PROMPT,
+    CONTRIBUTION_SUMMARY_PROMPT,
+    CREDENTIAL_BUILD_PROMPT,
+    CREDENTIAL_REFRESH_PROMPT,
+    CRITIQUE_PROMPT,
+    FINALIZATION_PROMPT,
+    INITIAL_OPINION_PROMPT,
+    MAJORITY_REPORT_PROMPT,
+    NO_CONSENSUS_REPORT_PROMPT,
+    NO_REASONING_DIRECTIVE,
+    ORCHESTRATOR_BASE_DIRECTIVE,
+    PARTICIPANT_BASE_DIRECTIVE,
+    STATUS_ASSESSMENT_PROMPT,
+    TARGETED_FOLLOWUP_FROM_PARTICIPANT_PROMPT,
+    TARGETED_FOLLOWUP_PROMPT,
+    UNADDRESSED_FACTOR_PROMPT,
+)
+
+
+# Each entry: (constant_name, prompt_text, purpose). The frontend will
+# also derive {var} placeholders from the prompt text directly, but
+# `name` and `purpose` stay hand-curated for readability.
+_PROMPTS_BY_NAME: dict[str, tuple[str, str]] = {
+    # ── Always-on directives ─────────────────────────────────────
+    "PARTICIPANT_BASE_DIRECTIVE": (
+        PARTICIPANT_BASE_DIRECTIVE,
+        "Appended to every participant's role prompt so they know they "
+        "are in a CCAI forum, who the other participants are, and that "
+        "the orchestrator (not them) controls the floor.",
+    ),
+    "NO_REASONING_DIRECTIVE": (
+        NO_REASONING_DIRECTIVE,
+        "Hard 'no reasoning, no meta-commentary' guard added to every "
+        "participant call so models don't leak chain-of-thought, "
+        "<think> tags, or scratchpad text into the chat.",
+    ),
+    "ORCHESTRATOR_BASE_DIRECTIVE": (
+        ORCHESTRATOR_BASE_DIRECTIVE,
+        "System message for every orchestrator-side LLM call. "
+        "Establishes neutrality and demands strict JSON for the "
+        "structured ones (status checks, alliance detection, etc.).",
+    ),
+
+    # ── Optional pre-chat: Select N Automatically ────────────────
+    "AUTO_SELECT_PARTICIPANTS_PROMPT": (
+        AUTO_SELECT_PARTICIPANTS_PROMPT,
+        "Used when the user enables 'Select N Automatically' in the "
+        "participants dropdown. The orchestrator LLM ranks every "
+        "available candidate persona by relevance to the question and "
+        "returns the top N just before /chat/start.",
+    ),
+
+    # ── Phase 1 ─────────────────────────────────────────────────
+    "INITIAL_OPINION_PROMPT": (
+        INITIAL_OPINION_PROMPT,
+        "Phase 1. Asks each participant for an independent first "
+        "opinion, with no awareness of what anyone else has said. "
+        "This independence is what makes the Credential Summary in "
+        "the next step meaningful.",
+    ),
+
+    # ── Credential Summary (build) ──────────────────────────────
+    "CREDENTIAL_BUILD_PROMPT": (
+        CREDENTIAL_BUILD_PROMPT,
+        "After Phase 1 the orchestrator builds the Credential Summary: "
+        "a neutral assessment of each participant's expertise, "
+        "personality, biases, and a 0-1 credibility score on this "
+        "specific question. Returned as strict JSON.",
+    ),
+
+    # ── Phase 2 ─────────────────────────────────────────────────
+    "CRITIQUE_PROMPT": (
+        CRITIQUE_PROMPT,
+        "Phase 2. Each participant gets one or more critique rounds "
+        "(count is tunable in Settings -> Conversation limits). They "
+        "address any open questions aimed at them first, then offer "
+        "constructive critique of others and may revise their opinion.",
+    ),
+
+    # ── Credential Summary (refresh) ────────────────────────────
+    "CREDENTIAL_REFRESH_PROMPT": (
+        CREDENTIAL_REFRESH_PROMPT,
+        "After the last critique round, the orchestrator refreshes "
+        "the Credential Summary because participants reveal a lot "
+        "more about themselves through critique than through their "
+        "opening pitch.",
+    ),
+
+    # ── Phase 3 ─────────────────────────────────────────────────
+    "STATUS_ASSESSMENT_PROMPT": (
+        STATUS_ASSESSMENT_PROMPT,
+        "Phase 3. The orchestrator decides whether the group needs "
+        "targeted follow-ups before finalization. It prefers to relay "
+        "unanswered participant-to-participant questions verbatim and "
+        "only synthesizes a new one if no real open thread exists.",
+    ),
+    "TARGETED_FOLLOWUP_PROMPT": (
+        TARGETED_FOLLOWUP_PROMPT,
+        "Used inside Phase 3 when the orchestrator is asking a "
+        "follow-up of its own initiative (no real open thread "
+        "existed). The participant sees this as 'The orchestrator "
+        "has a follow-up for you'.",
+    ),
+    "TARGETED_FOLLOWUP_FROM_PARTICIPANT_PROMPT": (
+        TARGETED_FOLLOWUP_FROM_PARTICIPANT_PROMPT,
+        "Used inside Phase 3 when the orchestrator is relaying a "
+        "previously-unanswered question verbatim from another "
+        "participant, attributed to the original asker.",
+    ),
+
+    # ── Phase 4 ─────────────────────────────────────────────────
+    "FINALIZATION_PROMPT": (
+        FINALIZATION_PROMPT,
+        "Phase 4. Each participant states a revised post-discussion "
+        "opinion OR endorses another participant's revised opinion "
+        "(with an optional caveat). Open threads aimed at them are "
+        "answered briefly at the top.",
+    ),
+
+    # ── Phase 5 ─────────────────────────────────────────────────
+    "ALLIANCE_DETECTION_PROMPT": (
+        ALLIANCE_DETECTION_PROMPT,
+        "Start of Phase 5. The orchestrator clusters participants "
+        "into 'alliance groups' based on their revised opinions, so "
+        "consensus prompts can address allies and solo voices "
+        "differently.",
+    ),
+    "ADDRESSED_TO_PROMPT": (
+        ADDRESSED_TO_PROMPT,
+        "Used after each Phase 5 message to classify whether it was "
+        "aimed at one specific other participant (a dyadic exchange) "
+        "or broadcast to the whole group. Drives the back-and-forth "
+        "routing and the 'A -> B' header on each chat bubble.",
+    ),
+    "CONSENSUS_ALLIED_PROMPT": (
+        CONSENSUS_ALLIED_PROMPT,
+        "Phase 5 prompt for participants who are part of an alliance. "
+        "They advocate for the group's shared stance and try to win "
+        "over participants from other groups, addressing ONE "
+        "specific participant when possible.",
+    ),
+    "CONSENSUS_SOLO_PROMPT": (
+        CONSENSUS_SOLO_PROMPT,
+        "Phase 5 prompt for participants who have no allies. They "
+        "pick one of three strategies: persuade the closest group, "
+        "switch sides, or propose a compromise.",
+    ),
+    "CONSENSUS_STATUS_PROMPT": (
+        CONSENSUS_STATUS_PROMPT,
+        "Used periodically during Phase 5. The orchestrator decides "
+        "whether the group has reached majority agreement, is still "
+        "shifting productively, or has stalled and needs intervention.",
+    ),
+
+    # ── Phase 6 (closure) ───────────────────────────────────────
+    "UNADDRESSED_FACTOR_PROMPT": (
+        UNADDRESSED_FACTOR_PROMPT,
+        "If Phase 5 stalls, the orchestrator looks for ONE important "
+        "factor the group hasn't adequately discussed and surfaces it "
+        "as a new consideration before re-running consensus.",
+    ),
+    "MAJORITY_REPORT_PROMPT": (
+        MAJORITY_REPORT_PROMPT,
+        "Final report when the group reaches majority agreement. The "
+        "orchestrator writes a neutral prose summary of the decision, "
+        "the strongest supporting reasons, and high-credibility "
+        "dissenting points.",
+    ),
+    "NO_CONSENSUS_REPORT_PROMPT": (
+        NO_CONSENSUS_REPORT_PROMPT,
+        "Final report when consensus retries are exhausted without "
+        "agreement. The orchestrator lays out the major opinions, "
+        "names supporters, and offers its own neutral recommendation "
+        "with a note that the user should ultimately decide.",
+    ),
+
+    # ── Utility / table view ────────────────────────────────────
+    "CONTRIBUTION_SUMMARY_PROMPT": (
+        CONTRIBUTION_SUMMARY_PROMPT,
+        "Run after the chat ends to populate the per-participant "
+        "summary column in the table view (and CSV export). Asks the "
+        "orchestrator to write a neutral 2-3 sentence recap of each "
+        "participant's overall contribution.",
+    ),
+}
+
+
+# Ordered grouping that mirrors the live phase flow. Names reference
+# `_PROMPTS_BY_NAME` keys; the frontend renders groups in this order.
+_GROUPS: list[tuple[str, list[str]]] = [
+    ("Always-on directives", [
+        "PARTICIPANT_BASE_DIRECTIVE",
+        "NO_REASONING_DIRECTIVE",
+        "ORCHESTRATOR_BASE_DIRECTIVE",
+    ]),
+    ("Optional pre-chat", [
+        "AUTO_SELECT_PARTICIPANTS_PROMPT",
+    ]),
+    ("Phase 1: Initial Opinions", [
+        "INITIAL_OPINION_PROMPT",
+    ]),
+    ("Credential Summary (build)", [
+        "CREDENTIAL_BUILD_PROMPT",
+    ]),
+    ("Phase 2: Critique", [
+        "CRITIQUE_PROMPT",
+    ]),
+    ("Credential Summary (refresh)", [
+        "CREDENTIAL_REFRESH_PROMPT",
+    ]),
+    ("Phase 3: Status assessment & targeted follow-ups", [
+        "STATUS_ASSESSMENT_PROMPT",
+        "TARGETED_FOLLOWUP_PROMPT",
+        "TARGETED_FOLLOWUP_FROM_PARTICIPANT_PROMPT",
+    ]),
+    ("Phase 4: Opinion Finalization", [
+        "FINALIZATION_PROMPT",
+    ]),
+    ("Phase 5: Consensus Gathering", [
+        "ALLIANCE_DETECTION_PROMPT",
+        "ADDRESSED_TO_PROMPT",
+        "CONSENSUS_ALLIED_PROMPT",
+        "CONSENSUS_SOLO_PROMPT",
+        "CONSENSUS_STATUS_PROMPT",
+    ]),
+    ("Phase 6: Closure", [
+        "UNADDRESSED_FACTOR_PROMPT",
+        "MAJORITY_REPORT_PROMPT",
+        "NO_CONSENSUS_REPORT_PROMPT",
+    ]),
+    ("Utility prompts", [
+        "CONTRIBUTION_SUMMARY_PROMPT",
+    ]),
+]
+
+
+_VAR_RE = re.compile(r"\{([a-zA-Z_][a-zA-Z0-9_]*)\}")
+
+
+def _extract_variables(template: str) -> list[str]:
+    """Pull single-brace `{var}` placeholders out of a template,
+    preserving the first-occurrence order. Double-brace literals
+    (`{{` and `}}` from the JSON examples) are correctly ignored
+    because the regex only matches a single brace pair.
+    """
+    seen: set[str] = set()
+    out: list[str] = []
+    for m in _VAR_RE.finditer(template):
+        name = m.group(1)
+        if name in seen:
+            continue
+        seen.add(name)
+        out.append(name)
+    return out
+
+
+def build_prompt_catalog() -> dict[str, Any]:
+    """Return the catalog as a JSON-serializable dict.
+
+    Shape:
+      {
+        "groups": [
+          {"title": "...", "items": [{"name", "purpose", "variables", "template"}, ...]},
+          ...
+        ]
+      }
+    """
+    groups_out: list[dict[str, Any]] = []
+    for group_title, names in _GROUPS:
+        items: list[dict[str, Any]] = []
+        for name in names:
+            if name not in _PROMPTS_BY_NAME:
+                # Defensive: skip a name typo rather than 500.
+                continue
+            template, purpose = _PROMPTS_BY_NAME[name]
+            items.append({
+                "name": name,
+                "purpose": purpose,
+                "variables": _extract_variables(template),
+                "template": template,
+            })
+        groups_out.append({"title": group_title, "items": items})
+    return {"groups": groups_out}

backend/app/services/prompts/critique.py

@@ -1,7 +1,7 @@
 """Phase 2: each participant gets two turns of critique."""
 
 CRITIQUE_PROMPT = (
-    "Phase 2 of the discussion: Critique (round {round_number} of 2).\n\n"
+    "Phase 2 of the discussion: Critique (round {round_number} of {round_total}).\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 "

backend/tests/test_conversation_limits.py

@@ -0,0 +1,141 @@
+"""Tests for the user-tunable repetition / failsafe limits exposed via
+`ConversationLimits` and the `/api/chat/limits/defaults` endpoint.
+
+These guard:
+- defaults match the historical hard-coded values (no behavior change
+  for anyone who doesn't touch the new settings);
+- clamping silently coerces missing / out-of-range / non-int values
+  back to the per-field defaults rather than raising;
+- the defaults endpoint returns parallel `defaults` / `bounds` /
+  `descriptions` maps with the same field names so the frontend can
+  zip them into UI rows.
+"""
+from fastapi.testclient import TestClient
+
+from app.main import app
+from app.services.models import (
+    CONVERSATION_LIMIT_BOUNDS,
+    CONVERSATION_LIMIT_DESCRIPTIONS,
+    ConversationLimits,
+    clamp_conversation_limits,
+)
+
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+
+def test_defaults_match_historical_hardcoded_values():
+    """If anyone changes a default by accident, this test makes them
+    think twice. The values here are the ones the orchestrator used
+    before this knobs-as-settings refactor."""
+    limits = ConversationLimits()
+    assert limits.critique_rounds == 2
+    assert limits.status_assessment_max == 3
+    assert limits.consensus_turns_per_participant == 6
+    assert limits.dyad_cap == 2
+    assert limits.stall_recovery_attempts == 1
+    assert limits.auto_disable_failures == 3
+    assert limits.participant_message_pause_at == 60
+    assert limits.participant_message_pause_inc == 20
+    assert limits.orchestrator_call_pause_at == 100
+    assert limits.orchestrator_call_pause_inc == 50
+
+
+def test_bounds_cover_every_dataclass_field():
+    """Every tunable field needs a (min, max) bound; otherwise the
+    clamp helper would silently leave it unprotected."""
+    field_names = set(ConversationLimits().__dict__.keys())
+    bound_names = set(CONVERSATION_LIMIT_BOUNDS.keys())
+    assert field_names == bound_names
+
+
+def test_descriptions_cover_every_dataclass_field():
+    """The settings UI is server-driven; if a field has no description
+    block, the modal would render an empty row for it."""
+    field_names = set(ConversationLimits().__dict__.keys())
+    described = set(CONVERSATION_LIMIT_DESCRIPTIONS.keys())
+    assert field_names == described
+    for entry in CONVERSATION_LIMIT_DESCRIPTIONS.values():
+        assert "group" in entry
+        assert "label" in entry
+        assert "help" in entry
+
+
+# ---------------------------------------------------------------------------
+# clamp_conversation_limits
+# ---------------------------------------------------------------------------
+
+def test_clamp_returns_defaults_for_none_or_empty():
+    assert clamp_conversation_limits(None) == ConversationLimits()
+    assert clamp_conversation_limits({}) == ConversationLimits()
+
+
+def test_clamp_clamps_too_large_values():
+    """A value above the field's upper bound is coerced to the upper
+    bound, not rejected. This keeps the API permissive."""
+    out = clamp_conversation_limits({"critique_rounds": 99})
+    assert out.critique_rounds == CONVERSATION_LIMIT_BOUNDS["critique_rounds"][1]
+
+
+def test_clamp_clamps_too_small_values():
+    out = clamp_conversation_limits({"critique_rounds": -10})
+    assert out.critique_rounds == CONVERSATION_LIMIT_BOUNDS["critique_rounds"][0]
+
+
+def test_clamp_ignores_unknown_fields():
+    out = clamp_conversation_limits({"there_is_no_such_field": 7})
+    assert out == ConversationLimits()
+
+
+def test_clamp_silently_drops_non_int_values():
+    """Stringy garbage that can't be coerced should fall back to the
+    default for that one field, not raise."""
+    out = clamp_conversation_limits({"critique_rounds": "not-a-number"})
+    assert out.critique_rounds == ConversationLimits().critique_rounds
+
+
+def test_clamp_preserves_partial_overrides():
+    """Only-some-fields-supplied is the common case (UI sends just
+    the overridden ones)."""
+    out = clamp_conversation_limits({"dyad_cap": 4})
+    assert out.dyad_cap == 4
+    # All other fields untouched.
+    base = ConversationLimits()
+    for field_name in CONVERSATION_LIMIT_BOUNDS.keys():
+        if field_name == "dyad_cap":
+            continue
+        assert getattr(out, field_name) == getattr(base, field_name)
+
+
+def test_clamp_accepts_string_ints():
+    """JSON sometimes serializes numbers as strings - we should not
+    refuse a perfectly valid int just because it arrived as '4'."""
+    out = clamp_conversation_limits({"dyad_cap": "4"})
+    assert out.dyad_cap == 4
+
+
+# ---------------------------------------------------------------------------
+# /api/chat/limits/defaults endpoint
+# ---------------------------------------------------------------------------
+
+def test_limits_defaults_endpoint_returns_parallel_maps():
+    client = TestClient(app)
+    resp = client.get("/api/chat/limits/defaults")
+    assert resp.status_code == 200
+    body = resp.json()
+
+    assert set(body.keys()) == {"defaults", "bounds", "descriptions"}
+
+    # All three maps should agree on the same field set so the
+    # frontend can zip them per row.
+    field_names = set(ConversationLimits().__dict__.keys())
+    assert set(body["defaults"].keys()) == field_names
+    assert set(body["bounds"].keys()) == field_names
+    assert set(body["descriptions"].keys()) == field_names
+
+    # Bounds shape sanity-check.
+    for field_name, bound in body["bounds"].items():
+        assert "min" in bound and "max" in bound
+        assert bound["min"] < bound["max"]
+        assert bound["min"] <= body["defaults"][field_name] <= bound["max"]

backend/tests/test_csv_export.py

@@ -1,9 +1,18 @@
-from app.api.chat import _export_csv_table
+from app.api.chat import (
+    _export_csv_table,
+    _export_md,
+    _export_txt,
+)
 from app.services.models import Phase, Session
 from app.services.models import Participant
 
 
-def _mk_session():
+# Number of columns in the CSV table (kept here for tests to assert
+# field-count stability if the schema ever shifts).
+EXPECTED_CSV_COLUMNS = 9
+
+
+def _mk_session(*, with_credentials: bool = False) -> Session:
     s = Session()
     s.question = "Will \"AI\" change, education? Yes, no, maybe.\nNew lines too."
     p1 = Participant(
@@ -48,16 +57,35 @@ def _mk_session():
         },
     ]
     s.final_report = {"kind": "majority", "text": "Group decided X."}
+    if with_credentials:
+        s.credential_summary = [
+            {
+                "participant_id": "extra_a",
+                "name": "Alice",
+                "expertise": "Comparative education researcher.",
+                "personality": "Calm, evidence-driven.",
+                "credibility_for_question": 0.78,
+                "bias_to_watch": "Tends to over-trust meta-analyses.",
+            },
+            {
+                "participant_id": "expert_b",
+                "name": "Bob, Ph.D.",
+                "expertise": "K-12 classroom teacher, 20 years.",
+                "personality": "Combative; debates loudly.",
+                "credibility_for_question": 0.62,
+                "bias_to_watch": "Anchors on personal anecdotes.",
+            },
+        ]
     return s
 
 
 def test_csv_export_roundtrips_through_csv_module():
     """Ensure values containing commas, quotes, and newlines get quoted
-    correctly per RFC 4180."""
+    correctly per RFC 4180, and that credential columns are populated."""
     import csv
     import io
 
-    s = _mk_session()
+    s = _mk_session(with_credentials=True)
     out = _export_csv_table(s)
     assert out["filename"] == "ccai_chat_table.csv"
     parsed = list(csv.reader(io.StringIO(out["content"])))
@@ -71,6 +99,10 @@ def test_csv_export_roundtrips_through_csv_module():
     # column header row
     assert parsed[3] == [
         "Participant",
+        "Expertise (orchestrator's read)",
+        "Style",
+        "Credibility on this question (0-1)",
+        "Bias to watch",
         "First opinion",
         "Conversation contribution",
         "Revised opinion",
@@ -78,21 +110,87 @@ def test_csv_export_roundtrips_through_csv_module():
     ]
     alice_row = parsed[4]
     assert alice_row[0] == "Alice"
-    assert "\"quotes\"" in alice_row[1]  # csv module preserved the quotes
+    # credential columns
+    assert alice_row[1] == "Comparative education researcher."
+    assert alice_row[2] == "Calm, evidence-driven."
+    assert alice_row[3] == "0.78"
+    assert alice_row[4] == "Tends to over-trust meta-analyses."
+    # opinion columns - "First opinion" still preserves quotes/commas/newlines
+    assert "\"quotes\"" in alice_row[5]
     bob_row = parsed[5]
     assert bob_row[0] == "Bob, Ph.D."
-    assert "multi-line" in bob_row[1]
+    assert bob_row[3] == "0.62"
+    assert "multi-line" in bob_row[5]
 
 
 def test_csv_export_no_field_count_drift():
-    """Every row after the header should have exactly 5 columns even when
-    payload contains pathological characters."""
+    """Every data row should have exactly EXPECTED_CSV_COLUMNS columns,
+    matching the header row, even with pathological characters and even
+    when credentials are missing."""
+    import csv
+    import io
+
+    s = _mk_session(with_credentials=False)
+    out = _export_csv_table(s)
+    rows = list(csv.reader(io.StringIO(out["content"])))
+    header = rows[3]
+    assert len(header) == EXPECTED_CSV_COLUMNS
+    for row in rows[4:]:
+        assert len(row) == EXPECTED_CSV_COLUMNS
+
+
+def test_csv_export_blank_credentials_when_summary_missing():
+    """When the orchestrator hasn't built a Credential Summary yet, the
+    credential columns should be present but empty - never crash."""
     import csv
     import io
 
-    s = _mk_session()
+    s = _mk_session(with_credentials=False)
     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
+    alice_row = rows[4]
+    # cols 1..4 are credential columns (Expertise, Style, Credibility, Bias)
+    assert alice_row[1] == ""
+    assert alice_row[2] == ""
+    assert alice_row[3] == ""
+    assert alice_row[4] == ""
+    # but the opinion columns should still be populated
+    assert "Alice" in alice_row[0]
+    assert alice_row[6] == "Stayed firm."  # contribution summary
+
+
+def test_txt_export_includes_credential_block_when_present():
+    s = _mk_session(with_credentials=True)
+    out = _export_txt(s)
+    body = out["content"]
+    assert "Credential Summary" in body
+    assert "Comparative education researcher." in body
+    assert "0.78" in body
+    assert "Tends to over-trust meta-analyses." in body
+    # Block precedes the conversation transcript
+    cred_idx = body.index("Credential Summary")
+    msg_idx = body.index("Final consensus statement A")
+    assert cred_idx < msg_idx
+
+
+def test_txt_export_omits_credential_block_when_empty():
+    s = _mk_session(with_credentials=False)
+    out = _export_txt(s)
+    assert "Credential Summary" not in out["content"]
+
+
+def test_md_export_includes_credential_block_when_present():
+    s = _mk_session(with_credentials=True)
+    out = _export_md(s)
+    body = out["content"]
+    assert "## Credential Summary" in body
+    assert "### Alice" in body
+    assert "### Bob, Ph.D." in body
+    assert "**Credibility on this question:** 0.78" in body
+    assert "**Bias to watch:**" in body
+
+
+def test_md_export_omits_credential_block_when_empty():
+    s = _mk_session(with_credentials=False)
+    out = _export_md(s)
+    assert "## Credential Summary" not in out["content"]

frontend/src/App.js

@@ -5,11 +5,18 @@ import ChatControls from './components/ChatControls';
 import ChatArea from './components/ChatArea';
 import ExpertPersonaModal from './components/ExpertPersonaModal';
 import ChatTableView from './components/ChatTableView';
+import CredentialSummaryModal from './components/CredentialSummaryModal';
+import ConversationLimitsModal from './components/ConversationLimitsModal';
+import PromptCatalogModal from './components/PromptCatalogModal';
 import {
   fetchModels, fetchPersonas, fetchDemoQuestions,
   startChat, continueChat, getOrchestrator, setOrchestrator,
-  getSpeedPriority, setSpeedPriority, getAuthStatus,
-  exportChat, exportApiLog, fetchTableView, getRateLimitStatus,
+  getAuthStatus,
+  exportChat, exportApiLog, fetchTableView,   fetchCredentials,
+  fetchConversationLimitsDefaults,
+  autoSelectParticipants,
+  fetchPromptCatalog,
+  getRateLimitStatus,
 } from './utils/api';
 import * as storage from './utils/storage';
 import './styles/variables.css';
@@ -43,7 +50,6 @@ export default function App() {
   const [demoQuestions, setDemoQuestions] = useState([]);
 
   // Display options
-  const [speedPriority, setSpeedPriorityState] = useState(false);
   const [showResponseTime, setShowResponseTime] = useState(false);
   const [showChatStats, setShowChatStats] = useState(false);
 
@@ -66,6 +72,32 @@ export default function App() {
   const [expertEditing, setExpertEditing] = useState(null);
   const [tableData, setTableData] = useState(null);
   const [tableOpen, setTableOpen] = useState(false);
+  // Credential Summary: cached snapshot fed by SSE `credentials_updated`
+  // events, plus an open/closed flag and a question echo for the modal
+  // header. Reset on each new chat start.
+  const [credentialsData, setCredentialsData] = useState(null);
+  const [credentialsOpen, setCredentialsOpen] = useState(false);
+  // Conversation limits: schema (defaults + bounds + descriptions)
+  // pulled from /api/chat/limits/defaults, plus a sparse map of the
+  // user's overrides persisted to localStorage. Empty map means
+  // "use server defaults". The schema lazy-loads on first open.
+  const [limitsSchema, setLimitsSchema] = useState(null);
+  const [limitsOverrides, setLimitsOverrides] = useState(
+    persisted.conversation_limits || {},
+  );
+  const [limitsOpen, setLimitsOpen] = useState(false);
+  // Auto-select toggle: when on, the participant dropdown defers
+  // selection to the orchestrator LLM at /chat/start time. We also
+  // snapshot the user's manual selection before turning it on so we
+  // can restore it when it's turned back off.
+  const [autoSelectMode, setAutoSelectMode] = useState(
+    !!persisted.auto_select_mode,
+  );
+  const [priorManualSelection, setPriorManualSelection] = useState(null);
+  // Prompt catalog: lazily fetched on first open, then cached for the
+  // rest of the session. The catalog is static per backend deploy.
+  const [promptCatalog, setPromptCatalog] = useState(null);
+  const [promptCatalogOpen, setPromptCatalogOpen] = useState(false);
 
   const abortRef = useRef(null);
 
@@ -90,7 +122,6 @@ export default function App() {
         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);
@@ -158,12 +189,6 @@ export default function App() {
   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); }
-  }, []);
   const handleMaxParticipantsChange = useCallback((n) => {
     const clamped = Math.max(3, Math.min(9, n));
     setMaxParticipants(clamped);
@@ -212,6 +237,21 @@ export default function App() {
     });
   }, []);
 
+  // ─── Auto-select toggle ─────────────────────────────────────────
+  // When turning ON, snapshot the current manual selection so we can
+  // restore it on OFF. The actual LLM ranking happens in handleStart
+  // (so the user's question is available); this just flips the mode.
+  const handleToggleAutoSelectMode = useCallback((on) => {
+    if (on && !autoSelectMode) {
+      setPriorManualSelection([...selectedIds]);
+    } else if (!on && autoSelectMode && priorManualSelection !== null) {
+      setSelectedIds(priorManualSelection);
+      setPriorManualSelection(null);
+    }
+    setAutoSelectMode(!!on);
+    storage.setAutoSelectMode(!!on);
+  }, [autoSelectMode, selectedIds, priorManualSelection]);
+
   // ─── Expert persona ops ─────────────────────────────────────────
   const handleOpenExpertModal = useCallback((personaOrNull) => {
     setExpertEditing(personaOrNull);
@@ -285,12 +325,77 @@ export default function App() {
     } catch (err) { console.error('Table fetch failed:', err); }
   }, [sessionId]);
 
+  // ─── Credential Summary view ────────────────────────────────────
+  // Always re-fetch on open so the modal reflects the very latest
+  // server-side state (the Phase-3 refresh may have run after the SSE
+  // event was missed by a stale tab).
+  const handleShowCredentials = useCallback(async () => {
+    if (!sessionId) return;
+    try {
+      const data = await fetchCredentials(sessionId);
+      setCredentialsData(data);
+      setCredentialsOpen(true);
+    } catch (err) { console.error('Credentials fetch failed:', err); }
+  }, [sessionId]);
+
+  const handleRefreshCredentials = useCallback(async () => {
+    if (!sessionId) return;
+    try {
+      const data = await fetchCredentials(sessionId);
+      setCredentialsData(data);
+    } catch (err) { console.error('Credentials refresh failed:', err); }
+  }, [sessionId]);
+
+  // ─── Conversation limits (settings) ────────────────────────────
+  // Lazy-load the schema on first open, then cache it for the rest
+  // of the session. The user's override map is already in state
+  // and persisted to localStorage; we hand it to the modal as the
+  // initial draft and re-persist on every change.
+  const handleShowConversationLimits = useCallback(async () => {
+    if (!limitsSchema) {
+      try {
+        const data = await fetchConversationLimitsDefaults();
+        setLimitsSchema(data);
+      } catch (err) {
+        console.error('Conversation-limit schema fetch failed:', err);
+        return;
+      }
+    }
+    setLimitsOpen(true);
+  }, [limitsSchema]);
+
+  const handleConversationLimitsChange = useCallback((next) => {
+    setLimitsOverrides(next);
+    storage.setConversationLimits(next);
+  }, []);
+
+  const handleConversationLimitsResetAll = useCallback(() => {
+    setLimitsOverrides({});
+    storage.setConversationLimits({});
+  }, []);
+
+  // ─── Prompt catalog (Transparency) ─────────────────────────────
+  const handleShowPromptCatalog = useCallback(async () => {
+    if (!promptCatalog) {
+      try {
+        const data = await fetchPromptCatalog();
+        setPromptCatalog(data);
+      } catch (err) {
+        console.error('Prompt catalog fetch failed:', err);
+        return;
+      }
+    }
+    setPromptCatalogOpen(true);
+  }, [promptCatalog]);
+
   // ─── Build start payload ────────────────────────────────────────
-  const buildStartPayload = useCallback((theQuestion) => {
-    const enabledParticipants = selectedParticipants.filter(
-      p => enabledMap[p.participant_id] !== false,
-    );
-    const participants = enabledParticipants.map(p => ({
+  // `participantsOverride`, if provided, replaces the
+  // selectedParticipants-derived list (used by the auto-select flow
+  // because the freshly-chosen list isn't in state yet when we need it).
+  const buildStartPayload = useCallback((theQuestion, participantsOverride) => {
+    const baseList = participantsOverride
+      ?? selectedParticipants.filter(p => enabledMap[p.participant_id] !== false);
+    const participants = baseList.map(p => ({
       participant_id: p.participant_id,
       kind: p.kind || (p.participant_id.startsWith('neon:') ? 'neon'
         : (p.participant_id.startsWith('extra_') ? 'extra' : 'expert')),
@@ -298,7 +403,7 @@ export default function App() {
       role_prompt: p.role_prompt || null,
       model_id_override: modelAssignments[p.participant_id] || null,
     }));
-    const expert_payload = enabledParticipants
+    const expert_payload = baseList
       .filter(p => (p.kind || '').startsWith('expert'))
       .map(p => ({
         participant_id: p.participant_id,
@@ -314,8 +419,10 @@ export default function App() {
       orchestrator_model_id: orchestratorModel,
       summarizer_model_id: summarizerModel,
       max_participants: maxParticipants,
+      // Sparse override map; backend clamps and falls back per-field.
+      limits: limitsOverrides,
     };
-  }, [selectedParticipants, enabledMap, modelAssignments, orchestratorModel, summarizerModel, maxParticipants]);
+  }, [selectedParticipants, enabledMap, modelAssignments, orchestratorModel, summarizerModel, maxParticipants, limitsOverrides]);
 
   // ─── Stop / continue ────────────────────────────────────────────
   const handleStop = useCallback(() => {
@@ -336,22 +443,94 @@ export default function App() {
   // ─── Start chat ─────────────────────────────────────────────────
   const handleStart = useCallback(async (theQuestion) => {
     if (!theQuestion || !theQuestion.trim()) return;
-    if (enabledSelectedCount < 2) return;
+    // In auto-select mode the dropdown has no manual picks - skip the
+    // pre-flight count check and validate the chosen pool below instead.
+    if (!autoSelectMode && enabledSelectedCount < 2) return;
 
     const controller = new AbortController();
     abortRef.current = controller;
     setIsRunning(true);
     setMessages([]);
     setSystemMessages([]);
-    setStatusText('Starting conversation...');
+    setStatusText(
+      autoSelectMode ? 'Picking participants...' : 'Starting conversation...',
+    );
     setSessionId(null);
     setSessionParticipants([]);
     setPause(null);
     setActiveQuestion(theQuestion.trim());
+    setCredentialsData(null);
+
+    // Resolve the final participant list. When auto-select is on, ask
+    // the orchestrator to rank every available candidate; otherwise
+    // fall through to the user's manual selection.
+    let resolvedParticipants = null;
+    if (autoSelectMode) {
+      const candidatePool = Object.values(allCatalogParticipants);
+      if (candidatePool.length < 2) {
+        setIsRunning(false);
+        setStatusText('');
+        setSystemMessages(prev => [...prev, {
+          text: 'Auto-select needs at least 2 candidate participants available.',
+        }]);
+        return;
+      }
+      const candidatesPayload = candidatePool.map(p => ({
+        participant_id: p.participant_id,
+        name: p.name,
+        role_prompt: p.role_prompt || '',
+        kind: p.kind || (p.participant_id.startsWith('neon:') ? 'neon'
+          : (p.participant_id.startsWith('extra_') ? 'extra' : 'expert')),
+        model_id: modelAssignments[p.participant_id]
+          || p.model_id || p.default_model_id || '',
+      }));
+      try {
+        const result = await autoSelectParticipants({
+          question: theQuestion.trim(),
+          count: maxParticipants,
+          candidates: candidatesPayload,
+          orchestrator_model_id: orchestratorModel,
+        });
+        const chosenIds = result.selected || [];
+        resolvedParticipants = chosenIds
+          .map(id => allCatalogParticipants[id])
+          .filter(Boolean);
+        if (resolvedParticipants.length < 2) {
+          setIsRunning(false);
+          setStatusText('');
+          setSystemMessages(prev => [...prev, {
+            text: 'Auto-select returned too few participants. '
+              + 'Turn auto-select off and pick manually.',
+          }]);
+          return;
+        }
+        // Reflect the pick in the sidebar.
+        setSelectedIds(chosenIds);
+        setEnabledMap(prev => {
+          const next = { ...prev };
+          for (const id of chosenIds) next[id] = true;
+          return next;
+        });
+        if (result.rationale) {
+          setSystemMessages(prev => [...prev, {
+            text: `Auto-select rationale: ${result.rationale}`,
+          }]);
+        }
+        setStatusText('Starting conversation...');
+      } catch (err) {
+        console.error('Auto-select failed:', err);
+        setIsRunning(false);
+        setStatusText('');
+        setSystemMessages(prev => [...prev, {
+          text: `Auto-select failed: ${err.message}`,
+        }]);
+        return;
+      }
+    }
 
     try {
       await startChat(
-        buildStartPayload(theQuestion),
+        buildStartPayload(theQuestion, resolvedParticipants),
         {
           onSession: (data) => {
             setSessionId(data.session_id);
@@ -393,6 +572,17 @@ export default function App() {
           onOrchestratorCapPause: (data) => {
             setPause({ reason: 'orchestrator', ...data });
           },
+          onCredentialsUpdated: (data) => {
+            // Backend emits this after the Phase-1.5 build and (when
+            // it changes) after the Phase-3 refresh. We cache the
+            // payload so the modal opens instantly without a round trip.
+            setCredentialsData({
+              session_id: data.session_id,
+              question: theQuestion.trim(),
+              credentials: data.credentials || [],
+              stage: data.stage || 'built',
+            });
+          },
           onDone: () => {
             setIsRunning(false);
             setStatusText('');
@@ -414,7 +604,11 @@ export default function App() {
       abortRef.current = null;
       getAuthStatus().then(setAuth).catch(() => {});
     }
-  }, [buildStartPayload, enabledSelectedCount, dailyLimit]);
+  }, [
+    buildStartPayload, enabledSelectedCount, dailyLimit,
+    autoSelectMode, allCatalogParticipants, modelAssignments,
+    maxParticipants, orchestratorModel,
+  ]);
 
   const handleStartRandom = useCallback(() => {
     if (demoQuestions.length === 0) {
@@ -425,8 +619,17 @@ export default function App() {
     handleStart(q.text);
   }, [demoQuestions, handleStart]);
 
-  const startDisabled = isRunning || enabledSelectedCount < 2;
-  const startDisabledReason = enabledSelectedCount < 2
+  // In auto-select mode we don't require manual picks - the orchestrator
+  // will choose them at /chat/start time, so just need 2+ candidates
+  // available in the catalog.
+  const autoSelectReady = autoSelectMode
+    && Object.keys(allCatalogParticipants).length >= 2;
+  const startDisabled = isRunning
+    || (!autoSelectMode && enabledSelectedCount < 2)
+    || (autoSelectMode && !autoSelectReady);
+  const startDisabledReason = autoSelectMode
+    ? (!autoSelectReady ? 'No candidate participants available for auto-select.' : '')
+    : enabledSelectedCount < 2
     ? 'Add at least 2 active participants to start.'
     : '';
 
@@ -443,14 +646,14 @@ export default function App() {
         maxParticipants={maxParticipants}
         onToggleParticipant={handleToggleParticipant}
         onOpenExpertModal={handleOpenExpertModal}
+        autoSelectMode={autoSelectMode}
+        onToggleAutoSelectMode={handleToggleAutoSelectMode}
 
         allModels={allModelsFlat}
         orchestratorModel={orchestratorModel}
         onOrchestratorChange={handleOrchestratorChange}
         summarizerModel={summarizerModel}
         onSummarizerChange={handleSummarizerChange}
-        speedPriority={speedPriority}
-        onSpeedPriorityChange={handleSpeedPriorityChange}
         showResponseTime={showResponseTime}
         onShowResponseTimeChange={setShowResponseTime}
         showChatStats={showChatStats}
@@ -460,6 +663,11 @@ export default function App() {
         modelAssignments={modelAssignments}
         onModelAssignmentChange={handleModelAssignmentChange}
         onShowTableView={handleShowTableView}
+        onShowCredentials={handleShowCredentials}
+        hasCredentials={!!sessionId}
+        onShowPromptCatalog={handleShowPromptCatalog}
+        onShowConversationLimits={handleShowConversationLimits}
+        conversationLimitsOverridden={Object.keys(limitsOverrides).length > 0}
         onDownloadChatTxt={handleDownloadTxt}
         onDownloadChatMd={handleDownloadMd}
         onDownloadCsvTable={handleDownloadCsvTable}
@@ -475,6 +683,8 @@ export default function App() {
           modelAssignments={modelAssignments}
           onToggleEnabled={handleSidebarToggleEnabled}
           onRemove={handleSidebarRemove}
+          autoSelectMode={autoSelectMode}
+          maxParticipants={maxParticipants}
         />
         <div className="content">
           <ChatControls
@@ -520,6 +730,25 @@ export default function App() {
           onExportCsv={handleDownloadCsvTable}
         />
       )}
+      <CredentialSummaryModal
+        isOpen={credentialsOpen}
+        data={credentialsData}
+        onClose={() => setCredentialsOpen(false)}
+        onRefresh={handleRefreshCredentials}
+      />
+      <ConversationLimitsModal
+        isOpen={limitsOpen}
+        schema={limitsSchema}
+        overrides={limitsOverrides}
+        onClose={() => setLimitsOpen(false)}
+        onChange={handleConversationLimitsChange}
+        onResetAll={handleConversationLimitsResetAll}
+      />
+      <PromptCatalogModal
+        isOpen={promptCatalogOpen}
+        catalog={promptCatalog}
+        onClose={() => setPromptCatalogOpen(false)}
+      />
     </div>
   );
 }

frontend/src/components/ConversationLimitsModal.js

@@ -0,0 +1,212 @@
+import React, { useMemo, useState } from 'react';
+import { RotateCcw } from 'lucide-react';
+
+/**
+ * Settings modal for the user-tunable repetition / failsafe limits.
+ *
+ * The schema (defaults, bounds, descriptions, group assignments) is
+ * fetched from GET /api/chat/limits/defaults so the entire UI is
+ * server-driven: adding a knob in `services.models.ConversationLimits`
+ * makes it appear here automatically. The user's overrides are
+ * persisted to localStorage and sent on the next /chat/start, where
+ * the backend re-clamps them to the declared bounds.
+ *
+ * "Effective" values shown to the user are: override (if set) ->
+ * server default. Values are pre-clamped client-side too so the
+ * stepper UI stays in range.
+ */
+export default function ConversationLimitsModal({
+  isOpen,
+  schema,
+  overrides,
+  onClose,
+  onChange,
+  onResetAll,
+}) {
+  const [draft, setDraft] = useState(() => ({ ...(overrides || {}) }));
+
+  // Reset draft whenever the modal is reopened so we don't leak edits
+  // from a previous open.
+  React.useEffect(() => {
+    if (isOpen) setDraft({ ...(overrides || {}) });
+  }, [isOpen, overrides]);
+
+  const grouped = useMemo(() => groupFields(schema), [schema]);
+
+  if (!isOpen) return null;
+
+  if (!schema) {
+    return (
+      <div className="ccai-credentials-overlay">
+        <div className="ccai-credentials-card">
+          <div className="ccai-credentials-header">
+            <div>
+              <h2>Conversation limits</h2>
+            </div>
+            <div className="ccai-tab-spacer" />
+            <button className="modal-close" onClick={onClose}>&times;</button>
+          </div>
+          <div className="ccai-credentials-body">
+            <div className="ccai-credentials-empty">Loading limits...</div>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  const handleChange = (field, value) => {
+    const next = { ...draft, [field]: value };
+    setDraft(next);
+    onChange?.(next);
+  };
+
+  const handleResetField = (field) => {
+    const next = { ...draft };
+    delete next[field];
+    setDraft(next);
+    onChange?.(next);
+  };
+
+  const handleResetAll = () => {
+    setDraft({});
+    onResetAll?.();
+  };
+
+  return (
+    <div className="ccai-credentials-overlay">
+      <div className="ccai-credentials-card">
+        <div className="ccai-credentials-header">
+          <div>
+            <h2>Conversation limits</h2>
+            <div className="ccai-credentials-subtitle">
+              These knobs control how long each phase of the discussion
+              runs and when the conversation pauses for a Continue
+              confirmation. Changes apply to the next chat you start.
+            </div>
+          </div>
+          <div className="ccai-tab-spacer" />
+          <button
+            className="btn-sm btn-outline"
+            onClick={handleResetAll}
+            title="Restore every knob to the server default"
+          >
+            <RotateCcw size={14} style={{ marginRight: 4 }} />
+            Reset all
+          </button>
+          <button className="modal-close" onClick={onClose}>&times;</button>
+        </div>
+
+        <div className="ccai-credentials-body">
+          {grouped.map(({ group, fields }) => (
+            <div key={group} className="ccai-limits-group">
+              <div className="ccai-limits-group-title">{group}</div>
+              {fields.map((f) => (
+                <LimitRow
+                  key={f.field}
+                  field={f.field}
+                  label={f.label}
+                  help={f.help}
+                  defaultValue={f.defaultValue}
+                  min={f.min}
+                  max={f.max}
+                  override={draft[f.field]}
+                  onChange={(v) => handleChange(f.field, v)}
+                  onResetField={() => handleResetField(f.field)}
+                />
+              ))}
+            </div>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function LimitRow({
+  field,
+  label,
+  help,
+  defaultValue,
+  min,
+  max,
+  override,
+  onChange,
+  onResetField,
+}) {
+  const isOverride = override !== undefined && override !== null;
+  const effective = isOverride ? override : defaultValue;
+
+  const setClamped = (raw) => {
+    if (raw === '' || raw === null || raw === undefined) {
+      // Empty input = revert to default for this field.
+      onResetField();
+      return;
+    }
+    let n = parseInt(raw, 10);
+    if (Number.isNaN(n)) return;
+    if (n < min) n = min;
+    if (n > max) n = max;
+    onChange(n);
+  };
+
+  return (
+    <div className="ccai-limit-row">
+      <div className="ccai-limit-row-head">
+        <label className="ccai-limit-label" htmlFor={`limit-${field}`}>
+          {label}
+        </label>
+        <div className="ccai-limit-stepper">
+          <input
+            id={`limit-${field}`}
+            type="number"
+            min={min}
+            max={max}
+            step={1}
+            value={effective}
+            onChange={(e) => setClamped(e.target.value)}
+            className="ccai-limit-input"
+          />
+          <span className="ccai-limit-range">
+            ({min}-{max}, default {defaultValue})
+          </span>
+          {isOverride && (
+            <button
+              className="ccai-limit-reset"
+              onClick={onResetField}
+              title="Reset this field to the default"
+            >
+              reset
+            </button>
+          )}
+        </div>
+      </div>
+      <div className="ccai-limit-help">{help}</div>
+    </div>
+  );
+}
+
+/**
+ * Convert the flat `descriptions` map into [{group, fields[]}] in
+ * the order the groups first appear, then the order each field is
+ * declared in `bounds` (which mirrors the dataclass field order).
+ */
+function groupFields(schema) {
+  if (!schema) return [];
+  const { defaults, bounds, descriptions } = schema;
+  const orderedFields = Object.keys(bounds);
+  const seen = new Map();
+  for (const field of orderedFields) {
+    const desc = descriptions[field] || {};
+    const group = desc.group || 'Other';
+    if (!seen.has(group)) seen.set(group, []);
+    seen.get(group).push({
+      field,
+      label: desc.label || field,
+      help: desc.help || '',
+      defaultValue: defaults[field],
+      min: bounds[field].min,
+      max: bounds[field].max,
+    });
+  }
+  return Array.from(seen.entries()).map(([group, fields]) => ({ group, fields }));
+}

frontend/src/components/CredentialSummaryModal.js

@@ -0,0 +1,198 @@
+import React, { useMemo } from 'react';
+import { Download } from 'lucide-react';
+
+/**
+ * Read-only modal that surfaces the orchestrator-generated Credential
+ * Summary - the per-participant assessment of expertise, debating
+ * style, credibility on this question, and biases to watch.
+ *
+ * Built once after Phase 1 (initial opinions) and refreshed once after
+ * Phase 2 (critique). The modal pulls a fresh snapshot via GET
+ * /api/chat/{id}/credentials each time it's opened, so the user sees
+ * the latest version regardless of when they peek.
+ *
+ * Layout mirrors ChatTableView (overlay + card + close button) for
+ * consistency with the existing transparency surfaces.
+ */
+export default function CredentialSummaryModal({
+  isOpen,
+  data,
+  onClose,
+  onRefresh,
+}) {
+  // Hooks must run on every render, so the filename memo lives ABOVE
+  // the early return. The dependency on `isOpen` regenerates the
+  // timestamp each time the modal opens (matches PromptCatalogModal).
+  const filename = useMemo(() => {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    return (
+      'ccai-credentials-'
+      + `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`
+      + `-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`
+      + '.txt'
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isOpen]);
+
+  if (!isOpen) return null;
+
+  const credentials = (data && data.credentials) || [];
+  const question = data?.question || '';
+
+  const handleDownload = () => {
+    if (!credentials.length) return;
+    const txt = renderCredentialsAsText(question, credentials);
+    const blob = new Blob([txt], { 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);
+  };
+
+  return (
+    <div className="ccai-credentials-overlay">
+      <div className="ccai-credentials-card">
+        <div className="ccai-credentials-header">
+          <div>
+            <h2>Credential Summary</h2>
+            <div className="ccai-credentials-subtitle">
+              The orchestrator's neutral assessment of each participant.
+              Built after Phase 1 and refreshed once after Phase 2 critique.
+            </div>
+          </div>
+          <div className="ccai-tab-spacer" />
+          {onRefresh && (
+            <button
+              className="btn-sm btn-outline"
+              onClick={onRefresh}
+              title="Re-fetch from the server"
+            >
+              Refresh
+            </button>
+          )}
+          <button
+            className="btn-sm btn-outline"
+            onClick={handleDownload}
+            disabled={credentials.length === 0}
+            title="Download the credential summary as a .txt file"
+          >
+            <Download size={14} style={{ marginRight: 4 }} />
+            Download as .txt
+          </button>
+          <button className="modal-close" onClick={onClose}>&times;</button>
+        </div>
+
+        {question && (
+          <div className="ccai-credentials-question">
+            <strong>Question:</strong>
+            <div>{question}</div>
+          </div>
+        )}
+
+        <div className="ccai-credentials-body">
+          {credentials.length === 0 ? (
+            <div className="ccai-credentials-empty">
+              No Credential Summary has been generated yet. The
+              orchestrator builds it after Phase 1 (initial opinions).
+            </div>
+          ) : (
+            credentials.map((c) => (
+              <CredentialCard key={c.participant_id} cred={c} />
+            ))
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function CredentialCard({ cred }) {
+  const score = toScore(cred.credibility_for_question);
+  return (
+    <div className="ccai-credential-card">
+      <div className="ccai-credential-card-head">
+        <div className="ccai-credential-name">
+          {cred.name || cred.participant_id}
+        </div>
+        {score !== null && (
+          <div className="ccai-credibility-wrap" title={`Credibility ${score.toFixed(2)} of 1.0`}>
+            <span className="ccai-credibility-label">Credibility</span>
+            <div className="ccai-credibility-bar">
+              <div
+                className="ccai-credibility-fill"
+                style={{ width: `${Math.round(score * 100)}%` }}
+              />
+            </div>
+            <span className="ccai-credibility-num">{score.toFixed(2)}</span>
+          </div>
+        )}
+      </div>
+      <FieldRow label="Expertise" value={cred.expertise} />
+      <FieldRow label="Style" value={cred.personality} />
+      <FieldRow label="Bias to watch" value={cred.bias_to_watch} />
+    </div>
+  );
+}
+
+function FieldRow({ label, value }) {
+  if (!value) return null;
+  return (
+    <div className="ccai-credential-row">
+      <div className="ccai-credential-row-label">{label}</div>
+      <div className="ccai-credential-row-value">{value}</div>
+    </div>
+  );
+}
+
+function toScore(value) {
+  if (value === null || value === undefined) return null;
+  const n = Number(value);
+  if (Number.isNaN(n)) return null;
+  return Math.max(0, Math.min(1, n));
+}
+
+/**
+ * Flat human-readable .txt dump used by the Download button. Same
+ * banner/separator style as PromptCatalogModal.renderCatalogAsText so
+ * the two transparency exports look like a matched set.
+ */
+function renderCredentialsAsText(question, credentials) {
+  const now = new Date().toISOString();
+  const lines = [];
+  const banner = '═'.repeat(64);
+  lines.push(banner);
+  lines.push('Collaborative Conversational AI (CCAI) Demo — Credential Summary');
+  lines.push(`Generated: ${now}`);
+  lines.push(banner);
+  lines.push('');
+
+  if (question) {
+    lines.push('Question:');
+    for (const ln of String(question).split('\n')) {
+      lines.push('    ' + ln);
+    }
+    lines.push('');
+  }
+
+  const sep = '─'.repeat(12);
+  lines.push(`${sep} Participants ${sep}`);
+  lines.push('');
+
+  for (const cred of credentials) {
+    const score = toScore(cred.credibility_for_question);
+    const name = cred.name || cred.participant_id || '(unknown)';
+    lines.push(`## ${name}`);
+    if (score !== null) {
+      lines.push(`Credibility: ${score.toFixed(2)} of 1.00`);
+    }
+    if (cred.expertise) lines.push(`Expertise: ${cred.expertise}`);
+    if (cred.personality) lines.push(`Style: ${cred.personality}`);
+    if (cred.bias_to_watch) lines.push(`Bias to watch: ${cred.bias_to_watch}`);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}

frontend/src/components/DevMenu.js

@@ -1,7 +1,8 @@
 import React, { useState, useMemo, useRef, useEffect } from 'react';
 import {
   ChevronRight, Download, Settings2, Search,
-  Square, CheckSquare, UserPlus, Table2,
+  Square, CheckSquare, UserPlus, Table2, ScrollText, SlidersHorizontal,
+  BookOpen,
 } from 'lucide-react';
 
 /**
@@ -20,8 +21,6 @@ export default function DevMenu({
   onOrchestratorChange,
   summarizerModel,
   onSummarizerChange,
-  speedPriority,
-  onSpeedPriorityChange,
   showResponseTime,
   onShowResponseTimeChange,
   showChatStats,
@@ -33,6 +32,11 @@ export default function DevMenu({
   onModelAssignmentChange,
   onOpenExpertModal,
   onShowTableView,
+  onShowCredentials,
+  hasCredentials,
+  onShowPromptCatalog,
+  onShowConversationLimits,
+  conversationLimitsOverridden,
   onDownloadChatTxt,
   onDownloadChatMd,
   onDownloadCsvTable,
@@ -174,23 +178,6 @@ export default function DevMenu({
               );
             })}
 
-            <div className="dev-panel-divider" />
-            <div className="dev-panel-label">Response priority</div>
-            <button
-              className={`dev-panel-choice ${!speedPriority ? 'dev-panel-choice-active' : ''}`}
-              onClick={() => onSpeedPriorityChange(false)}
-            >
-              {!speedPriority ? <CheckSquare size={16} className="dev-check-icon" /> : <Square size={16} className="dev-check-icon" />}
-              Prioritize model choice
-            </button>
-            <button
-              className={`dev-panel-choice ${speedPriority ? 'dev-panel-choice-active' : ''}`}
-              onClick={() => onSpeedPriorityChange(true)}
-            >
-              {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">Display options</div>
             <button
@@ -208,6 +195,53 @@ export default function DevMenu({
               Chat stats after end
             </button>
 
+            <div className="dev-panel-divider" />
+            <div className="dev-panel-label">Transparency</div>
+            <button
+              disabled={!hasCredentials}
+              onClick={() => { onShowCredentials?.(); setOpen(false); }}
+              title={
+                hasCredentials
+                  ? "View the orchestrator's per-participant Credential Summary"
+                  : "Credential Summary is built after Phase 1 (initial opinions). Start a chat first."
+              }
+            >
+              <ScrollText size={14} className="dev-check-icon" />
+              View Credential Summary…
+              <ChevronRight size={12} style={{ marginLeft: 'auto', opacity: 0.5 }} />
+            </button>
+            <button
+              onClick={() => { onShowPromptCatalog?.(); setOpen(false); }}
+              title="View every prompt template the orchestrator and participants use, grouped by phase."
+            >
+              <BookOpen size={14} className="dev-check-icon" />
+              View current chat prompts…
+              <ChevronRight size={12} style={{ marginLeft: 'auto', opacity: 0.5 }} />
+            </button>
+
+            <div className="dev-panel-divider" />
+            <div className="dev-panel-label">Advanced</div>
+            <button
+              onClick={() => { onShowConversationLimits?.(); setOpen(false); }}
+              title="View and adjust the per-phase repetition limits and failsafe pause points."
+            >
+              <SlidersHorizontal size={14} className="dev-check-icon" />
+              Conversation limits…
+              {conversationLimitsOverridden && (
+                <span
+                  title="One or more limits are overridden from the defaults"
+                  style={{
+                    marginLeft: 6,
+                    fontSize: 11,
+                    color: 'var(--text-secondary)',
+                  }}
+                >
+                  (custom)
+                </span>
+              )}
+              <ChevronRight size={12} style={{ marginLeft: 'auto', opacity: 0.5 }} />
+            </button>
+
             <div className="dev-panel-divider" />
             <button disabled={!hasChat} className="dev-panel-download-item" onClick={() => { onDownloadChatTxt(); setOpen(false); }}>
               Download chat as .txt

frontend/src/components/Header.js

@@ -21,6 +21,8 @@ export default function Header({
   maxParticipants,
   onToggleParticipant,
   onOpenExpertModal,
+  autoSelectMode,
+  onToggleAutoSelectMode,
 
   // dev menu props passed straight through
   ...devProps
@@ -34,7 +36,7 @@ export default function Header({
         <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
+          </a> - Collaborative Conversational AI (CCAI) Demo
         </h1>
       </div>
       <div className="header-right">
@@ -46,6 +48,8 @@ export default function Header({
           maxParticipants={maxParticipants}
           onToggleParticipant={onToggleParticipant}
           onOpenExpertModal={onOpenExpertModal}
+          autoSelectMode={autoSelectMode}
+          onToggleAutoSelectMode={onToggleAutoSelectMode}
         />
         <button
           className="icon-btn"

frontend/src/components/ParticipantDropdown.js

@@ -1,5 +1,5 @@
 import React, { useState, useRef, useEffect } from 'react';
-import { Users, Plus, ChevronDown } from 'lucide-react';
+import { Users, Plus, ChevronDown, Wand2, Check } from 'lucide-react';
 
 /**
  * Header dropdown that lists every available participant the user can
@@ -8,6 +8,11 @@ import { Users, Plus, ChevronDown } from 'lucide-react';
  *   - Extra (the four bundled non-Neon-LLM personas)
  *   - Expert (user-created, stored in localStorage)
  *
+ * A top-of-list "Select N Automatically" toggle defers the choice to
+ * the orchestrator LLM: when enabled, manual checkboxes are visually
+ * disabled and the actual picks happen at /chat/start time via the
+ * /api/chat/auto-select-participants endpoint.
+ *
  * Selecting a participant adds them to the active conversation list. The
  * "Create Expert Persona..." entry opens the modal.
  */
@@ -18,6 +23,8 @@ export default function ParticipantDropdown({
   maxParticipants,
   onToggleParticipant,
   onOpenExpertModal,
+  autoSelectMode,
+  onToggleAutoSelectMode,
 }) {
   const [open, setOpen] = useState(false);
   const ref = useRef(null);
@@ -34,21 +41,61 @@ export default function ParticipantDropdown({
 
   const isSelected = (id) => selectedIds.includes(id);
   const atCap = selectedIds.length >= maxParticipants;
+  // When auto-select is on, checkboxes are deferred entirely - the
+  // orchestrator picks at start time, so user picks are ignored.
+  const checkboxDisabledForAuto = !!autoSelectMode;
 
   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"
+        title={
+          autoSelectMode
+            ? 'Auto-select mode: participants picked at chat start by the orchestrator'
+            : 'Add or remove participants'
+        }
       >
         <Users size={14} />
-        <span>Participants ({selectedIds.length}/{maxParticipants})</span>
+        <span>
+          {autoSelectMode
+            ? 'Participants Auto Selected'
+            : `Participants (${selectedIds.length}/${maxParticipants})`}
+        </span>
         <ChevronDown size={12} />
       </button>
       {open && (
         <div className="ccai-dropdown-panel">
           <div className="ccai-dropdown-section">
+            <button
+              type="button"
+              className={
+                'ccai-dropdown-autoselect' +
+                (autoSelectMode ? ' ccai-dropdown-autoselect-on' : '')
+              }
+              onClick={() => onToggleAutoSelectMode?.(!autoSelectMode)}
+              title={
+                autoSelectMode
+                  ? 'Turn off auto-select and resume manual picking'
+                  : 'Defer participant selection until chat start; the orchestrator will pick the most relevant.'
+              }
+            >
+              {autoSelectMode ? <Check size={14} /> : <Wand2 size={14} />}
+              <span>Select {maxParticipants} Automatically</span>
+            </button>
+            <div className="ccai-dropdown-autoselect-help">
+              {autoSelectMode
+                ? 'The orchestrator will pick the most relevant participants for your question when you start the chat.'
+                : 'Or pick manually from the lists below.'}
+            </div>
+          </div>
+          <div className="ccai-dropdown-divider" />
+          <div
+            className={
+              'ccai-dropdown-section' +
+              (checkboxDisabledForAuto ? ' ccai-dropdown-section-muted' : '')
+            }
+          >
             <div className="ccai-dropdown-section-title">Neon.ai Personas</div>
             {(catalog?.neon || []).length === 0 && (
               <div className="ccai-dropdown-empty">
@@ -60,26 +107,44 @@ export default function ParticipantDropdown({
                 key={p.participant_id}
                 participant={p}
                 checked={isSelected(p.participant_id)}
-                disabledForAdd={atCap && !isSelected(p.participant_id)}
+                disabledForAdd={
+                  checkboxDisabledForAuto
+                  || (atCap && !isSelected(p.participant_id))
+                }
+                autoSelectActive={checkboxDisabledForAuto}
                 onToggle={() => onToggleParticipant(p, 'neon')}
               />
             ))}
           </div>
           <div className="ccai-dropdown-divider" />
-          <div className="ccai-dropdown-section">
+          <div
+            className={
+              'ccai-dropdown-section' +
+              (checkboxDisabledForAuto ? ' ccai-dropdown-section-muted' : '')
+            }
+          >
             <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)}
+                disabledForAdd={
+                  checkboxDisabledForAuto
+                  || (atCap && !isSelected(p.participant_id))
+                }
+                autoSelectActive={checkboxDisabledForAuto}
                 onToggle={() => onToggleParticipant(p, 'extra')}
               />
             ))}
           </div>
           <div className="ccai-dropdown-divider" />
-          <div className="ccai-dropdown-section">
+          <div
+            className={
+              'ccai-dropdown-section' +
+              (checkboxDisabledForAuto ? ' ccai-dropdown-section-muted' : '')
+            }
+          >
             <div className="ccai-dropdown-section-title">Expert Personas</div>
             {(expertPersonas || []).length === 0 && (
               <div className="ccai-dropdown-empty">
@@ -91,7 +156,11 @@ export default function ParticipantDropdown({
                 key={p.participant_id}
                 participant={p}
                 checked={isSelected(p.participant_id)}
-                disabledForAdd={atCap && !isSelected(p.participant_id)}
+                disabledForAdd={
+                  checkboxDisabledForAuto
+                  || (atCap && !isSelected(p.participant_id))
+                }
+                autoSelectActive={checkboxDisabledForAuto}
                 onToggle={() => onToggleParticipant(p, 'expert')}
               />
             ))}
@@ -109,7 +178,7 @@ export default function ParticipantDropdown({
   );
 }
 
-function DropdownItem({ participant, checked, disabledForAdd, onToggle }) {
+function DropdownItem({ participant, checked, disabledForAdd, autoSelectActive, onToggle }) {
   return (
     <label
       className={
@@ -117,7 +186,11 @@ function DropdownItem({ participant, checked, disabledForAdd, onToggle }) {
         (checked ? ' ccai-dropdown-item-checked' : '') +
         (disabledForAdd ? ' ccai-dropdown-item-disabled' : '')
       }
-      title={disabledForAdd ? 'Participant cap reached' : ''}
+      title={
+        autoSelectActive
+          ? 'Disabled while auto-select is on'
+          : (disabledForAdd ? 'Participant cap reached' : '')
+      }
     >
       <input
         type="checkbox"

frontend/src/components/ParticipantSidebar.js

@@ -14,19 +14,39 @@ export default function ParticipantSidebar({
   modelAssignments,
   onToggleEnabled,
   onRemove,
+  autoSelectMode,
+  maxParticipants,
 }) {
+  // In auto-select mode with no chat in progress, the sidebar shows a
+  // placeholder explaining the deferred selection. Once the chat
+  // starts, App.js populates `participants` with the LLM-chosen set
+  // and the regular cards render normally.
+  const showAutoPlaceholder = autoSelectMode && participants.length === 0;
+
   return (
     <aside className="sidebar ccai-sidebar">
       <div className="ccai-sidebar-header">
         <h2 className="sidebar-title">Participants</h2>
         <div className="ccai-sidebar-help">
-          {participants.length === 0 ? (
+          {showAutoPlaceholder ? (
+            <em>Auto-select is on.</em>
+          ) : participants.length === 0 ? (
             <em>Use the Participants dropdown in the header to add some.</em>
           ) : (
             <em>Drag to reorder is not supported yet — order is by selection.</em>
           )}
         </div>
       </div>
+      {showAutoPlaceholder && (
+        <div className="ccai-sidebar-autoselect-empty">
+          <strong>Auto-select: {maxParticipants} participants</strong>
+          <div style={{ marginTop: 4 }}>
+            When you start the chat, the orchestrator will pick the
+            {' '}<strong>{maxParticipants}</strong> participants whose
+            expertise best fits your question.
+          </div>
+        </div>
+      )}
       {participants.map((p) => {
         const enabled = enabledMap[p.participant_id] !== false;
         const modelOverride = modelAssignments[p.participant_id];

frontend/src/components/PromptCatalogModal.js

@@ -0,0 +1,189 @@
+import React, { useMemo, useState } from 'react';
+import { Copy, Check, Download } from 'lucide-react';
+
+/**
+ * Transparency modal that surfaces every prompt template the
+ * orchestrator and participants use during a chat, grouped by phase.
+ * Each item shows a humanized title, a 1-2 sentence purpose, the
+ * runtime template variables the backend interpolates, and the full
+ * template in a copy-able <pre> block. A "Download as .txt" button
+ * in the header dumps the whole catalog in a flat human-readable form.
+ *
+ * Same shell pattern as ConversationLimitsModal / CredentialSummaryModal.
+ */
+export default function PromptCatalogModal({
+  isOpen,
+  catalog,
+  onClose,
+}) {
+  // Note: hooks must run on every render, so this filename memo lives
+  // ABOVE the `if (!isOpen) return null` early return. The dependency
+  // on `isOpen` makes the filename timestamp regenerate each time the
+  // modal opens (i.e. each download gets a fresh stamp).
+  const filename = useMemo(() => {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    return (
+      'ccai-prompts-'
+      + `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`
+      + `-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`
+      + '.txt'
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [isOpen]);
+
+  if (!isOpen) return null;
+
+  const handleDownload = () => {
+    if (!catalog) return;
+    const txt = renderCatalogAsText(catalog);
+    const blob = new Blob([txt], { 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);
+  };
+
+  return (
+    <div className="ccai-credentials-overlay">
+      <div className="ccai-credentials-card">
+        <div className="ccai-credentials-header">
+          <div>
+            <h2>Current chat prompts</h2>
+            <div className="ccai-credentials-subtitle">
+              Every prompt template the orchestrator and participants
+              use during a chat, in conversation order. Variables in
+              {' '}<code>{'{braces}'}</code> are filled in at runtime.
+            </div>
+          </div>
+          <div className="ccai-tab-spacer" />
+          <button
+            className="btn-sm btn-outline"
+            onClick={handleDownload}
+            disabled={!catalog}
+            title="Download the full catalog as a .txt file"
+          >
+            <Download size={14} style={{ marginRight: 4 }} />
+            Download as .txt
+          </button>
+          <button className="modal-close" onClick={onClose}>&times;</button>
+        </div>
+
+        <div className="ccai-credentials-body">
+          {!catalog && (
+            <div className="ccai-credentials-empty">Loading prompts...</div>
+          )}
+          {catalog && (catalog.groups || []).map((g) => (
+            <div key={g.title} className="ccai-prompt-group">
+              <div className="ccai-prompt-group-title">{g.title}</div>
+              {(g.items || []).map((item) => (
+                <PromptItem key={item.name} item={item} />
+              ))}
+            </div>
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function PromptItem({ item }) {
+  const [copied, setCopied] = useState(false);
+  const displayName = humanizeName(item.name);
+
+  const handleCopy = async () => {
+    try {
+      await navigator.clipboard.writeText(item.template || '');
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1500);
+    } catch (err) {
+      console.warn('Clipboard copy failed:', err);
+    }
+  };
+
+  return (
+    <div className="ccai-prompt-item">
+      <div className="ccai-prompt-item-head">
+        <div className="ccai-prompt-item-title">{displayName}</div>
+        <button
+          className="ccai-prompt-copy-btn"
+          onClick={handleCopy}
+          title="Copy template to clipboard"
+        >
+          {copied ? <Check size={12} /> : <Copy size={12} />}
+          {copied ? 'Copied' : 'Copy'}
+        </button>
+      </div>
+      <div className="ccai-prompt-purpose">{item.purpose}</div>
+      {item.variables && item.variables.length > 0 && (
+        <div className="ccai-prompt-vars">
+          <strong>Variables:</strong>{' '}
+          {item.variables.map((v, i) => (
+            <span key={v}>
+              <code>{`{${v}}`}</code>
+              {i < item.variables.length - 1 ? ', ' : ''}
+            </span>
+          ))}
+        </div>
+      )}
+      <pre className="ccai-prompt-template">{item.template}</pre>
+    </div>
+  );
+}
+
+/**
+ * "INITIAL_OPINION_PROMPT" -> "Initial Opinion Prompt".
+ * Splits on underscores, lowercases everything, capitalizes each word.
+ * Drops nothing (e.g. "Prompt" suffix stays) so the displayed name
+ * still matches the constant a developer might grep for.
+ */
+function humanizeName(name) {
+  if (!name) return '';
+  return name
+    .split('_')
+    .map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join(' ');
+}
+
+/**
+ * Flat human-readable .txt dump used by the Download button. Matches
+ * the spec format: title banner, per-group separator, per-item header
+ * with purpose + variables, then the indented template body.
+ */
+function renderCatalogAsText(catalog) {
+  const now = new Date().toISOString();
+  const lines = [];
+  const banner = '═'.repeat(64);
+  lines.push(banner);
+  lines.push('Collaborative Conversational AI (CCAI) Demo — Current chat prompts');
+  lines.push(`Generated: ${now}`);
+  lines.push(banner);
+  lines.push('');
+
+  for (const group of catalog.groups || []) {
+    const sep = '─'.repeat(12);
+    lines.push(`${sep} ${group.title} ${sep}`);
+    lines.push('');
+    for (const item of (group.items || [])) {
+      lines.push(`## ${humanizeName(item.name)}`);
+      lines.push(`Purpose: ${item.purpose}`);
+      if (item.variables && item.variables.length > 0) {
+        lines.push(
+          'Variables: '
+          + item.variables.map(v => `{${v}}`).join(', '),
+        );
+      }
+      lines.push('');
+      // Indent each template line by 4 spaces so the body is
+      // visually distinct from the metadata in a plain-text viewer.
+      for (const ln of (item.template || '').split('\n')) {
+        lines.push('    ' + ln);
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}

frontend/src/styles/ccai.css

@@ -1,5 +1,6 @@
 /* ════════════════════════════════════════════════════════════════
-   CCAI Vibe Demo - additive styles on top of LLMChats3 baseline.
+   Collaborative Conversational AI (CCAI) Demo - additive styles on
+   top of LLMChats3 baseline.
    Anything new (multi-participant sidebar, dropdown, expert modal,
    table view, orchestrator banners, failsafe banner) lives here.
    ════════════════════════════════════════════════════════════════ */
@@ -566,6 +567,191 @@
 }
 
 
+/* ── Credential Summary modal ──────────────────────────────────────
+   Surfaces the orchestrator's per-participant assessment built after
+   Phase 1 and refreshed after Phase 2 critique. Reuses the table
+   modal's overlay/card chrome for visual consistency.
+   ──────────────────────────────────────────────────────────────── */
+
+.ccai-credentials-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+}
+
+.ccai-credentials-card {
+  background: var(--bg-primary);
+  border: 1px solid var(--border-primary);
+  border-radius: 12px;
+  width: min(880px, 95vw);
+  max-height: 90vh;
+  display: flex;
+  flex-direction: column;
+  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+}
+
+.ccai-credentials-header {
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+  padding: 16px 20px;
+  border-bottom: 1px solid var(--border-primary);
+}
+
+.ccai-credentials-header h2 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.ccai-credentials-subtitle {
+  margin-top: 4px;
+  font-size: 12px;
+  color: var(--text-tertiary);
+  line-height: 1.4;
+  max-width: 560px;
+}
+
+.ccai-credentials-question {
+  margin: 0 20px;
+  padding: 10px 12px;
+  background: var(--bg-secondary);
+  border-radius: 8px;
+  font-size: 13px;
+  color: var(--text-secondary);
+}
+
+.ccai-credentials-question strong {
+  display: block;
+  font-size: 11px;
+  text-transform: uppercase;
+  color: var(--text-tertiary);
+  letter-spacing: 0.04em;
+  margin-bottom: 4px;
+}
+
+.ccai-credentials-body {
+  padding: 16px 20px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  overflow-y: auto;
+}
+
+.ccai-credentials-empty {
+  padding: 24px;
+  text-align: center;
+  font-size: 13px;
+  color: var(--text-tertiary);
+  border: 1px dashed var(--border-primary);
+  border-radius: 8px;
+}
+
+.ccai-credential-card {
+  padding: 12px 14px;
+  border: 1px solid var(--border-primary);
+  border-radius: 10px;
+  background: var(--bg-secondary);
+}
+
+.ccai-credential-card-head {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 8px;
+  flex-wrap: wrap;
+}
+
+.ccai-credential-name {
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.ccai-credibility-wrap {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  margin-left: auto;
+}
+
+.ccai-credibility-label {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-tertiary);
+}
+
+.ccai-credibility-bar {
+  width: 120px;
+  height: 6px;
+  background: var(--border-primary);
+  border-radius: 3px;
+  overflow: hidden;
+}
+
+.ccai-credibility-fill {
+  height: 100%;
+  background: linear-gradient(
+    90deg,
+    var(--accent-primary, #6366F1),
+    var(--accent-primary, #6366F1)
+  );
+  transition: width 0.3s ease;
+}
+
+.ccai-credibility-num {
+  font-size: 12px;
+  font-weight: 600;
+  font-variant-numeric: tabular-nums;
+  color: var(--text-secondary);
+  min-width: 32px;
+  text-align: right;
+}
+
+.ccai-credential-row {
+  display: grid;
+  grid-template-columns: 110px 1fr;
+  gap: 8px;
+  padding: 4px 0;
+  font-size: 13px;
+  line-height: 1.45;
+}
+
+.ccai-credential-row-label {
+  font-size: 10px;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: var(--text-tertiary);
+  font-weight: 600;
+  padding-top: 2px;
+}
+
+.ccai-credential-row-value {
+  color: var(--text-primary);
+}
+
+@media (max-width: 600px) {
+  .ccai-credentials-card {
+    max-height: 100vh;
+    border-radius: 0;
+    width: 100vw;
+  }
+  .ccai-credential-row {
+    grid-template-columns: 1fr;
+    gap: 2px;
+  }
+  .ccai-credibility-bar {
+    width: 80px;
+  }
+}
+
+
 /* ── Orchestrator messages ─────────────────────────────────────── */
 
 .ccai-orchestrator-msg {
@@ -833,3 +1019,269 @@
     width: 100vw;
   }
 }
+
+
+/* ── Conversation limits modal ─────────────────────────────���──────
+   Re-uses .ccai-credentials-overlay/.ccai-credentials-card/.ccai-
+   credentials-header/.ccai-credentials-body for the shell so the
+   look matches the credential summary modal. The classes below
+   style the per-section list and per-field stepper row. */
+
+.ccai-limits-group {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 12px 14px;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-primary);
+  border-radius: 10px;
+}
+
+.ccai-limits-group + .ccai-limits-group {
+  margin-top: 4px;
+}
+
+.ccai-limits-group-title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-primary);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  border-bottom: 1px solid var(--border-primary);
+  padding-bottom: 6px;
+  margin-bottom: 2px;
+}
+
+.ccai-limit-row {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 6px 0;
+}
+
+.ccai-limit-row + .ccai-limit-row {
+  border-top: 1px dashed var(--border-primary);
+  padding-top: 10px;
+}
+
+.ccai-limit-row-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  flex-wrap: wrap;
+}
+
+.ccai-limit-label {
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.ccai-limit-stepper {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.ccai-limit-input {
+  width: 64px;
+  padding: 4px 6px;
+  background: var(--bg-primary);
+  border: 1px solid var(--border-primary);
+  border-radius: 6px;
+  color: var(--text-primary);
+  font-size: 14px;
+  text-align: right;
+}
+
+.ccai-limit-range {
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+.ccai-limit-reset {
+  font-size: 12px;
+  background: transparent;
+  border: 1px solid var(--border-primary);
+  color: var(--text-secondary);
+  padding: 2px 8px;
+  border-radius: 6px;
+  cursor: pointer;
+}
+
+.ccai-limit-reset:hover {
+  background: var(--card-bg);
+  color: var(--text-primary);
+}
+
+.ccai-limit-help {
+  font-size: 12.5px;
+  color: var(--text-secondary);
+  line-height: 1.45;
+}
+
+
+/* ── Auto-select participants (dropdown + sidebar placeholder) ──── */
+
+.ccai-dropdown-autoselect {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  width: 100%;
+  padding: 8px 10px;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-primary);
+  border-radius: 8px;
+  color: var(--text-primary);
+  font-size: 13px;
+  font-weight: 600;
+  cursor: pointer;
+  text-align: left;
+}
+
+.ccai-dropdown-autoselect:hover {
+  border-color: var(--accent-primary, var(--text-primary));
+}
+
+.ccai-dropdown-autoselect-on {
+  background: var(--accent-primary, var(--bg-primary));
+  color: var(--bg-primary, var(--text-primary));
+  border-color: transparent;
+}
+
+.ccai-dropdown-autoselect-help {
+  font-size: 11.5px;
+  color: var(--text-secondary);
+  padding: 6px 4px 0;
+  line-height: 1.4;
+}
+
+.ccai-dropdown-section-muted {
+  opacity: 0.55;
+  pointer-events: none;
+}
+
+.ccai-sidebar-autoselect-empty {
+  margin: 12px;
+  padding: 12px;
+  border: 1px dashed var(--border-primary);
+  border-radius: 8px;
+  color: var(--text-secondary);
+  font-size: 12.5px;
+  line-height: 1.45;
+}
+
+.ccai-sidebar-autoselect-empty strong {
+  color: var(--text-primary);
+  font-size: 13px;
+}
+
+
+/* ── Prompt catalog modal ─────────────────────────────────────────
+   Re-uses .ccai-credentials-overlay/.ccai-credentials-card shell.
+   The classes below style the per-group sections and per-item
+   purpose / variables / template blocks. */
+
+.ccai-prompt-group {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 12px 14px;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-primary);
+  border-radius: 10px;
+}
+
+.ccai-prompt-group + .ccai-prompt-group {
+  margin-top: 4px;
+}
+
+.ccai-prompt-group-title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-primary);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  border-bottom: 1px solid var(--border-primary);
+  padding-bottom: 6px;
+}
+
+.ccai-prompt-item {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 8px 0;
+}
+
+.ccai-prompt-item + .ccai-prompt-item {
+  border-top: 1px dashed var(--border-primary);
+  padding-top: 12px;
+}
+
+.ccai-prompt-item-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.ccai-prompt-item-title {
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.ccai-prompt-copy-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  font-size: 12px;
+  padding: 3px 8px;
+  background: transparent;
+  border: 1px solid var(--border-primary);
+  color: var(--text-secondary);
+  border-radius: 6px;
+  cursor: pointer;
+}
+
+.ccai-prompt-copy-btn:hover {
+  background: var(--card-bg);
+  color: var(--text-primary);
+}
+
+.ccai-prompt-purpose {
+  font-size: 12.5px;
+  color: var(--text-secondary);
+  line-height: 1.45;
+}
+
+.ccai-prompt-vars {
+  font-size: 12px;
+  color: var(--text-secondary);
+}
+
+.ccai-prompt-vars code {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  background: var(--bg-primary);
+  border: 1px solid var(--border-primary);
+  border-radius: 4px;
+  padding: 1px 4px;
+  font-size: 11.5px;
+}
+
+.ccai-prompt-template {
+  background: var(--bg-primary);
+  border: 1px solid var(--border-primary);
+  border-radius: 6px;
+  padding: 10px 12px;
+  margin: 0;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 12px;
+  line-height: 1.45;
+  color: var(--text-primary);
+  white-space: pre-wrap;
+  overflow-x: auto;
+  max-height: 280px;
+  overflow-y: auto;
+}

frontend/src/styles/components.css

@@ -747,6 +747,13 @@
   top: 100%;
   margin-top: 4px;
   min-width: 220px;
+  /* Cap the panel at a bit less than the viewport so it never extends
+     past the bottom of the window; long content scrolls within. The
+     16px subtraction leaves a comfortable gap for shadow + breathing
+     room beneath the header. */
+  max-height: calc(100vh - 80px);
+  overflow-y: auto;
+  overscroll-behavior: contain;
   background: var(--card-bg);
   border: 1px solid var(--border-primary);
   border-radius: 10px;

frontend/src/utils/api.js

@@ -1,6 +1,16 @@
+// Default to '' (relative URLs) so any production-style build - whether
+// done inside Docker (Dockerfile sets REACT_APP_API_URL=) or on the host
+// without that env var - hits the same origin that served the page. This
+// avoids the cross-origin trap where a `npm run build` on the host
+// without REACT_APP_API_URL would silently bake `http://localhost:8000`
+// into the bundle and break every API call from a Docker deployment.
+//
+// If you want the CRA dev server (`npm start` on :3000) to talk to a
+// FastAPI backend on :8000, set REACT_APP_API_URL=http://localhost:8000
+// in `frontend/.env.development` or your shell.
 const API_BASE = process.env.REACT_APP_API_URL !== undefined
   ? process.env.REACT_APP_API_URL
-  : 'http://localhost:8000';
+  : '';
 
 export async function fetchModels() {
   const resp = await fetch(`${API_BASE}/api/models`, { cache: 'no-store' });
@@ -115,6 +125,7 @@ function eventHandlerKey(eventType) {
     case 'failsafe_pause': return 'onFailsafePause';
     case 'orchestrator_cap_pause': return 'onOrchestratorCapPause';
     case 'participant_error': return 'onParticipantError';
+    case 'credentials_updated': return 'onCredentialsUpdated';
     default: return null;
   }
 }
@@ -178,6 +189,61 @@ export async function fetchTableView(sessionId) {
   return resp.json();
 }
 
+/**
+ * Fetch the catalog of every prompt template the orchestrator and
+ * participants use, grouped by phase and annotated with purpose and
+ * runtime variables. Backs the "View current chat prompts" modal.
+ */
+export async function fetchPromptCatalog() {
+  const resp = await fetch(`${API_BASE}/api/chat/prompts/catalog`, { cache: 'no-store' });
+  if (!resp.ok) throw new Error('Failed to fetch prompt catalog');
+  return resp.json();
+}
+
+/**
+ * Ask the backend to pick the top `count` participants from the
+ * candidate pool by relevance to the question. Used by the
+ * "Select N Automatically" toggle in the participants dropdown.
+ *
+ * Returns: { selected: [participant_id, ...], rationale: "..." }
+ */
+export async function autoSelectParticipants({ question, count, candidates, orchestrator_model_id }) {
+  const resp = await fetch(`${API_BASE}/api/chat/auto-select-participants`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ question, count, candidates, orchestrator_model_id }),
+  });
+  if (!resp.ok) {
+    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+    throw new Error(err.detail || 'Auto-select failed');
+  }
+  return resp.json();
+}
+
+/**
+ * Fetch the user-tunable conversation-limit defaults, bounds, and
+ * descriptions. The frontend uses this to render the "Conversation
+ * limits" settings modal entirely from the server schema, so adding
+ * a new knob in the backend doesn't require a frontend change.
+ *
+ * Shape: { defaults: {field: int}, bounds: {field: {min, max}},
+ *          descriptions: {field: {group, label, help}} }
+ */
+export async function fetchConversationLimitsDefaults() {
+  const resp = await fetch(`${API_BASE}/api/chat/limits/defaults`, { cache: 'no-store' });
+  if (!resp.ok) throw new Error('Failed to fetch conversation-limit defaults');
+  return resp.json();
+}
+
+export async function fetchCredentials(sessionId) {
+  const resp = await fetch(
+    `${API_BASE}/api/chat/${sessionId}/credentials`,
+    { cache: 'no-store' },
+  );
+  if (!resp.ok) throw new Error('Credentials fetch failed');
+  return resp.json();
+}
+
 export async function getAuthStatus() {
   const resp = await fetch(`${API_BASE}/api/auth/status`, { credentials: 'include' });
   if (!resp.ok) return { logged_in: false, remaining_conversations: -1 };

frontend/src/utils/storage.js

@@ -19,6 +19,15 @@ const DEFAULTS = {
   summarizer_model_id: null,
   max_participants: 5,
   theme: null,
+  // Sparse map of user overrides to ConversationLimits fields. Empty
+  // map = "use server defaults". The server clamps anything we send,
+  // so storing whatever the user typed (including stale values from
+  // an earlier session) is safe.
+  conversation_limits: {},
+  // When true, the participants dropdown shows "Select N Automatically"
+  // as the active mode and the per-persona checkboxes are hidden.
+  // The auto-select happens just before /chat/start.
+  auto_select_mode: false,
 };
 
 function readAll() {
@@ -87,3 +96,11 @@ export function setMaxParticipants(n) {
 export function setTheme(theme) {
   return patchState({ theme });
 }
+
+export function setConversationLimits(limitsMap) {
+  return patchState({ conversation_limits: limitsMap || {} });
+}
+
+export function setAutoSelectMode(on) {
+  return patchState({ auto_select_mode: !!on });
+}