Merge pull request #5 from NeonClary/dev-cursor

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.
     """
@@ -354,6 +358,17 @@ async def api_demo_questions():
 # Start chat
 # ---------------------------------------------------------------------------
 
+def _neon_role_prompt_from_model_id(model_id: str) -> str:
+    """Look up a Neon persona's HANA system_prompt from the client cache."""
+    if not model_id.startswith("neon:"):
+        return ""
+    parts = model_id.split(":", 2)
+    if len(parts) != 3:
+        return ""
+    sp = hana_client.get_persona_system_prompt(parts[1], parts[2])
+    return (sp or "").strip()
+
+
 def _build_participant(
     sel: ParticipantSelectionPayload,
     expert_lookup: dict[str, ExpertPersonaPayload],
@@ -410,6 +425,8 @@ def _build_participant(
             )
         if not model_id:
             model_id = pid
+        if not role_prompt:
+            role_prompt = _neon_role_prompt_from_model_id(model_id)
         if not role_prompt:
             role_prompt = (
                 f"You are {name}, a Neon.ai persona. Speak naturally in your "
@@ -435,6 +452,11 @@ def _build_participant(
     else:
         raise HTTPException(400, f"Unknown participant kind: {kind}")
 
+    # When the user assigns a Neon model to a non-Neon persona, surface
+    # that model's HANA persona prompt for inference context.
+    if not role_prompt and model_id.startswith("neon:"):
+        role_prompt = _neon_role_prompt_from_model_id(model_id)
+
     resolved = settings.resolve_model(model_id)
     if not resolved:
         raise HTTPException(400, f"Unknown model: {model_id}")
@@ -480,6 +502,13 @@ async def api_start_chat(req: StartChatRequest, request: Request):
 
     expert_lookup = {ep.participant_id: ep for ep in req.expert_personas}
 
+    # Populate the HANA persona prompt cache so Neon role_prompt
+    # resolution works even if /api/models hasn't been called yet.
+    try:
+        await hana_client.get_models()
+    except Exception as exc:
+        LOG.warning("HANA get_models during chat start failed: %s", exc)
+
     max_p = max(MIN_MAX_PARTICIPANTS, min(MAX_MAX_PARTICIPANTS, req.max_participants))
     if len(req.participants) < 2:
         raise HTTPException(400, "Need at least 2 participants")
@@ -745,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/api/personas.py

@@ -46,11 +46,13 @@ async def get_personas():
             persona_name = p.get("persona_name") or ""
             if _is_vanilla_or_rag(persona_name):
                 continue
+            system_prompt = (p.get("system_prompt") or "").strip()
             raw_neon.append({
                 "model_id": nm["model_id"],
                 "model_short": model_short,
                 "persona_name": persona_name,
                 "description": p.get("description") or "",
+                "role_prompt": system_prompt,
             })
 
     # Pass 2: batch-reformat display names via the orchestrator LLM
@@ -72,6 +74,7 @@ async def get_personas():
             "model_display": r["model_short"],
             "default_model_id": participant_id,
             "description": r["description"],
+            "role_prompt": r.get("role_prompt") or "",
         })
 
     extras = list_extra_personas()

backend/app/clients/llm_router.py

@@ -180,6 +180,9 @@ async def _call_neon_direct_vllm(
         "response": strip_thinking(result.get("response", "")),
         "elapsed_seconds": result.get("elapsed_seconds", 0),
         "model": resolved["model_id"],
+        "error": result.get("error", False),
+        "error_kind": result.get("error_kind", ""),
+        "error_status": result.get("error_status"),
     }
 
 

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/context_budget.py

@@ -175,6 +175,87 @@ def build_compressed_messages(
     return head + [summary_msg] + tail
 
 
+# ---------------------------------------------------------------------------
+# Compress transcript embedded inside a single user prompt (CCAI pattern)
+# ---------------------------------------------------------------------------
+#
+# Phase prompts bake the full transcript into one user message, e.g.
+# "Conversation so far:\n{transcript}\n\nIn 4-8 sentences:…". The AskJerry
+# multi-message trim path never fires because api_messages only has
+# [system, user]. These helpers swap the transcript body for summary+tail.
+
+_TRANSCRIPT_HEADERS: tuple[str, ...] = (
+    "Conversation so far:\n",
+    "Full conversation so far:\n",
+    "Full transcript:\n",
+    "Full conversation:\n",
+)
+
+# Section headers that typically follow the transcript block in phase prompts.
+_TRANSCRIPT_FOOTERS: tuple[str, ...] = (
+    "\n\nOpen threads",
+    "\n\nIn ",
+    "\n\nFIRST",
+    "\n\nThe orchestrator",
+    "\n\nRight now",
+    "\n\nPhase ",
+    "\n\nQuestion:\n",
+    "\n\nCredential Summary:\n",
+    "\n\nBelow is",
+    "\n\nTargeted question:\n",
+)
+
+
+def replace_embedded_transcript(user_prompt: str, new_transcript: str) -> str:
+    """Replace the transcript body inside a phase prompt, if a known header exists."""
+    for header in _TRANSCRIPT_HEADERS:
+        idx = user_prompt.find(header)
+        if idx < 0:
+            continue
+        start = idx + len(header)
+        rest = user_prompt[start:]
+        end = len(rest)
+        for footer in _TRANSCRIPT_FOOTERS:
+            pos = rest.find(footer)
+            if pos >= 0:
+                end = min(end, pos)
+        return user_prompt[:start] + new_transcript + rest[end:]
+    return user_prompt
+
+
+def build_compressed_transcript_block(
+    summary: ContextSummary,
+    recent_transcript: str,
+) -> str:
+    """AskJerry-style block: running summary + recent tail."""
+    recent = (recent_transcript or "").strip()
+    if summary.is_active():
+        body = (
+            "[Earlier discussion summary]\n"
+            + summary.summary_text.strip()
+        )
+        if recent:
+            body += "\n\n[Recent messages]\n" + recent
+        return body
+    if recent:
+        return "[Recent messages — auto-trimmed for context]\n" + recent
+    return ""
+
+
+def cap_max_tokens_for_window(
+    model_id: str,
+    api_messages: list[dict[str, Any]],
+    requested_max_tokens: int,
+) -> int:
+    """Shrink reply budget so input + output fits the model window (AskJerry)."""
+    window = context_window_for(model_id)
+    est = estimate_messages_tokens(api_messages)
+    headroom = window - est - 64
+    if headroom < 256:
+        return max(64, min(requested_max_tokens, headroom))
+    return min(requested_max_tokens, headroom)
+
+
 # ---------------------------------------------------------------------------
 # Run a summarize call against the configured summarizer model
 # ---------------------------------------------------------------------------

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
@@ -43,17 +43,19 @@ from app.services.context_budget import (
     ContextSummary,
     DEFAULT_REPLY_BUDGET,
     KEEP_RECENT_MESSAGES,
-    build_compressed_messages,
+    build_compressed_transcript_block,
+    cap_max_tokens_for_window,
     context_window_for,
     estimate_messages_tokens,
+    replace_embedded_transcript,
     run_summarize,
     select_summarizer_model_id,
     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 (
@@ -61,6 +63,7 @@ from app.services.orchestrator_speed import (
     _AiTurnSpec,
     compact_transcript_for_orchestrator,
     orchestrator_fast_model_id,
+    run_initial_opinions_roster,
     run_roster_ai_turns_parallel,
 )
 from app.services.resilience import run_resilient_turn
@@ -298,7 +301,8 @@ async def _wait_for_continue(
     else:
         session.orchestrator_call_cap += bump_inc
     session.pause_reason = None
-    yield _sse("status", {"message": "Resuming conversation..."})
+    for chunk in _orchestrator_banner_sse(session, "Resuming conversation..."):
+        yield chunk
 
 
 # ---------------------------------------------------------------------------
@@ -546,13 +550,38 @@ async def _call_participant(
 
     await _maybe_summarize_for_participant(session, participant, api_messages)
 
-    needs_sum, needs_trim, _ = should_summarize(
+    needs_sum, needs_trim, input_budget = should_summarize(
         participant.model_id, api_messages, participant.summary,
     )
-    if needs_trim:
-        api_messages = build_compressed_messages(
-            api_messages, participant.summary, needs_trim,
+
+    # CCAI embeds the transcript inside the user prompt. When over budget,
+    # swap that block for summary + recent tail (AskJerry pattern).
+    if needs_sum or needs_trim:
+        recent_transcript = _format_history(
+            session.messages[-KEEP_RECENT_MESSAGES:],
+            include_orchestrator=False,
+        )
+        compressed_block = build_compressed_transcript_block(
+            participant.summary,
+            recent_transcript,
         )
+        if compressed_block:
+            new_prompt = replace_embedded_transcript(user_prompt, compressed_block)
+            user_prompt = new_prompt
+            api_messages[1] = {"role": "user", "content": user_prompt}
+        elif len(user_prompt) > input_budget * 4:
+            # Last-resort: keep prompt head + tail if no transcript header matched.
+            keep = max(512, input_budget * 2)
+            user_prompt = (
+                user_prompt[:keep]
+                + "\n\n[…middle truncated for context…]\n\n"
+                + user_prompt[-keep:]
+            )
+            api_messages[1] = {"role": "user", "content": user_prompt}
+
+    max_tokens = cap_max_tokens_for_window(
+        participant.model_id, api_messages, max_tokens,
+    )
 
     resolved = {
         "model_id": participant.model_id,
@@ -699,13 +728,154 @@ def _msg_payload(msg: dict[str, Any]) -> dict[str, Any]:
     return msg
 
 
+def _orchestrator_banner_sse(
+    session: Session,
+    text: str,
+    *,
+    kind: str = "status",
+    extra: dict[str, Any] | None = None,
+) -> list[str]:
+    """Append an orchestrator line to the transcript and emit chat + status SSE."""
+    msg = _add_orchestrator_message(session, text, kind=kind, extra=extra)
+    return [
+        _sse("orchestrator", _msg_payload(msg)),
+        _sse("status", {"message": text}),
+    ]
+
+
+def _participant_turn_failure_sse(
+    session: Session,
+    participant: Participant,
+) -> list[str]:
+    """Emit participant_error and auto-disable banner when threshold hit."""
+    out = [
+        _sse("participant_error", {
+            "participant_id": participant.participant_id,
+            "name": participant.name,
+            "phase": session.phase.value,
+        }),
+    ]
+    if participant.consecutive_failures >= session.limits.auto_disable_failures:
+        participant.enabled = False
+        out.extend(_orchestrator_banner_sse(
+            session,
+            f"{participant.name} auto-disabled after "
+            f"{session.limits.auto_disable_failures} consecutive failures.",
+        ))
+    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
 # ---------------------------------------------------------------------------
 
 async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
     session.phase = Phase.INITIAL_OPINIONS
-    yield _sse("status", {"message": "Phase 1: collecting independent first opinions..."})
+    for chunk in _orchestrator_banner_sse(
+        session, "Phase 1: collecting independent first opinions...",
+    ):
+        yield chunk
 
     actives = _active_participants(session)
 
@@ -721,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:
@@ -734,10 +908,9 @@ async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
             max_tokens=700,
         )
 
-    async for chunk in run_roster_ai_turns_parallel(
+    async for chunk in run_initial_opinions_roster(
         session,
         actives,
-        phase=session.phase,
         build_spec=_build_initial_spec,
         call_participant=_call_participant,
         on_human_turn=_human_initial,
@@ -745,20 +918,9 @@ async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
     ):
         yield chunk
 
-    yield _sse("status", {"message": "Building Credential Summary..."})
-    creds = await build_credential_summary(
-        orchestrator_model_id=_orchestrator_model_id(session),
-        question=session.question,
-        participants=_active_participants(session),
-        initial_opinions=session.initial_opinions,
-        api_log=session.api_log,
-        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,
@@ -784,9 +946,11 @@ def _critique_phase_for(round_number: int) -> Phase:
 async def _phase_critique(session: Session, round_number: int) -> AsyncIterator[str]:
     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 {round_total}...",
-    })
+    for chunk in _orchestrator_banner_sse(
+        session,
+        f"Phase 2: critique round {round_number} of {round_total}...",
+    ):
+        yield chunk
     cred_block = credentials_to_block(session.credential_summary)
     actives = _active_participants(session)
     # Freeze transcript + pending threads at round start so parallel
@@ -859,10 +1023,12 @@ async def _phase_critique(session: Session, round_number: int) -> AsyncIterator[
 
 async def _phase_status_assessment(session: Session) -> AsyncIterator[str]:
     session.phase = Phase.STATUS_ASSESSMENT
-    yield _sse("status", {"message": "Phase 3: assessing whether more questions are needed..."})
+    for chunk in _orchestrator_banner_sse(
+        session, "Phase 3: assessing whether more questions are needed...",
+    ):
+        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
@@ -900,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:
@@ -996,10 +1141,8 @@ async def _phase_status_assessment(session: Session) -> AsyncIterator[str]:
             for ev in turn.sse_events:
                 yield ev
             if not turn.ok:
-                yield _sse("participant_error", {
-                    "participant_id": target.participant_id, "name": target.name,
-                    "phase": session.phase.value,
-                })
+                for chunk in _participant_turn_failure_sse(session, target):
+                    yield chunk
                 continue
             speaker = turn.speaker
             text, elapsed = turn.text, turn.elapsed
@@ -1031,7 +1174,8 @@ async def _phase_status_assessment(session: Session) -> AsyncIterator[str]:
 
 async def _phase_finalization(session: Session) -> AsyncIterator[str]:
     session.phase = Phase.FINALIZATION
-    yield _sse("status", {"message": "Phase 4: opinion finalization..."})
+    for chunk in _orchestrator_banner_sse(session, "Phase 4: opinion finalization..."):
+        yield chunk
 
     cred_block = credentials_to_block(session.credential_summary)
     actives = _active_participants(session)
@@ -1089,7 +1233,8 @@ async def _phase_finalization(session: Session) -> AsyncIterator[str]:
 
 async def _phase_consensus(session: Session) -> AsyncIterator[str]:
     session.phase = Phase.CONSENSUS
-    yield _sse("status", {"message": "Phase 5: consensus gathering..."})
+    for chunk in _orchestrator_banner_sse(session, "Phase 5: consensus gathering..."):
+        yield chunk
 
     cred_block = credentials_to_block(session.credential_summary)
     actives = _active_participants(session)
@@ -1108,7 +1253,12 @@ async def _phase_consensus(session: Session) -> AsyncIterator[str]:
     # Render alliance group members using the same display names shown
     # in the sidebar (Participant.name), not raw participant_ids.
     id_to_name = {p.participant_id: p.name for p in actives}
-    announce = "Alliance groups detected: " + "; ".join(
+    alliance_prefix = (
+        "Updated alliance groups detected: "
+        if session.consensus_attempts > 0
+        else "Alliance groups detected: "
+    )
+    announce = alliance_prefix + "; ".join(
         f"\"{g.get('stance', '')}\" -> ["
         + ", ".join(
             id_to_name.get(m, m) for m in (g.get("members") or [])
@@ -1139,6 +1289,10 @@ async def _phase_consensus(session: Session) -> AsyncIterator[str]:
 
     while consensus_turns < max_consensus_turns:
         consensus_turns += 1
+        actives = _active_participants(session)
+        if len(actives) < 2:
+            break
+        queue = [p for p in queue if p.enabled]
 
         # Pick speaker. Prefer the addressed-to target (dyadic exchange)
         # only while we're under the consecutive-routing cap. Once the
@@ -1216,10 +1370,8 @@ async def _phase_consensus(session: Session) -> AsyncIterator[str]:
         for ev in turn.sse_events:
             yield ev
         if not turn.ok:
-            yield _sse("participant_error", {
-                "participant_id": speaker.participant_id, "name": speaker.name,
-                "phase": session.phase.value,
-            })
+            for chunk in _participant_turn_failure_sse(session, speaker):
+                yield chunk
             continue
         # Consensus phase doesn't swap participants, only LLMs behind
         # them, so turn.speaker is the same instance as `speaker`. Use
@@ -1394,7 +1546,8 @@ def _build_consensus_prompt(
 
 async def _phase_closure(session: Session) -> AsyncIterator[str]:
     session.phase = Phase.CLOSURE
-    yield _sse("status", {"message": "Phase 6: closure..."})
+    for chunk in _orchestrator_banner_sse(session, "Phase 6: closure..."):
+        yield chunk
 
     cred_block = credentials_to_block(session.credential_summary)
     transcript = await compact_transcript_for_orchestrator(

backend/app/services/orchestrator_speed.py

@@ -177,6 +177,7 @@ async def run_roster_ai_turns_parallel(
     from app.services.orchestrator import (
         _msg_payload,
         _participant_msg_cap_hit,
+        _participant_turn_failure_sse,
         _sse,
         _wait_for_continue,
     )
@@ -237,6 +238,104 @@ async def run_roster_ai_turns_parallel(
         yield chunk
 
 
+async def run_initial_opinions_roster(
+    session: "Session",
+    actives: list["Participant"],
+    *,
+    build_spec: Callable[["Participant"], _AiTurnSpec | None],
+    call_participant: CallParticipantFn,
+    on_human_turn: Callable[
+        ["Participant"],
+        AsyncIterator[str],
+    ],
+    post_process: PostProcessFn | None = None,
+) -> AsyncIterator[str]:
+    """Phase-1 roster walk with human-aware AI prefetch.
+
+    When a human is in the roster, every AI participant's initial-
+    opinion call is fired immediately (in parallel) so answers are ready
+    while the human types. SSE ``message`` events are still emitted in
+    roster order: any LLMs listed before the human appear as soon as
+    their prefetch completes, and LLMs after the human stay hidden until
+    the human submits (or skips).
+    """
+    from app.services.models import Phase
+    from app.services.orchestrator import (
+        _participant_msg_cap_hit,
+        _sse,
+        _wait_for_continue,
+    )
+
+    phase = Phase.INITIAL_OPINIONS
+    has_human = any(p.kind == "human" for p in actives)
+    if not has_human:
+        async for chunk in run_roster_ai_turns_parallel(
+            session,
+            actives,
+            phase=phase,
+            build_spec=build_spec,
+            call_participant=call_participant,
+            on_human_turn=on_human_turn,
+            post_process=post_process,
+        ):
+            yield chunk
+        return
+
+    pending: dict[str, asyncio.Task[_AiTurnResult]] = {}
+    for p in actives:
+        if p.kind == "human":
+            continue
+        spec = build_spec(p)
+        if spec is None:
+            continue
+        pending[p.participant_id] = asyncio.create_task(
+            _execute_ai_turn(session, spec, call_participant),
+            name=f"prefetch_initial:{p.participant_id}",
+        )
+
+    for p in actives:
+        if p.kind == "human":
+            async for chunk in on_human_turn(p):
+                yield chunk
+            if _participant_msg_cap_hit(session):
+                async for chunk in _wait_for_continue(session, "messages"):
+                    yield chunk
+            continue
+
+        task = pending.pop(p.participant_id, None)
+        if task is None:
+            continue
+        try:
+            result = await task
+        except BaseException as exc:
+            LOG.exception(
+                "Prefetched initial opinion failed for %s: %s",
+                p.participant_id,
+                exc,
+            )
+            yield _sse("participant_error", {
+                "participant_id": p.participant_id,
+                "name": p.name,
+                "phase": phase.value,
+            })
+            continue
+
+        extra: dict[str, Any] | None = None
+        if post_process is not None:
+            extra = await post_process(result) or {}
+        async for chunk in _emit_ai_turn_result(
+            session, result, phase=phase, extra=extra,
+        ):
+            yield chunk
+        if _participant_msg_cap_hit(session):
+            async for chunk in _wait_for_continue(session, "messages"):
+                yield chunk
+
+    for pid, task in pending.items():
+        if not task.done():
+            task.cancel()
+
+
 async def _emit_ai_turn_result(
     session: "Session",
     result: _AiTurnResult,
@@ -249,6 +348,7 @@ async def _emit_ai_turn_result(
         _add_participant_message,
         _msg_payload,
         _orchestrator_cap_hit,
+        _participant_turn_failure_sse,
         _replying_to_ids,
         _sse,
         _wait_for_continue,
@@ -256,22 +356,14 @@ 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:
-        yield _sse("participant_error", {
-            "participant_id": p.participant_id,
-            "name": p.name,
-            "phase": phase.value,
-        })
-        if p.consecutive_failures >= session.limits.auto_disable_failures:
-            p.enabled = False
-            yield _sse("status", {
-                "message": (
-                    f"{p.name} auto-disabled after "
-                    f"{session.limits.auto_disable_failures} failures."
-                ),
-            })
+        for chunk in _participant_turn_failure_sse(session, p):
+            yield chunk
         return
 
     speaker = turn.speaker
@@ -291,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/public/index.html

@@ -5,8 +5,8 @@
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <link rel="icon" type="image/png" href="/neon-logo.png" />
   <meta name="theme-color" content="#6366F1" />
-  <meta name="description" content="Neon.ai - AI to AI Conversations" />
-  <title>Neon.ai - AI to AI Conversations</title>
+  <meta name="description" content="CCAI Demo" />
+  <title>CCAI Demo</title>
 </head>
 <body>
   <div id="root"></div>

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,19 @@ 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). */
+function appendInlineChatNote(setMessages, text, extra = {}) {
+  setMessages(prev => [...prev, {
+    role: 'system',
+    text,
+    timestamp: Date.now() / 1000,
+    ...extra,
+  }]);
 }
 
 export default function App() {
@@ -149,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(() => {
@@ -186,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 = [];
@@ -207,6 +232,20 @@ export default function App() {
     return list;
   }, [providers, neonModels]);
 
+  // Map neon:model@ver:persona ids -> HANA system_prompt (from /api/models).
+  const neonPromptByModelId = useMemo(() => {
+    const map = {};
+    for (const nm of neonModels) {
+      for (const p of (nm.personas || [])) {
+        if (p.enabled === false) continue;
+        const id = `neon:${nm.model_id}:${p.persona_name}`;
+        const sp = (p.system_prompt || '').trim();
+        if (sp) map[id] = sp;
+      }
+    }
+    return map;
+  }, [neonModels]);
+
   // ─── Active participants resolved from selectedIds ──────────────
   const allCatalogParticipants = useMemo(() => {
     const map = {};
@@ -340,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);
@@ -397,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);
@@ -562,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).
@@ -592,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
@@ -649,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;
@@ -744,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);
@@ -786,9 +917,6 @@ export default function App() {
             )));
           },
           onOrchestrator: (data) => {
-            // Orchestrator events with kind == "status" but no text are
-            // status banners; bubble them into a message-style entry so
-            // they render with the orchestrator pill.
             if (data && data.text) {
               setMessages(prev => [...prev, { ...data, role: 'orchestrator' }]);
             } else if (data?.message) {
@@ -807,39 +935,35 @@ export default function App() {
             setSystemMessages(prev => [...prev, { text: `Error: ${data.message}` }]);
           },
           onParticipantError: (data) => {
-            setSystemMessages(prev => [...prev, {
-              text: `${data.name || 'A participant'} couldn't respond this turn.`,
-            }]);
+            const text = `${data.name || 'A participant'} couldn't respond this turn.`;
+            appendInlineChatNote(setMessages, text, {
+              kind: 'participant_error',
+              phase: data.phase,
+              participant_id: data.participant_id,
+            });
           },
           onParticipantSubstituted: (data) => {
-            // Resilience layer swapped the backing LLM behind a
-            // persona's prompt+name. Surface it as a system note so
-            // the user can reconcile any change in voice / latency
-            // with the chat metadata.
             const name = data.name || 'A participant';
             const toDisplay = data.to_model_display || data.to_model_id || 'a substitute model';
-            setSystemMessages(prev => [...prev, {
-              text: `${name}'s primary model didn't respond; continuing with ${toDisplay}.`,
-            }]);
+            appendInlineChatNote(
+              setMessages,
+              `${name}'s primary model didn't respond; continuing with ${toDisplay}.`,
+              { kind: 'participant_substituted', phase: data.phase },
+            );
           },
           onParticipantReplaced: (data) => {
-            // Phase 1 alternate kicked in. Replace the session
-            // roster snapshot so the sidebar re-renders with the
-            // new participant; also note the change in chat.
             if (Array.isArray(data?.roster)) {
               setSessionParticipants(data.roster);
             }
             const origName = data.original_name || 'A participant';
             const altName = data.new_name || 'an alternate';
-            setSystemMessages(prev => [...prev, {
-              text: `${origName} couldn't give an initial opinion; ${altName} is taking their place.`,
-            }]);
+            appendInlineChatNote(
+              setMessages,
+              `${origName} couldn't give an initial opinion; ${altName} is taking their place.`,
+              { kind: 'participant_replaced', phase: data.phase },
+            );
           },
           onVoteCast: (data) => {
-            // One per-ballot from a vote-based decision method. We
-            // surface these as system notes so the user can follow
-            // the tally as it happens; the final report message will
-            // contain the canonical summary.
             const voter = data?.voter_name || 'A voter';
             let line;
             if (data?.vote) {
@@ -851,16 +975,15 @@ export default function App() {
             } else {
               line = `${voter} abstained or returned an invalid ballot.`;
             }
-            setSystemMessages(prev => [...prev, { text: line }]);
+            appendInlineChatNote(setMessages, line, { kind: 'vote_cast' });
           },
           onVoteTally: (data) => {
-            // Final tally summary. The orchestrator message that
-            // follows contains the rendered report, so we just log
-            // a one-liner here for the system feed.
             const kind = data?.kind || 'vote';
-            setSystemMessages(prev => [...prev, {
-              text: `Vote complete (${kind}); see report below.`,
-            }]);
+            appendInlineChatNote(
+              setMessages,
+              `Vote complete (${kind}); see report below.`,
+              { kind: 'vote_tally' },
+            );
           },
           onFailsafePause: (data) => {
             setPause({ reason: 'messages', ...data });
@@ -913,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.
@@ -948,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}
@@ -999,6 +1112,7 @@ export default function App() {
           participants={selectedParticipants}
           enabledMap={enabledMap}
           modelAssignments={modelAssignments}
+          neonPromptByModelId={neonPromptByModelId}
           onToggleEnabled={handleSidebarToggleEnabled}
           onRemove={handleSidebarRemove}
           autoSelectMode={autoSelectMode}
@@ -1006,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}
@@ -1069,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}
@@ -1088,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/ChatArea.js

@@ -74,8 +74,15 @@ export default function ChatArea({
         </div>
       )}
       {(messages || []).map((msg, i) => {
+        if (msg.role === 'system') {
+          return (
+            <div key={msg.message_id || `sys-inline-${i}`} className="system-message">
+              {msg.text}
+            </div>
+          );
+        }
         if (msg.role === 'orchestrator') {
-          return <OrchestratorMessage key={i} message={msg} messageIdx={i} />;
+          return <OrchestratorMessage key={msg.message_id || i} message={msg} messageIdx={i} />;
         }
         const idx = speakerIdxFor[msg.speaker_id] ?? i;
         const prev = i > 0 ? messages[i - 1] : null;

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/ParticipantSidebar.js

@@ -12,6 +12,7 @@ export default function ParticipantSidebar({
   participants,
   enabledMap,
   modelAssignments,
+  neonPromptByModelId = {},
   onToggleEnabled,
   onRemove,
   autoSelectMode,
@@ -56,6 +57,7 @@ export default function ParticipantSidebar({
             participant={p}
             enabled={enabled}
             modelOverride={modelOverride}
+            neonPromptByModelId={neonPromptByModelId}
             onToggleEnabled={() => onToggleEnabled(p.participant_id, !enabled)}
             onRemove={() => onRemove(p.participant_id)}
           />
@@ -65,10 +67,18 @@ export default function ParticipantSidebar({
   );
 }
 
-function ParticipantCard({ participant, enabled, modelOverride, onToggleEnabled, onRemove }) {
+function ParticipantCard({ participant, enabled, modelOverride, neonPromptByModelId, onToggleEnabled, onRemove }) {
   const [open, setOpen] = useState(false);
   const isHuman = participant.kind === 'human';
 
+  const effectiveModelId = modelOverride
+    || participant.default_model_id
+    || (participant.kind === 'neon' ? participant.participant_id : '');
+  const personaPrompt = (effectiveModelId.startsWith('neon:')
+    && neonPromptByModelId[effectiveModelId])
+    || participant.role_prompt
+    || '';
+
   return (
     <div
       className={
@@ -152,7 +162,7 @@ function ParticipantCard({ participant, enabled, modelOverride, onToggleEnabled,
               <div className="ccai-participant-field">
                 <div className="ccai-participant-field-label">Persona prompt</div>
                 <pre className="ccai-participant-prompt">
-                  {participant.role_prompt || '(no prompt set)'}
+                  {personaPrompt || '(no prompt set)'}
                 </pre>
               </div>
             </>

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

@@ -533,6 +533,7 @@
   border-collapse: collapse;
   font-size: 12px;
   color: var(--text-primary);
+  table-layout: fixed;
 }
 
 .ccai-table th,
@@ -554,6 +555,18 @@
   top: 0;
 }
 
+.ccai-table th:first-child,
+.ccai-table td:first-child {
+  width: 15%;
+}
+
+.ccai-table th:nth-child(n + 2),
+.ccai-table td:nth-child(n + 2) {
+  width: 21.25%;
+  overflow-wrap: break-word;
+  word-wrap: break-word;
+}
+
 .ccai-table-name {
   white-space: nowrap;
   font-weight: 600;
@@ -569,7 +582,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 +630,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
   //     } }