Build credentials during Phase 1 and streamline human participant setup.

Generate per-participant credentials concurrently with initial opinions, rebuild only on model changes, and let humans join from profile text with background credential generation—no question required upfront. Also refresh chat-start controls, rate-limit notices, and header layout.

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

backend/app/api/chat.py

@@ -23,7 +23,10 @@ from typing import Any
 
 from app.clients.hana_client import hana_client
 from app.services import human_io
-from app.services.credential import normalize_one_credential
+from app.services.credential import (
+    build_human_credential_from_profile,
+    normalize_one_credential,
+)
 from app.services.extra_personas import EXTRA_PERSONAS, get_extra_persona
 from app.services.json_calls import orchestrator_call
 from app.services.resilience import build_substitution_chain
@@ -132,8 +135,9 @@ class AutoSelectRequest(BaseModel):
 
 
 class HumanCredentialPayload(BaseModel):
-    """User-authored credential summary for the in-the-loop human.
+    """Structured credential summary for the in-the-loop human.
 
+    Generated from the user's profile text via /credentials/from-profile.
     The orchestrator prepends this entry to the LLM-built credential
     summary so the human always appears first in the modal / exports.
     """
@@ -770,6 +774,40 @@ async def api_edit_human_credential(
     return {"ok": True, "credential": updated}
 
 
+class HumanCredentialFromProfileRequest(BaseModel):
+    """Body for POST /api/chat/credentials/from-profile."""
+
+    name: str
+    question: str = ""
+    profile_text: str
+    participant_id: str = ""
+    orchestrator_model_id: str | None = None
+
+
+@router.post("/chat/credentials/from-profile")
+async def api_human_credential_from_profile(req: HumanCredentialFromProfileRequest):
+    """Generate a structured credential summary from a human's profile text.
+
+    The orchestrator assesses the self-description the same way it would
+    a participant role prompt when building the Phase-1 Credential
+    Summary (expertise, style, credibility on this question, biases).
+    """
+    if not req.name.strip():
+        raise HTTPException(400, "name is required")
+    if not req.profile_text.strip():
+        raise HTTPException(400, "profile_text is required")
+
+    orchestrator_id = req.orchestrator_model_id or settings.orchestrator_model
+    credential = await build_human_credential_from_profile(
+        orchestrator_model_id=orchestrator_id,
+        question=(req.question or "").strip(),
+        name=req.name.strip(),
+        profile_text=req.profile_text.strip(),
+        participant_id=req.participant_id.strip(),
+    )
+    return {"credential": credential}
+
+
 # Module-level registry of in-flight credential drafts. Each draft is a
 # tiny piece of state: the question being discussed, the human's name,
 # the question/answer history, and the configured cap. Drafts are

backend/app/data/demo_questions.json

@@ -1,6 +1,12 @@
 {
   "version": 1,
   "questions": [
+    {
+      "id": "best_pet",
+      "category": "lifestyle",
+      "title": "Which is the best pet, cats or dogs?",
+      "text": "Which is the best pet, cats or dogs?"
+    },
     {
       "id": "undergrad_majors",
       "category": "education",

backend/app/services/credential.py

@@ -1,8 +1,9 @@
 """Credential Summary builder + refresher.
 
 The Credential Summary is a JSON dict (participant_id -> assessment)
-threaded into every later participant turn. It is built once after Phase
-1 and refreshed once after Phase 2 critique.
+threaded into every later participant turn. Each LLM participant's entry
+is built concurrently during Phase 1 (as their initial opinion lands)
+and is only rebuilt later if their backing model changes.
 """
 from __future__ import annotations
 
@@ -14,6 +15,8 @@ from app.services.json_calls import orchestrator_call
 from app.services.prompts import (
     CREDENTIAL_BUILD_PROMPT,
     CREDENTIAL_REFRESH_PROMPT,
+    HUMAN_CREDENTIAL_FROM_PROFILE_PROMPT,
+    SINGLE_PARTICIPANT_CREDENTIAL_BUILD_PROMPT,
 )
 from app.utils.sanitize import strip_thinking
 
@@ -68,8 +71,8 @@ async def build_credential_summary(
 ) -> list[dict[str, Any]]:
     """Build the Credential Summary list. Returns an empty list on parse failure.
 
-    Human participants (kind == "human") are NOT sent to the LLM - the
-    user already authored their own credential summary in the
+    Human participants (kind == "human") are NOT sent to the LLM -
+    their credential was generated from the user's profile text in the
     HumanParticipantModal. We prepend that entry to the front of the
     returned list so the human always appears first in the modal /
     export, and we exclude them from the LLM input so the orchestrator
@@ -101,6 +104,139 @@ async def build_credential_summary(
     return creds
 
 
+async def build_credential_for_participant(
+    *,
+    orchestrator_model_id: str,
+    question: str,
+    participant: Any,
+    initial_opinion: str,
+    api_log: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Build one credential entry from a role prompt + Phase-1 opinion."""
+    opinion = strip_thinking(initial_opinion or "")
+    prompt = SINGLE_PARTICIPANT_CREDENTIAL_BUILD_PROMPT.format(
+        question=question,
+        participant_id=participant.participant_id,
+        name=participant.name,
+        role_prompt=(participant.role_prompt or "").strip() or "(none)",
+        first_opinion=opinion or "(no opinion recorded)",
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=orchestrator_model_id,
+        user_prompt=prompt,
+        label=f"build_credential:{participant.participant_id}",
+        api_log=api_log,
+        max_tokens=512,
+    )
+    cred: dict[str, Any] = {}
+    if isinstance(parsed, dict):
+        if isinstance(parsed.get("credential"), dict):
+            cred = parsed["credential"]
+        elif isinstance(parsed.get("credentials"), list) and parsed["credentials"]:
+            cred = parsed["credentials"][0]
+
+    merged = {
+        "participant_id": participant.participant_id,
+        "name": participant.name,
+        "expertise": cred.get("expertise", ""),
+        "personality": cred.get("personality", ""),
+        "credibility_for_question": cred.get("credibility_for_question", 0.5),
+        "bias_to_watch": cred.get("bias_to_watch", ""),
+        "is_human": False,
+    }
+    if not merged["expertise"]:
+        merged["expertise"] = "(no credential available)"
+    return normalize_one_credential(merged)
+
+
+def assemble_credential_summary_list(
+    *,
+    participants: list[Any],
+    credential_entries_by_pid: dict[str, dict[str, Any]],
+    human_credential: dict[str, Any] | None = None,
+) -> list[dict[str, Any]]:
+    """Merge per-participant credential rows in roster order (human first)."""
+    creds: list[dict[str, Any]] = []
+    if human_credential:
+        creds.append(normalize_one_credential(human_credential))
+
+    for p in participants:
+        if getattr(p, "kind", "") == "human":
+            continue
+        row = credential_entries_by_pid.get(p.participant_id)
+        if row:
+            creds.append(row)
+        else:
+            creds.append(normalize_one_credential({
+                "participant_id": p.participant_id,
+                "name": p.name,
+                "expertise": "(no credential available)",
+                "personality": "",
+                "credibility_for_question": 0.5,
+                "bias_to_watch": "",
+                "is_human": False,
+            }))
+    return creds
+
+
+async def build_human_credential_from_profile(
+    *,
+    orchestrator_model_id: str,
+    question: str,
+    name: str,
+    profile_text: str,
+    participant_id: str = "",
+    api_log: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Turn a human's freeform self-description into a structured credential.
+
+    Uses the same assessment rubric as Phase-1 credential building for
+    LLM participants (expertise, style, credibility, bias) but sources
+    only the profile text — equivalent to a persona role prompt.
+    """
+    q = (question or "").strip()
+    if q:
+        question_block = f"Question:\n<<<\n{q}\n>>>\n\n"
+    else:
+        question_block = (
+            "Discussion question: (not specified yet). Assess the "
+            "participant in general terms; credibility_for_question "
+            "should reflect their likely relevance once a topic is "
+            "chosen.\n\n"
+        )
+    prompt = HUMAN_CREDENTIAL_FROM_PROFILE_PROMPT.format(
+        question_block=question_block,
+        name=name.strip(),
+        profile_text=profile_text.strip(),
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=orchestrator_model_id,
+        user_prompt=prompt,
+        label="human_credential_from_profile",
+        api_log=api_log,
+        max_tokens=768,
+    )
+    cred: dict[str, Any] = {}
+    if isinstance(parsed, dict):
+        if isinstance(parsed.get("credential"), dict):
+            cred = parsed["credential"]
+        elif isinstance(parsed.get("credentials"), list) and parsed["credentials"]:
+            cred = parsed["credentials"][0]
+
+    merged = {
+        "participant_id": participant_id,
+        "name": name.strip(),
+        "expertise": cred.get("expertise", ""),
+        "personality": cred.get("personality", ""),
+        "credibility_for_question": cred.get("credibility_for_question", 0.55),
+        "bias_to_watch": cred.get("bias_to_watch", ""),
+        "is_human": True,
+    }
+    if not merged["expertise"] and profile_text.strip():
+        merged["expertise"] = profile_text.strip()[:500]
+    return normalize_one_credential(merged)
+
+
 async def refresh_credential_summary(
     *,
     orchestrator_model_id: str,
@@ -160,7 +296,7 @@ def normalize_one_credential(c: dict[str, Any]) -> dict[str, Any]:
         "personality": c.get("personality", ""),
         "credibility_for_question": max(0.0, min(1.0, score)),
         "bias_to_watch": c.get("bias_to_watch", ""),
-        "is_human": bool(c.get("is_human", True)),
+        "is_human": bool(c.get("is_human", False)),
     }
 
 

backend/app/services/models.py

@@ -310,6 +310,15 @@ class Session:
     # Phase 1 outputs
     initial_opinions: dict[str, str] = field(default_factory=dict)
     credential_summary: list[dict[str, Any]] = field(default_factory=list)
+    # Per-participant credential builds kicked off as each initial
+    # opinion completes during Phase 1 (concurrent with remaining turns).
+    credential_build_tasks: dict[str, Any] = field(default_factory=dict)
+    credential_entries_by_pid: dict[str, dict[str, Any]] = field(
+        default_factory=dict,
+    )
+    # model_id each credential row was built for; used to rebuild only
+    # when the backing LLM behind a participant changes.
+    credential_model_by_pid: dict[str, str] = field(default_factory=dict)
 
     # Phase 2 / 3 / 4 / 5 message store. Each entry:
     #   { speaker_id, speaker_name, role: "participant"|"orchestrator",

backend/app/services/orchestrator.py

@@ -4,7 +4,7 @@ group discussion to a consensus (or to a documented failure-to-consense).
 Phase outline (matches the build plan):
 
     1. Initial Opinions (independent, no peeking)
-    1.5. Build Credential Summary
+    1.5. Credential Summary (built concurrently during Phase 1)
     2. Critique x 2 rounds (full history visible)
     3. Status Assessment (max 3 iterations of targeted follow-ups)
     4. Opinion Finalization
@@ -53,9 +53,9 @@ from app.services.context_budget import (
     should_summarize,
 )
 from app.services.credential import (
-    build_credential_summary,
+    assemble_credential_summary_list,
+    build_credential_for_participant,
     credentials_to_block,
-    refresh_credential_summary,
 )
 from app.services.json_calls import orchestrator_call
 from app.services.orchestrator_speed import (
@@ -765,6 +765,107 @@ def _participant_turn_failure_sse(
     return out
 
 
+# ---------------------------------------------------------------------------
+# Credential summary (concurrent with Phase 1)
+# ---------------------------------------------------------------------------
+
+async def _credential_build_runner(
+    session: Session,
+    participant: Participant,
+    initial_opinion: str,
+) -> None:
+    """Background task: one participant's credential row."""
+    try:
+        cred = await build_credential_for_participant(
+            orchestrator_model_id=_orchestrator_model_id(session),
+            question=session.question,
+            participant=participant,
+            initial_opinion=initial_opinion,
+            api_log=session.api_log,
+        )
+        session.credential_entries_by_pid[participant.participant_id] = cred
+        session.credential_model_by_pid[participant.participant_id] = (
+            participant.model_id
+        )
+        _bump_orchestrator_count(session)
+    except Exception as exc:
+        LOG.exception(
+            "Credential build failed for %s: %s",
+            participant.participant_id,
+            exc,
+        )
+
+
+def _schedule_phase1_credential_build(
+    session: Session,
+    participant: Participant,
+    initial_opinion: str,
+) -> None:
+    """Start (or restart) a background credential build for one AI participant."""
+    if participant.kind == "human":
+        return
+    if not (initial_opinion or "").strip():
+        return
+
+    pid = participant.participant_id
+    existing = session.credential_build_tasks.get(pid)
+    if existing is not None and not existing.done():
+        existing.cancel()
+
+    session.credential_build_tasks[pid] = asyncio.create_task(
+        _credential_build_runner(session, participant, initial_opinion),
+        name=f"credential:{pid}",
+    )
+
+
+def _sync_credential_summary_from_entries(session: Session) -> None:
+    session.credential_summary = assemble_credential_summary_list(
+        participants=_active_participants(session),
+        credential_entries_by_pid=session.credential_entries_by_pid,
+        human_credential=session.human_credential,
+    )
+
+
+async def _await_phase1_credential_tasks(session: Session) -> None:
+    """Wait for any in-flight per-participant credential builds."""
+    tasks = [
+        t for t in session.credential_build_tasks.values()
+        if t is not None and not t.done()
+    ]
+    if tasks:
+        await asyncio.gather(*tasks, return_exceptions=True)
+    _sync_credential_summary_from_entries(session)
+
+
+async def _rebuild_participant_credential_on_model_change(
+    session: Session,
+    participant: Participant,
+) -> bool:
+    """Rebuild one credential row when the backing LLM model changes."""
+    if participant.kind == "human":
+        return False
+    pid = participant.participant_id
+    opinion = (session.initial_opinions or {}).get(pid, "")
+    if not opinion.strip():
+        return False
+    prior_model = session.credential_model_by_pid.get(pid)
+    if not prior_model or prior_model == participant.model_id:
+        return False
+
+    cred = await build_credential_for_participant(
+        orchestrator_model_id=_orchestrator_model_id(session),
+        question=session.question,
+        participant=participant,
+        initial_opinion=opinion,
+        api_log=session.api_log,
+    )
+    _bump_orchestrator_count(session)
+    session.credential_entries_by_pid[pid] = cred
+    session.credential_model_by_pid[pid] = participant.model_id
+    _sync_credential_summary_from_entries(session)
+    return True
+
+
 # ---------------------------------------------------------------------------
 # Phase implementations
 # ---------------------------------------------------------------------------
@@ -790,7 +891,11 @@ async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
             yield chunk
 
     async def _post_initial(result: _AiTurnResult) -> dict[str, Any]:
-        session.initial_opinions[result.participant.participant_id] = result.turn.text
+        speaker = result.turn.speaker
+        session.initial_opinions[speaker.participant_id] = result.turn.text
+        _schedule_phase1_credential_build(
+            session, speaker, result.turn.text,
+        )
         return {}
 
     def _build_initial_spec(p: Participant) -> _AiTurnSpec | None:
@@ -813,21 +918,9 @@ async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
     ):
         yield chunk
 
-    for chunk in _orchestrator_banner_sse(session, "Building Credential Summary..."):
-        yield chunk
-    creds = await build_credential_summary(
-        orchestrator_model_id=_orchestrator_model_id(session),
-        question=session.question,
-        participants=_active_participants(session),
-        initial_opinions=session.initial_opinions,
-        api_log=session.api_log,
-        human_credential=session.human_credential,
-    )
-    _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.
+    # Credential rows were built in parallel as each opinion landed;
+    # only wait here if any background task is still finishing.
+    await _await_phase1_credential_tasks(session)
     yield _sse("credentials_updated", {
         "stage": "built",
         "credentials": session.credential_summary,
@@ -936,7 +1029,6 @@ async def _phase_status_assessment(session: Session) -> AsyncIterator[str]:
         yield chunk
 
     cred_block = credentials_to_block(session.credential_summary)
-    cred_refreshed = False
 
     for iteration in range(session.limits.status_assessment_max):
         session.status_assessment_iterations = iteration + 1
@@ -974,27 +1066,6 @@ async def _phase_status_assessment(session: Session) -> AsyncIterator[str]:
             yield _sse("orchestrator", _msg_payload(msg))
             return
 
-        # Refresh credentials only when follow-ups are actually needed.
-        if not cred_refreshed:
-            cred_refreshed = True
-            full_transcript = _format_history(session.messages)
-            refreshed = await refresh_credential_summary(
-                orchestrator_model_id=_orchestrator_model_id(session),
-                question=session.question,
-                participants=_active_participants(session),
-                existing=session.credential_summary,
-                critique_transcript=full_transcript,
-                api_log=session.api_log,
-            )
-            _bump_orchestrator_count(session)
-            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)
-
         # Otherwise run targeted follow-ups
         active_ids = {p.participant_id for p in _active_participants(session)}
         for oq in open_qs:

backend/app/services/orchestrator_speed.py

@@ -356,7 +356,10 @@ async def _emit_ai_turn_result(
 
     p = result.participant
     turn = result.turn
+    substituted = False
     for ev in turn.sse_events:
+        if "participant_substituted" in ev:
+            substituted = True
         yield ev
     if not turn.ok:
         for chunk in _participant_turn_failure_sse(session, p):
@@ -380,6 +383,18 @@ async def _emit_ai_turn_result(
     )
     yield _sse("message", _msg_payload(msg))
 
+    if substituted:
+        from app.services.orchestrator import (
+            _rebuild_participant_credential_on_model_change,
+        )
+        if await _rebuild_participant_credential_on_model_change(
+            session, speaker,
+        ):
+            yield _sse("credentials_updated", {
+                "stage": "model_changed",
+                "credentials": session.credential_summary,
+            })
+
     if _orchestrator_cap_hit(session):
         async for chunk in _wait_for_continue(session, "orchestrator"):
             yield chunk

backend/app/services/prompts/__init__.py

@@ -14,6 +14,8 @@ from app.services.prompts.initial_opinions import INITIAL_OPINION_PROMPT
 from app.services.prompts.credential_summary import (
     CREDENTIAL_BUILD_PROMPT,
     CREDENTIAL_REFRESH_PROMPT,
+    HUMAN_CREDENTIAL_FROM_PROFILE_PROMPT,
+    SINGLE_PARTICIPANT_CREDENTIAL_BUILD_PROMPT,
 )
 from app.services.prompts.critique import CRITIQUE_PROMPT
 from app.services.prompts.status_assessment import (
@@ -48,6 +50,8 @@ __all__ = [
     "INITIAL_OPINION_PROMPT",
     "CREDENTIAL_BUILD_PROMPT",
     "CREDENTIAL_REFRESH_PROMPT",
+    "HUMAN_CREDENTIAL_FROM_PROFILE_PROMPT",
+    "SINGLE_PARTICIPANT_CREDENTIAL_BUILD_PROMPT",
     "CRITIQUE_PROMPT",
     "STATUS_ASSESSMENT_PROMPT",
     "TARGETED_FOLLOWUP_PROMPT",

backend/app/services/prompts/credential_summary.py

@@ -1,10 +1,9 @@
 """Credential Summary: the orchestrator's neutral assessment of each
 participant's expertise, personality, and credibility on the question.
 
-Built once after Phase 1 from each participant's role prompt + first
-opinion. Refreshed once after Phase 2 critique because participants
-reveal a lot more about themselves through critique than through their
-opening pitch.
+Each LLM participant's entry is built concurrently during Phase 1 (as
+their initial opinion lands). Entries are only rebuilt if the backing
+LLM model behind that participant changes.
 """
 
 CREDENTIAL_BUILD_PROMPT = (
@@ -34,6 +33,59 @@ CREDENTIAL_BUILD_PROMPT = (
     "any participant. Output JSON only - no commentary, no markdown."
 )
 
+HUMAN_CREDENTIAL_FROM_PROFILE_PROMPT = (
+    "A human participant is joining a group discussion. Their "
+    "self-description below is equivalent to an LLM participant's role "
+    "prompt — use it as the sole source of background (they have not "
+    "spoken in the discussion yet). Build a Credential Summary entry: "
+    "a neutral, third-person assessment that any other participant could "
+    "use to weight their statements.\n\n"
+    "{question_block}"
+    "Name: {name}\n"
+    "Self-description:\n<<<\n{profile_text}\n>>>\n\n"
+    "Return JSON ONLY in this exact shape:\n"
+    "{{\n"
+    '  "credential": {{\n'
+    '    "name": "{name}",\n'
+    '    "expertise": "<1-2 sentences on what they know about and don\'t know about>",\n'
+    '    "personality": "<1 sentence on debating style / temperament>",\n'
+    '    "credibility_for_question": <number 0.0 to 1.0>,\n'
+    '    "bias_to_watch": "<1 sentence on biases or blind spots>"\n'
+    "  }}\n"
+    "}}\n\n"
+    "credibility_for_question is YOUR neutral estimate of how much weight "
+    "their voice should carry on THIS specific question, given their "
+    "self-description and the question topic. Use the full 0-1 scale. "
+    "Output JSON only — no commentary, no markdown."
+)
+
+SINGLE_PARTICIPANT_CREDENTIAL_BUILD_PROMPT = (
+    "Below is the question being discussed and, for one participant, "
+    "their role prompt and their first opinion (Phase 1). Build ONE "
+    "Credential Summary entry: a neutral, third-person assessment that "
+    "any other participant could use to weight their statements.\n\n"
+    "Question:\n<<<\n{question}\n>>>\n\n"
+    "Participant id: {participant_id}\n"
+    "Name: {name}\n"
+    "Role prompt:\n<<<\n{role_prompt}\n>>>\n"
+    "First opinion:\n<<<\n{first_opinion}\n>>>\n\n"
+    "Return JSON ONLY in this exact shape:\n"
+    "{{\n"
+    '  "credential": {{\n'
+    '    "participant_id": "{participant_id}",\n'
+    '    "name": "{name}",\n'
+    '    "expertise": "<1-2 sentences on what they know about and don\'t know about>",\n'
+    '    "personality": "<1 sentence on debating style / temperament>",\n'
+    '    "credibility_for_question": <number 0.0 to 1.0>,\n'
+    '    "bias_to_watch": "<1 sentence on biases or blind spots>"\n'
+    "  }}\n"
+    "}}\n\n"
+    "credibility_for_question is YOUR neutral estimate of how much weight "
+    "their voice should carry on THIS specific question, given their stated "
+    "background and how they framed their first opinion. Use the full 0-1 "
+    "scale. Output JSON only — no commentary, no markdown."
+)
+
 CREDENTIAL_REFRESH_PROMPT = (
     "Below is the original Credential Summary you produced after Phase 1. "
     "After two rounds of critique, the participants have revealed more "

frontend/src/App.js

@@ -9,6 +9,7 @@ import CredentialSummaryModal from './components/CredentialSummaryModal';
 import ConversationLimitsModal from './components/ConversationLimitsModal';
 import PromptCatalogModal from './components/PromptCatalogModal';
 import HumanParticipantModal from './components/HumanParticipantModal';
+import RateLimitNotice from './components/RateLimitNotice';
 import {
   fetchModels, fetchPersonas, fetchDemoQuestions,
   startChat, continueChat, getOrchestrator, setOrchestrator,
@@ -21,6 +22,7 @@ import {
   fetchPromptCatalog,
   getRateLimitStatus,
   submitHumanResponse, patchHumanCredential,
+  generateHumanCredentialFromProfile,
 } from './utils/api';
 import * as storage from './utils/storage';
 import './styles/variables.css';
@@ -28,9 +30,9 @@ import './styles/layout.css';
 import './styles/components.css';
 import './styles/ccai.css';
 
-function pickRandom(list) {
-  if (!list || list.length === 0) return null;
-  return list[Math.floor(Math.random() * list.length)];
+/** True when the user is subject to the per-IP daily chat cap. */
+function isRateLimitedUser(auth) {
+  return auth && !auth.is_org_member && auth.remaining_conversations >= 0;
 }
 
 /** Append a system note at the current point in the chat timeline (not end-of-feed). */
@@ -159,6 +161,10 @@ export default function App() {
   const [humanSubmitting, setHumanSubmitting] = useState(false);
 
   const abortRef = useRef(null);
+  const chatControlsRef = useRef(null);
+  const humanCredentialGenRef = useRef(null);
+  const oneLeftNoticeShownRef = useRef(false);
+  const [rateLimitNotice, setRateLimitNotice] = useState(null);
 
   // ─── Apply theme ────────────────────────────────────────────────
   useEffect(() => {
@@ -196,6 +202,15 @@ export default function App() {
     }).catch(() => {});
   }, [persisted.orchestrator_model_id]);
 
+  // Pop up once per session when the daily cap leaves exactly one chat.
+  useEffect(() => {
+    if (!isRateLimitedUser(auth)) return;
+    if (auth.remaining_conversations === 1 && !oneLeftNoticeShownRef.current) {
+      oneLeftNoticeShownRef.current = true;
+      setRateLimitNotice('one_left');
+    }
+  }, [auth]);
+
   // ─── Build a flat list of all models for pickers ────────────────
   const allModelsFlat = useMemo(() => {
     const list = [];
@@ -364,13 +379,67 @@ export default function App() {
     setHumanModalOpen(true);
   }, [humanParticipant]);
 
+  const runHumanCredentialGeneration = useCallback(async (spec, question) => {
+    const result = await generateHumanCredentialFromProfile({
+      name: spec.name,
+      question: (question || '').trim(),
+      profile_text: spec.profile_text,
+      participant_id: spec.participant_id,
+      orchestrator_model_id: orchestratorModel || null,
+    });
+    const cred = result.credential || {};
+    return {
+      ...spec,
+      credential_pending: false,
+      credential_built_for_question: (question || '').trim(),
+      credential_summary: {
+        name: cred.name || spec.name,
+        expertise: cred.expertise || '',
+        personality: cred.personality || '',
+        credibility_for_question: typeof cred.credibility_for_question === 'number'
+          ? cred.credibility_for_question
+          : 0.55,
+        bias_to_watch: cred.bias_to_watch || '',
+      },
+    };
+  }, [orchestratorModel]);
+
+  const startHumanCredentialGeneration = useCallback((spec, question) => {
+    const promise = runHumanCredentialGeneration(spec, question)
+      .then((updated) => {
+        setHumanParticipant(prev => (
+          prev && prev.participant_id === spec.participant_id ? updated : prev
+        ));
+        return updated;
+      })
+      .catch((err) => {
+        console.error('Human credential generation failed:', err);
+        setHumanParticipant(prev => (
+          prev && prev.participant_id === spec.participant_id
+            ? { ...prev, credential_pending: false, credential_error: err.message }
+            : prev
+        ));
+        throw err;
+      });
+    humanCredentialGenRef.current = promise;
+    return promise;
+  }, [runHumanCredentialGeneration]);
+
   const handleSaveHuman = useCallback((spec) => {
-    setHumanParticipant(spec);
+    const pending = {
+      ...spec,
+      credential_pending: true,
+      credential_summary: null,
+    };
+    setHumanParticipant(pending);
     setHumanModalOpen(false);
     setHumanEditing(null);
-  }, []);
+    const question = chatControlsRef.current?.getDraftQuestion?.() || '';
+    startHumanCredentialGeneration(pending, question);
+  }, [startHumanCredentialGeneration]);
 
   const handleRemoveHuman = useCallback(() => {
+    humanCredentialGenRef.current = null;
     setHumanParticipant(null);
     setHumanModalOpen(false);
     setHumanEditing(null);
@@ -421,6 +490,7 @@ export default function App() {
             credibility_for_question: updated.credibility_for_question ?? 0.55,
             bias_to_watch: updated.bias_to_watch || '',
           },
+          // profile_text unchanged — edits in the modal only adjust the summary.
         } : prev);
         // Refresh the credentials cache so the modal reflects the edit.
         const data = await fetchCredentials(sessionId);
@@ -586,7 +656,7 @@ export default function App() {
   // `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 buildStartPayload = useCallback((theQuestion, participantsOverride, humanOverride) => {
     // Always honor the sidebar enabled toggles, including when
     // auto-select supplies a participantsOverride list (which used to
     // bypass enabledMap and always prepend a disabled human).
@@ -616,14 +686,15 @@ export default function App() {
     // participants array. Backend rejects start if it sees a human in
     // participants but no human_credential, so this MUST be present
     // whenever the human is enabled.
+    const hp = humanOverride ?? humanParticipant;
     const humanInList = baseList.find(p => p.kind === 'human');
     let human_credential = null;
-    if (humanInList && humanParticipant) {
-      const cs = humanParticipant.credential_summary || {};
+    if (humanInList && hp) {
+      const cs = hp.credential_summary || {};
       human_credential = {
         participant_id: humanInList.participant_id,
         name: humanInList.name,
-        expertise: cs.expertise || '',
+        expertise: cs.expertise || hp.profile_text?.slice(0, 500) || '',
         personality: cs.personality || '',
         credibility_for_question: typeof cs.credibility_for_question === 'number'
           ? cs.credibility_for_question
@@ -673,6 +744,10 @@ export default function App() {
   // ─── Start chat ─────────────────────────────────────────────────
   const handleStart = useCallback(async (theQuestion) => {
     if (!theQuestion || !theQuestion.trim()) return;
+    if (isRateLimitedUser(auth) && auth.remaining_conversations === 0) {
+      setRateLimitNotice('exhausted');
+      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;
@@ -768,9 +843,41 @@ export default function App() {
       }
     }
 
+    let humanForStart = humanParticipant;
+    const humanEnabledForStart = humanParticipant
+      && enabledMap[humanParticipant.participant_id] !== false;
+    if (humanEnabledForStart) {
+      const q = theQuestion.trim();
+      const needsQuestionRefresh = q
+        && humanParticipant.credential_built_for_question !== q;
+      if (humanParticipant.credential_pending && humanCredentialGenRef.current) {
+        setStatusText('Finishing credential summary...');
+        try {
+          humanForStart = await humanCredentialGenRef.current;
+        } catch {
+          humanForStart = humanParticipant;
+        }
+      }
+      if (!humanForStart?.credential_summary?.expertise || needsQuestionRefresh) {
+        setStatusText('Preparing credential summary...');
+        try {
+          humanForStart = await runHumanCredentialGeneration(humanParticipant, q);
+          setHumanParticipant(humanForStart);
+          humanCredentialGenRef.current = Promise.resolve(humanForStart);
+        } catch (err) {
+          setIsRunning(false);
+          setStatusText('');
+          setSystemMessages(prev => [...prev, {
+            text: `Could not generate human credential: ${err.message}`,
+          }]);
+          return;
+        }
+      }
+    }
+
     try {
       await startChat(
-        buildStartPayload(theQuestion, resolvedParticipants),
+        buildStartPayload(theQuestion, resolvedParticipants, humanForStart),
         {
           onSession: (data) => {
             setSessionId(data.session_id);
@@ -929,21 +1036,12 @@ export default function App() {
       getAuthStatus().then(setAuth).catch(() => {});
     }
   }, [
-    buildStartPayload, enabledSelectedCount, dailyLimit,
+    buildStartPayload, enabledSelectedCount, dailyLimit, auth,
     autoSelectMode, allCatalogParticipants, modelAssignments,
     maxParticipants, orchestratorModel, enabledMap,
-    humanParticipant, humanCatalogEntry,
+    humanParticipant, humanCatalogEntry, runHumanCredentialGeneration,
   ]);
 
-  const handleStartRandom = useCallback(() => {
-    if (demoQuestions.length === 0) {
-      setSystemMessages(prev => [...prev, { text: 'No demo questions available.' }]);
-      return;
-    }
-    const q = pickRandom(demoQuestions);
-    handleStart(q.text);
-  }, [demoQuestions, handleStart]);
-
   // 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.
@@ -964,7 +1062,6 @@ export default function App() {
         theme={theme}
         onToggleTheme={() => setTheme(t => t === 'light' ? 'dark' : 'light')}
         auth={auth}
-        dailyLimit={dailyLimit}
         catalog={catalog}
         expertPersonas={expertPersonas}
         selectedIds={selectedIds}
@@ -1023,8 +1120,9 @@ export default function App() {
         />
         <div className="content">
           <ChatControls
-            onStartRandom={handleStartRandom}
-            onStartTyped={handleStart}
+            ref={chatControlsRef}
+            demoQuestions={demoQuestions}
+            onStart={handleStart}
             onStop={handleStop}
             disabled={startDisabled}
             isRunning={isRunning}
@@ -1086,8 +1184,6 @@ export default function App() {
       <HumanParticipantModal
         isOpen={humanModalOpen}
         initial={humanEditing}
-        question={activeQuestion}
-        orchestratorModel={orchestratorModel}
         onClose={() => { setHumanModalOpen(false); setHumanEditing(null); }}
         onSave={handleSaveHuman}
         onRemove={humanEditing ? handleRemoveHuman : null}
@@ -1105,6 +1201,10 @@ export default function App() {
         catalog={promptCatalog}
         onClose={() => setPromptCatalogOpen(false)}
       />
+      <RateLimitNotice
+        kind={rateLimitNotice}
+        onClose={() => setRateLimitNotice(null)}
+      />
     </div>
   );
 }

frontend/src/components/AuthBadge.js

@@ -1,19 +1,15 @@
 import React from 'react';
-import { LogIn, LogOut, User } from 'lucide-react';
+import { LogOut, User } from 'lucide-react';
 
-export default function AuthBadge({ auth, dailyLimit }) {
+export default function AuthBadge({ auth }) {
   if (!auth) return null;
-  const cap = dailyLimit || 30;
 
   if (auth.logged_in) {
     return (
-      <div className="auth-badge">
+      <div className="auth-badge auth-badge-end">
         <User size={14} />
         <span className="auth-username">{auth.username}</span>
         {auth.is_org_member && <span className="auth-org-tag">org</span>}
-        {!auth.is_org_member && auth.remaining_conversations >= 0 && (
-          <span className="auth-remaining">{auth.remaining_conversations} left</span>
-        )}
         <a href="/oauth/huggingface/logout" className="auth-link" title="Sign out">
           <LogOut size={13} />
         </a>
@@ -22,12 +18,9 @@ export default function AuthBadge({ auth, dailyLimit }) {
   }
 
   return (
-    <div className="auth-badge">
-      {auth.remaining_conversations >= 0 && (
-        <span className="auth-remaining">{auth.remaining_conversations}/{cap} chats</span>
-      )}
+    <div className="auth-badge auth-badge-end">
       <a href="/oauth/huggingface/login" className="auth-link auth-login">
-        <LogIn size={13} /> Sign in
+        Sign in
       </a>
     </div>
   );

frontend/src/components/ChatControls.js

@@ -1,26 +1,96 @@
-import React, { useState } from 'react';
-import { Play, Shuffle } from 'lucide-react';
+import React, { useState, useRef, useCallback, forwardRef, useImperativeHandle } from 'react';
+import { Play } from 'lucide-react';
+
+const DEMO_SUFFIX = ' [Or type your own question]';
+
+function formatDemoDisplay(question) {
+  if (!question) return '';
+  const label = (question.title || question.text || '').trim();
+  return `Demo Question: ${label}${DEMO_SUFFIX}`;
+}
 
 /**
- * "Let Them Start" picks a random demo question from the bank.
- * "Start Chat With My Prompt" uses the typed-in question.
- *
- * Both require >=2 enabled participants - that's enforced upstream and
- * mirrored here as a disabled state.
+ * Question field pre-filled with a cycling demo prompt; "Start Chat"
+ * uses the demo question text or whatever the user typed.
  */
-export default function ChatControls({
-  onStartRandom,
-  onStartTyped,
+const ChatControls = forwardRef(function ChatControls({
+  demoQuestions = [],
+  onStart,
   onStop,
   disabled,
   isRunning,
   disabledReason,
   activeQuestion,
-}) {
-  const [text, setText] = useState('');
-  const placeholder = disabled
-    ? (disabledReason || 'Add participants to start a conversation')
-    : 'Or type your own question for the group...';
+}, ref) {
+  const demoIndexRef = useRef(0);
+  const [demoIndex, setDemoIndex] = useState(0);
+  const [mode, setMode] = useState('demo');
+  const [userText, setUserText] = useState('');
+
+  const currentDemo = demoQuestions.length > 0
+    ? demoQuestions[demoIndex % demoQuestions.length]
+    : null;
+  const demoDisplay = formatDemoDisplay(currentDemo);
+  const inputValue = mode === 'demo' ? demoDisplay : userText;
+
+  const resolveQuestion = useCallback(() => {
+    if (mode === 'custom') return userText.trim();
+    return (currentDemo?.text || '').trim();
+  }, [mode, userText, currentDemo]);
+
+  useImperativeHandle(ref, () => ({
+    getDraftQuestion: resolveQuestion,
+  }), [resolveQuestion]);
+
+  const advanceDemo = useCallback(() => {
+    if (demoQuestions.length === 0) return;
+    const next = (demoIndexRef.current + 1) % demoQuestions.length;
+    demoIndexRef.current = next;
+    setDemoIndex(next);
+    setMode('demo');
+    setUserText('');
+  }, [demoQuestions.length]);
+
+  const handleChange = (e) => {
+    const v = e.target.value;
+    if (mode === 'demo') {
+      if (v === '' || v === demoDisplay) return;
+      setMode('custom');
+      setUserText(v);
+      return;
+    }
+    if (v === '') {
+      setMode('demo');
+      setUserText('');
+      return;
+    }
+    setUserText(v);
+  };
+
+  const handleKeyDown = (e) => {
+    if (disabled || mode !== 'demo') return;
+    if (e.key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey) {
+      setMode('custom');
+      setUserText(e.key);
+      e.preventDefault();
+      return;
+    }
+    if (e.key === 'Backspace' || e.key === 'Delete') {
+      setMode('custom');
+      setUserText('');
+      e.preventDefault();
+    }
+  };
+
+  const handleStart = () => {
+    const question = resolveQuestion();
+    if (!question || disabled) return;
+    onStart(question);
+    advanceDemo();
+  };
+
+  const canStart = !disabled && !!resolveQuestion();
+
   return (
     <div className="chat-controls">
       {isRunning ? (
@@ -40,37 +110,35 @@ export default function ChatControls({
         </>
       ) : (
         <>
-          <button
-            className="btn-primary"
-            disabled={disabled}
-            onClick={() => onStartRandom()}
-            title="Pick a random demo question and start"
-          >
-            <Shuffle size={14} style={{ verticalAlign: 'middle', marginRight: 4 }} />
-            Let Them Start
-          </button>
           <input
             type="text"
-            value={text}
-            placeholder={placeholder}
+            value={inputValue}
+            placeholder={
+              disabled
+                ? (disabledReason || 'Add participants to start a conversation')
+                : (demoQuestions.length === 0 ? 'Loading demo questions…' : '')
+            }
             disabled={disabled}
-            onChange={e => setText(e.target.value)}
-            onKeyDown={e => {
-              if (e.key === 'Enter' && !disabled && text.trim()) {
-                onStartTyped(text.trim());
+            onChange={handleChange}
+            onKeyDown={(e) => {
+              handleKeyDown(e);
+              if (e.key === 'Enter' && canStart) {
+                handleStart();
               }
             }}
           />
           <button
             className="btn-primary"
-            disabled={disabled || !text.trim()}
-            onClick={() => onStartTyped(text.trim())}
+            disabled={!canStart}
+            onClick={handleStart}
           >
             <Play size={14} style={{ verticalAlign: 'middle', marginRight: 4 }} />
-            Start Chat With My Prompt
+            Start Chat
           </button>
         </>
       )}
     </div>
   );
-}
+});
+
+export default ChatControls;

frontend/src/components/CredentialSummaryModal.js

@@ -6,8 +6,9 @@ import { Download, Edit2, Check, X, User } from 'lucide-react';
  * 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
+ * Built concurrently during Phase 1 (as each initial opinion lands).
+ * Rebuilt only if a participant's backing LLM model changes. 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.
  *
@@ -62,7 +63,7 @@ export default function CredentialSummaryModal({
             <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.
+              Built during Phase 1; updated only if a participant&apos;s model changes.
             </div>
           </div>
           <div className="ccai-tab-spacer" />

frontend/src/components/Header.js

@@ -23,7 +23,6 @@ export default function Header({
   theme,
   onToggleTheme,
   auth,
-  dailyLimit,
 
   catalog,
   expertPersonas,
@@ -88,7 +87,6 @@ export default function Header({
         </h1>
       </div>
       <div className="header-right">
-        <AuthBadge auth={auth} dailyLimit={dailyLimit} />
         <ParticipantDropdown
           catalog={catalog}
           expertPersonas={expertPersonas}
@@ -174,6 +172,7 @@ export default function Header({
           onShowConversationLimits={onShowConversationLimits}
           conversationLimitsOverridden={conversationLimitsOverridden}
         />
+        <AuthBadge auth={auth} />
       </div>
     </header>
   );

frontend/src/components/HumanParticipantModal.js

@@ -1,196 +1,42 @@
-import React, { useState, useCallback, useRef, useEffect } from 'react';
-import { Download, Sparkles, X } from 'lucide-react';
-import {
-  startCredentialDraft,
-  answerCredentialDraft,
-  cancelCredentialDraft,
-} from '../utils/api';
+import React, { useState, useCallback, useEffect } from 'react';
+import { X } from 'lucide-react';
 
 /**
  * Modal for adding (or editing) the in-the-loop human participant.
  *
- * Two flows:
- *   - Manual: the user types their own credential summary into the
- *     text area. The textarea pre-fills with a sample so they always
- *     have somewhere to start.
- *   - AI-assisted: clicking "Use AI to make a Credential Summary"
- *     opens a small chat with the orchestrator LLM. The LLM asks 3-6
- *     adaptive questions and emits a final structured summary, which
- *     replaces the textarea content.
- *
- * On Approve, the modal hands the finalized
- *   { participant_id, name, credential_summary: {...} }
- * shape back to App.js via onSave. App.js persists it via storage and
- * adds the human to the active participant set.
- *
- * "Download as .txt" lets the user keep a copy of their summary
- * outside the demo (useful if they want to reuse it elsewhere).
+ * The user enters a name and a freeform self-description (experience,
+ * personality, etc.). On Approve the parent saves immediately and
+ * generates the structured credential summary in the background.
  */
 export default function HumanParticipantModal({
   isOpen,
   initial,
-  question,
-  orchestratorModel,
   onClose,
   onSave,
   onRemove,
 }) {
   const [name, setName] = useState('');
-  const [summary, setSummary] = useState('');
-  // AI Q&A state
-  const [aiDraftId, setAiDraftId] = useState(null);
-  const [aiHistory, setAiHistory] = useState([]); // [{q, a}, ...]
-  const [aiCurrentQuestion, setAiCurrentQuestion] = useState('');
-  const [aiAnswer, setAiAnswer] = useState('');
-  const [aiBusy, setAiBusy] = useState(false);
-  const [aiError, setAiError] = useState('');
-  const [aiCounts, setAiCounts] = useState({ asked: 0, max: 6 });
-
-  const sampleRef = useRef('');
+  const [profileText, setProfileText] = useState('');
 
-  // Reset on open / when the initial payload changes.
   useEffect(() => {
     if (!isOpen) return;
-    const initialName = initial?.name || 'Pat';
-    setName(initialName);
-    const sample = initial?.credential_summary
-      ? renderSummaryToText(initial.credential_summary)
-      : sampleSummaryText(initialName);
-    sampleRef.current = sample;
-    setSummary(sample);
-    setAiDraftId(null);
-    setAiHistory([]);
-    setAiCurrentQuestion('');
-    setAiAnswer('');
-    setAiBusy(false);
-    setAiError('');
-    setAiCounts({ asked: 0, max: 6 });
+    setName(initial?.name || 'Pat');
+    setProfileText(initial?.profile_text || '');
   }, [isOpen, initial]);
 
-  // Abandon the AI Q&A if the modal is closed mid-flow.
-  useEffect(() => {
-    if (!isOpen && aiDraftId) {
-      cancelCredentialDraft(aiDraftId);
-    }
-  }, [isOpen, aiDraftId]);
-
-  const handleStartAi = useCallback(async () => {
-    if (!name.trim()) {
-      setAiError('Please enter a name first.');
-      return;
-    }
-    if (!question || !question.trim()) {
-      setAiError('Enter your discussion question before using AI assist.');
-      return;
-    }
-    setAiBusy(true);
-    setAiError('');
-    try {
-      const result = await startCredentialDraft({
-        name: name.trim(),
-        question: question.trim(),
-        max_questions: 6,
-        orchestrator_model_id: orchestratorModel || null,
-      });
-      setAiDraftId(result.draft_id);
-      setAiCounts({
-        asked: result.questions_asked || 1,
-        max: result.max_questions || 6,
-      });
-      if (result.kind === 'summary') {
-        setSummary(renderSummaryToText({
-          ...(result.summary || {}),
-          name: result.summary?.name || name.trim(),
-        }));
-        setAiCurrentQuestion('');
-      } else {
-        setAiCurrentQuestion(result.question || '');
-      }
-    } catch (err) {
-      setAiError(err.message || 'AI assist failed to start.');
-    } finally {
-      setAiBusy(false);
-    }
-  }, [name, question, orchestratorModel]);
-
-  const handleSubmitAnswer = useCallback(async () => {
-    if (!aiDraftId) return;
-    if (!aiAnswer.trim()) {
-      setAiError('Please type an answer first.');
-      return;
-    }
-    setAiBusy(true);
-    setAiError('');
-    const lastQ = aiCurrentQuestion;
-    const lastA = aiAnswer.trim();
-    try {
-      const result = await answerCredentialDraft(aiDraftId, lastA);
-      setAiHistory(prev => [...prev, { q: lastQ, a: lastA }]);
-      setAiAnswer('');
-      setAiCounts({
-        asked: result.questions_asked || aiCounts.asked,
-        max: result.max_questions || aiCounts.max,
-      });
-      if (result.kind === 'summary') {
-        setSummary(renderSummaryToText({
-          ...(result.summary || {}),
-          name: result.summary?.name || name.trim(),
-        }));
-        setAiCurrentQuestion('');
-        setAiDraftId(null);
-      } else {
-        setAiCurrentQuestion(result.question || '');
-      }
-    } catch (err) {
-      setAiError(err.message || 'AI assist failed to continue.');
-    } finally {
-      setAiBusy(false);
-    }
-  }, [aiDraftId, aiAnswer, aiCurrentQuestion, aiCounts.asked, aiCounts.max, name]);
-
-  const handleStopAi = useCallback(async () => {
-    if (aiDraftId) {
-      await cancelCredentialDraft(aiDraftId);
-    }
-    setAiDraftId(null);
-    setAiCurrentQuestion('');
-    setAiAnswer('');
-    setAiError('');
-  }, [aiDraftId]);
-
   const handleApprove = useCallback(() => {
-    if (!name.trim()) {
-      setAiError('Please enter a name before approving.');
-      return;
-    }
-    if (!summary.trim()) {
-      setAiError('Credential summary cannot be empty.');
-      return;
-    }
-    const parsed = parseSummaryText(summary, name.trim());
+    if (!name.trim()) return;
+    if (!profileText.trim()) return;
     const pid = initial?.participant_id || `human_${Date.now()}`;
     onSave({
       participant_id: pid,
       name: name.trim(),
-      credential_summary: parsed,
+      profile_text: profileText.trim(),
     });
-  }, [name, summary, initial, onSave]);
-
-  const handleDownload = useCallback(() => {
-    const text = `Name: ${name}\n\n${summary}\n`;
-    const blob = new Blob([text], { type: 'text/plain;charset=utf-8' });
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = `${(name || 'human').replace(/\s+/g, '_')}-credential.txt`;
-    a.click();
-    URL.revokeObjectURL(url);
-  }, [name, summary]);
+  }, [name, profileText, initial, onSave]);
 
   if (!isOpen) return null;
 
-  const aiInProgress = !!aiDraftId && !!aiCurrentQuestion;
-
   return (
     <div className="ccai-credentials-overlay">
       <div className="ccai-credentials-card ccai-human-modal-card">
@@ -199,7 +45,7 @@ export default function HumanParticipantModal({
             <h2>Add a Human Participant</h2>
             <div className="ccai-credentials-subtitle">
               Give yourself (or another human) a seat at the table.
-              The orchestrator will pause for your input when it's
+              The orchestrator will pause for your input when it&apos;s
               your turn.
             </div>
           </div>
@@ -219,82 +65,27 @@ export default function HumanParticipantModal({
             />
           </label>
 
-          <div className="ccai-human-field">
-            <div className="ccai-human-summary-header">
-              <span className="ccai-human-field-label">
-                Credential summary
-              </span>
-              <button
-                type="button"
-                className="btn-sm btn-outline ccai-human-ai-btn"
-                onClick={handleStartAi}
-                disabled={aiBusy || aiInProgress}
-                title="Have the AI ask a few questions and draft a summary for you"
-              >
-                <Sparkles size={14} style={{ marginRight: 4 }} />
-                Use AI to make a Credential Summary
-              </button>
-            </div>
+          <label className="ccai-human-field">
+            <span className="ccai-human-field-label">
+              Experience, personality, …
+            </span>
             <textarea
               className="ccai-human-summary"
-              value={summary}
-              onChange={e => setSummary(e.target.value)}
-              rows={10}
+              value={profileText}
+              onChange={e => setProfileText(e.target.value)}
+              rows={8}
               spellCheck
+              placeholder={
+                'Describe your background, how you tend to argue, '
+                + 'and anything the group should know about your perspective…'
+              }
             />
             <div className="ccai-human-summary-help">
-              This is what the orchestrator and other participants will
-              see about you. Edit it to your taste — or click the AI
-              assist button above and answer a few questions.
+              The orchestrator will turn this into a credential summary
+              for the group — the same way it assesses each LLM
+              participant&apos;s persona prompt.
             </div>
-          </div>
-
-          {aiInProgress && (
-            <div className="ccai-human-ai-panel">
-              <div className="ccai-human-ai-counter">
-                AI assist · question {aiCounts.asked} of {aiCounts.max}
-                <button
-                  type="button"
-                  className="ccai-human-ai-stop"
-                  onClick={handleStopAi}
-                  title="Stop the AI Q&A and keep what's in the textarea"
-                >
-                  <X size={12} /> Stop
-                </button>
-              </div>
-              {aiHistory.map((qa, i) => (
-                <div key={i} className="ccai-human-ai-turn">
-                  <div className="ccai-human-ai-q">Q: {qa.q}</div>
-                  <div className="ccai-human-ai-a">A: {qa.a}</div>
-                </div>
-              ))}
-              <div className="ccai-human-ai-current-q">
-                <strong>Q:</strong> {aiCurrentQuestion}
-              </div>
-              <textarea
-                className="ccai-human-ai-answer"
-                value={aiAnswer}
-                onChange={e => setAiAnswer(e.target.value)}
-                rows={3}
-                placeholder="Your answer..."
-                disabled={aiBusy}
-              />
-              <div className="ccai-human-ai-actions">
-                <button
-                  type="button"
-                  className="btn btn-primary btn-sm"
-                  onClick={handleSubmitAnswer}
-                  disabled={aiBusy || !aiAnswer.trim()}
-                >
-                  {aiBusy ? 'Thinking…' : 'Send answer'}
-                </button>
-              </div>
-            </div>
-          )}
-
-          {aiError && (
-            <div className="ccai-human-error">{aiError}</div>
-          )}
+          </label>
         </div>
 
         <div className="ccai-human-modal-footer">
@@ -315,20 +106,15 @@ export default function HumanParticipantModal({
             <button
               type="button"
               className="btn-sm btn-outline"
-              onClick={handleDownload}
-              disabled={!summary.trim()}
+              onClick={onClose}
             >
-              <Download size={14} style={{ marginRight: 4 }} />
-              Download as .txt
-            </button>
-            <button type="button" className="btn-sm btn-outline" onClick={onClose}>
               Cancel
             </button>
             <button
               type="button"
               className="btn btn-primary btn-sm"
               onClick={handleApprove}
-              disabled={!name.trim() || !summary.trim()}
+              disabled={!name.trim() || !profileText.trim()}
             >
               Approve
             </button>
@@ -338,96 +124,3 @@ export default function HumanParticipantModal({
     </div>
   );
 }
-
-// ─── Helpers ─────────────────────────────────────────────────────
-
-function sampleSummaryText(name) {
-  // The pre-fill is intentionally generic-but-plausible: the user can
-  // edit a sentence or two and approve, or wipe it and start fresh.
-  return [
-    `Expertise: ${name} is a curious generalist with hands-on `
-      + 'experience across several professional domains, comfortable '
-      + 'asking pointed questions in unfamiliar territory.',
-    '',
-    `Style: Conversational and pragmatic; ${name} weighs trade-offs `
-      + 'aloud and is happy to change their mind when shown new '
-      + 'evidence.',
-    '',
-    'Credibility on this question: 0.55',
-    '',
-    'Bias to watch: Tendency to favor concrete, near-term solutions '
-      + 'over abstract long-horizon ones.',
-  ].join('\n');
-}
-
-function renderSummaryToText(cred) {
-  if (!cred) return '';
-  const lines = [];
-  if (cred.expertise) lines.push(`Expertise: ${cred.expertise}`);
-  if (cred.personality) lines.push('', `Style: ${cred.personality}`);
-  if (cred.credibility_for_question !== undefined
-      && cred.credibility_for_question !== null) {
-    const v = Number(cred.credibility_for_question);
-    if (!Number.isNaN(v)) {
-      lines.push('', `Credibility on this question: ${v.toFixed(2)}`);
-    }
-  }
-  if (cred.bias_to_watch) lines.push('', `Bias to watch: ${cred.bias_to_watch}`);
-  return lines.join('\n');
-}
-
-/**
- * Parse the textarea content back into the structured shape the
- * backend expects. Looks for lines starting with the field labels;
- * anything else is appended to whichever field is current.
- *
- * This is tolerant: if no labels are found, the whole blob becomes
- * the `expertise` field (so naive users typing freeform still get a
- * usable credential summary on Approve).
- */
-function parseSummaryText(text, name) {
-  const result = {
-    name,
-    expertise: '',
-    personality: '',
-    credibility_for_question: 0.55,
-    bias_to_watch: '',
-  };
-  let current = 'expertise';
-  for (const rawLine of text.split('\n')) {
-    const line = rawLine.trimEnd();
-    if (!line.trim()) continue;
-    const lower = line.toLowerCase();
-    if (lower.startsWith('expertise:')) {
-      current = 'expertise';
-      result.expertise = line.slice(line.indexOf(':') + 1).trim();
-    } else if (lower.startsWith('style:') || lower.startsWith('personality:')) {
-      current = 'personality';
-      result.personality = line.slice(line.indexOf(':') + 1).trim();
-    } else if (lower.startsWith('credibility')) {
-      current = 'credibility';
-      const num = parseFloat(line.replace(/[^0-9.]/g, ''));
-      if (!Number.isNaN(num)) {
-        // Heuristic: numbers > 1 are probably 0..100; coerce to 0..1.
-        result.credibility_for_question = num > 1 ? num / 100 : num;
-      }
-    } else if (lower.startsWith('bias')) {
-      current = 'bias_to_watch';
-      result.bias_to_watch = line.slice(line.indexOf(':') + 1).trim();
-    } else if (current === 'expertise') {
-      result.expertise += (result.expertise ? '\n' : '') + line;
-    } else if (current === 'personality') {
-      result.personality += (result.personality ? '\n' : '') + line;
-    } else if (current === 'bias_to_watch') {
-      result.bias_to_watch += (result.bias_to_watch ? '\n' : '') + line;
-    }
-  }
-  // Clamp credibility into the valid range.
-  if (Number.isNaN(result.credibility_for_question)) {
-    result.credibility_for_question = 0.55;
-  }
-  result.credibility_for_question = Math.max(
-    0, Math.min(1, result.credibility_for_question),
-  );
-  return result;
-}

frontend/src/components/RateLimitNotice.js

@@ -0,0 +1,64 @@
+import React from 'react';
+
+const COPY = {
+  one_left: {
+    title: 'One chat remaining today',
+    body: (
+      <>
+        You have one chat left for today. Contact us at{' '}
+        <a href="mailto:info@neon.ai">info@neon.ai</a> if you would like to do
+        more with CCAI.
+      </>
+    ),
+  },
+  exhausted: {
+    title: 'Daily chat limit reached',
+    body: (
+      <>
+        You have used all of your chats for today. Contact us at{' '}
+        <a href="mailto:info@neon.ai">info@neon.ai</a> if you would like to do
+        more with CCAI.
+      </>
+    ),
+  },
+};
+
+/**
+ * Modal notice for anonymous / rate-limited users at 1 chat left or
+ * when they try to start after the daily cap is exhausted.
+ */
+export default function RateLimitNotice({ kind, onClose }) {
+  if (!kind || !COPY[kind]) return null;
+  const { title, body } = COPY[kind];
+
+  return (
+    <div
+      className="ccai-credentials-overlay"
+      role="dialog"
+      aria-modal="true"
+      aria-labelledby="ccai-rate-limit-title"
+      onClick={onClose}
+    >
+      <div
+        className="ccai-credentials-card ccai-rate-limit-card"
+        onClick={(e) => e.stopPropagation()}
+      >
+        <div className="ccai-credentials-header">
+          <div>
+            <h2 id="ccai-rate-limit-title">{title}</h2>
+          </div>
+          <div className="ccai-tab-spacer" />
+          <button type="button" className="modal-close" onClick={onClose} aria-label="Close">
+            &times;
+          </button>
+        </div>
+        <div className="ccai-rate-limit-body">{body}</div>
+        <div className="ccai-rate-limit-actions">
+          <button type="button" className="btn-primary" onClick={onClose}>
+            OK
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/styles/ccai.css

@@ -569,7 +569,7 @@
 
 /* ── Credential Summary modal ──────────────────────────────────────
    Surfaces the orchestrator's per-participant assessment built after
-   Phase 1 and refreshed after Phase 2 critique. Reuses the table
+   Phase 1 (concurrent per participant). Reuses the table
    modal's overlay/card chrome for visual consistency.
    ──────────────────────────────────────────────────────────────── */
 
@@ -617,6 +617,33 @@
   max-width: 560px;
 }
 
+.ccai-rate-limit-card {
+  width: min(480px, 92vw);
+}
+
+.ccai-rate-limit-body {
+  padding: 16px 20px;
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--text-secondary);
+}
+
+.ccai-rate-limit-body a {
+  color: var(--accent-primary);
+  text-decoration: none;
+}
+
+.ccai-rate-limit-body a:hover {
+  text-decoration: underline;
+}
+
+.ccai-rate-limit-actions {
+  display: flex;
+  justify-content: flex-end;
+  padding: 12px 20px 16px;
+  border-top: 1px solid var(--border-primary);
+}
+
 .ccai-credentials-question {
   margin: 0 20px;
   padding: 10px 12px;

frontend/src/styles/components.css

@@ -1144,6 +1144,10 @@
   color: var(--text-primary);
 }
 
+.auth-badge-end {
+  margin-left: 4px;
+}
+
 /* ── Footer ─────────────────────────────────────────────────────── */
 
 .app-footer {

frontend/src/utils/api.js

@@ -310,6 +310,32 @@ export async function patchHumanCredential(sessionId, patch) {
  * first question or (rarely) a final summary if the LLM bails. The
  * draft_id is needed for subsequent /answer calls.
  */
+/**
+ * Generate a structured credential summary from a human's freeform
+ * profile text (experience, personality, etc.). Uses the orchestrator
+ * the same way it assesses an LLM participant's role prompt.
+ */
+export async function generateHumanCredentialFromProfile({
+  name, question, profile_text, participant_id, orchestrator_model_id,
+}) {
+  const resp = await fetch(`${API_BASE}/api/chat/credentials/from-profile`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      name,
+      question,
+      profile_text,
+      participant_id: participant_id || '',
+      orchestrator_model_id: orchestrator_model_id || null,
+    }),
+  });
+  if (!resp.ok) {
+    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+    throw new Error(err.detail || 'Credential generation failed');
+  }
+  return resp.json();
+}
+
 export async function startCredentialDraft({
   name, question, max_questions = 6, orchestrator_model_id = null,
 }) {

frontend/src/utils/storage.js

@@ -30,7 +30,8 @@ const DEFAULTS = {
   auto_select_mode: false,
   // In-the-loop human participant. null when no human is configured.
   // Shape when set:
-  //   { participant_id, name, credential_summary: {
+  //   { participant_id, name, profile_text,
+  //     credential_summary: {
   //       name, expertise, personality,
   //       credibility_for_question, bias_to_watch
   //     } }