feat: human participant turns + credential intake redesign

Human Participant: new human_io service and HumanInputSlot/HumanParticipantModal/HumanTurnIndicator UI; orchestrator and chat API support human turns; ParticipantSidebar/ChatArea/MessageBubble wiring.

Credential intake: new credential_intake prompt, expanded credential service, redesigned Credential Summary modal, prompt registry entry.

Supporting: App state and routing for human turns + credentials, Header surface, ccai.css styling for new components, api/storage helpers.
Co-authored-by: Cursor <cursoragent@cursor.com>

backend/app/api/chat.py

@@ -19,7 +19,16 @@ from app.middleware.rate_limit import (
     check_rate_limit,
     record_conversation,
 )
+from typing import Any
+
+from app.services import human_io
+from app.services.credential import normalize_one_credential
 from app.services.extra_personas import get_extra_persona
+from app.services.json_calls import orchestrator_call
+from app.services.prompts import (
+    CREDENTIAL_INTAKE_EMPTY_TRANSCRIPT,
+    CREDENTIAL_INTAKE_TURN_PROMPT,
+)
 from app.services.models import (
     CONVERSATION_LIMIT_BOUNDS,
     CONVERSATION_LIMIT_DESCRIPTIONS,
@@ -120,6 +129,21 @@ class AutoSelectRequest(BaseModel):
     orchestrator_model_id: str | None = None
 
 
+class HumanCredentialPayload(BaseModel):
+    """User-authored credential summary for the in-the-loop human.
+
+    The orchestrator prepends this entry to the LLM-built credential
+    summary so the human always appears first in the modal / exports.
+    """
+
+    participant_id: str
+    name: str
+    expertise: str = ""
+    personality: str = ""
+    credibility_for_question: float = 0.5
+    bias_to_watch: str = ""
+
+
 class StartChatRequest(BaseModel):
     question: str | None = None
 
@@ -135,6 +159,10 @@ class StartChatRequest(BaseModel):
     # silently clamped to the server-side default; see
     # `clamp_conversation_limits` in services.models.
     limits: dict[str, int] | None = None
+    # Optional in-the-loop human participant's pre-authored credential
+    # summary. Must reference a participant in the `participants` list
+    # that has kind == "human". Capped at one human per session.
+    human_credential: HumanCredentialPayload | None = None
 
 
 # ---------------------------------------------------------------------------
@@ -355,6 +383,23 @@ def _build_participant(
                 f"You are {name}, a Neon.ai persona. Speak naturally in your "
                 "own voice and bring the perspective your background suggests."
             )
+    elif kind == "human":
+        # Human participants don't use an LLM at all; the orchestrator
+        # pauses for their typed input. They still need a participant
+        # row so the rest of the state machine (credential summary,
+        # alliance detection, addressed-to routing, etc.) can refer to
+        # them by id and name.
+        if not name:
+            raise HTTPException(400, "Human participant requires a name")
+        return Participant(
+            participant_id=pid,
+            name=name,
+            role_prompt="",
+            model_id="",
+            kind="human",
+            enabled=True,
+            display_name="Human participant",
+        )
     else:
         raise HTTPException(400, f"Unknown participant kind: {kind}")
 
@@ -415,6 +460,20 @@ async def api_start_chat(req: StartChatRequest, request: Request):
     for sel in req.participants:
         participants.append(_build_participant(sel, expert_lookup, req.model_assignments))
 
+    humans = [p for p in participants if p.kind == "human"]
+    if len(humans) > 1:
+        raise HTTPException(400, "Only one human participant is supported per session.")
+    if humans and req.human_credential is None:
+        raise HTTPException(
+            400,
+            "Human participant requires a human_credential payload.",
+        )
+    if humans and req.human_credential.participant_id != humans[0].participant_id:
+        raise HTTPException(
+            400,
+            "human_credential.participant_id must match the human participant.",
+        )
+
     record_conversation(request)
 
     session = create_session()
@@ -429,6 +488,16 @@ async def api_start_chat(req: StartChatRequest, request: Request):
     session.limits = clamp_conversation_limits(req.limits)
     session.participant_message_cap = session.limits.participant_message_pause_at
     session.orchestrator_call_cap = session.limits.orchestrator_call_pause_at
+    if humans and req.human_credential is not None:
+        session.human_credential = normalize_one_credential({
+            "participant_id": req.human_credential.participant_id,
+            "name": req.human_credential.name,
+            "expertise": req.human_credential.expertise,
+            "personality": req.human_credential.personality,
+            "credibility_for_question": req.human_credential.credibility_for_question,
+            "bias_to_watch": req.human_credential.bias_to_watch,
+            "is_human": True,
+        })
 
     async def event_stream():
         yield (
@@ -467,6 +536,286 @@ async def api_continue(session_id: str, reason: str = "messages"):
     return {"ok": True, "reason": reason}
 
 
+# ---------------------------------------------------------------------------
+# Human participant: turn response + credential intake Q&A
+# ---------------------------------------------------------------------------
+
+class HumanResponseRequest(BaseModel):
+    """POST body for the human's response to a pending turn.
+
+    `skip` flips this turn into a "declined to comment" note from the
+    orchestrator rather than a participant message; `text` is ignored
+    when skip is true.
+    """
+
+    text: str = ""
+    skip: bool = False
+
+
+@router.post("/chat/{session_id}/human-response")
+async def api_human_response(session_id: str, req: HumanResponseRequest):
+    """Deliver the human participant's text for the current pending
+    turn. Wakes the orchestrator coroutine waiting on the
+    `human_io` slot for this session."""
+    session = get_session(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    if session.awaiting_human is None:
+        raise HTTPException(409, "Session is not awaiting a human turn")
+    if not req.skip and not (req.text or "").strip():
+        raise HTTPException(400, "text is required unless skip is true")
+    delivered = human_io.deliver_human_response(
+        session_id, req.text, skip=req.skip,
+    )
+    if not delivered:
+        raise HTTPException(409, "No pending human turn for this session")
+    return {"ok": True, "skipped": req.skip}
+
+
+class HumanCredentialEditRequest(BaseModel):
+    """PATCH body for editing the human's credential summary mid-chat."""
+
+    name: str | None = None
+    expertise: str | None = None
+    personality: str | None = None
+    credibility_for_question: float | None = None
+    bias_to_watch: str | None = None
+
+
+@router.patch("/chat/{session_id}/credentials/human")
+async def api_edit_human_credential(
+    session_id: str,
+    req: HumanCredentialEditRequest,
+):
+    """Update the human participant's credential summary in place.
+
+    The View Credential Summary modal lets the user tweak the human's
+    entry (name, expertise, style, credibility, bias). Only fields
+    provided in the body are changed; others are left as-is. The
+    updated entry is reflected in subsequent participant prompts (the
+    credentials_to_block call rebuilds the prompt block each turn).
+    """
+    session = get_session(session_id)
+    if not session:
+        raise HTTPException(404, "Session not found")
+    if session.human_credential is None:
+        raise HTTPException(404, "Session has no human participant")
+
+    updated = dict(session.human_credential)
+    for field_name in (
+        "name", "expertise", "personality",
+        "credibility_for_question", "bias_to_watch",
+    ):
+        value = getattr(req, field_name)
+        if value is not None:
+            updated[field_name] = value
+    updated["is_human"] = True
+    updated = normalize_one_credential(updated)
+    session.human_credential = updated
+
+    # Also patch the entry inside session.credential_summary so the
+    # View Credential Summary modal reflects the edit without waiting
+    # for the next phase-refresh.
+    for i, c in enumerate(session.credential_summary or []):
+        if c.get("participant_id") == updated["participant_id"]:
+            session.credential_summary[i] = updated
+            break
+
+    return {"ok": True, "credential": updated}
+
+
+# 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
+# transient (lifetime = a few seconds of Q&A in the modal) so we don't
+# bother persisting them; the registry is cleared by the API when the
+# draft is finalized or abandoned.
+_credential_drafts: dict[str, dict[str, Any]] = {}
+
+
+class CredentialDraftStartRequest(BaseModel):
+    """Body for POST /api/chat/credentials/draft - kicks off a Q&A."""
+
+    name: str
+    question: str
+    max_questions: int = 6
+    orchestrator_model_id: str | None = None
+
+
+class CredentialDraftAnswerRequest(BaseModel):
+    """Body for POST /api/chat/credentials/draft/{draft_id}/answer."""
+
+    answer: str = ""
+
+
+def _intake_transcript(history: list[dict[str, str]]) -> str:
+    """Render the Q&A history into a transcript snippet for the prompt.
+
+    Each entry of history is {"q": "...", "a": "..."}. The last entry
+    may have only "q" (the question the user is currently answering)
+    when called BEFORE the first answer, but in practice we render
+    history only after the LLM has emitted a question and the user has
+    answered, so both keys are present.
+    """
+    if not history:
+        return CREDENTIAL_INTAKE_EMPTY_TRANSCRIPT
+    lines: list[str] = []
+    for i, qa in enumerate(history, start=1):
+        q = (qa.get("q") or "").strip()
+        a = (qa.get("a") or "").strip()
+        lines.append(f"Q{i}: {q}")
+        lines.append(f"A{i}: {a}" if a else f"A{i}: (no answer yet)")
+    return "\n".join(lines)
+
+
+async def _intake_turn(draft: dict[str, Any]) -> dict[str, Any]:
+    """Run one orchestrator turn for the credential intake Q&A.
+
+    Returns either {"kind": "question", "text": ...} or
+    {"kind": "summary", "summary": {...}} as parsed from the
+    orchestrator's JSON output. Falls back to a safe default question
+    if parsing fails.
+    """
+    transcript = _intake_transcript(draft["history"])
+    prompt = CREDENTIAL_INTAKE_TURN_PROMPT.format(
+        name=draft["name"],
+        question=draft["question"],
+        max_questions=draft["max_questions"],
+        questions_asked=draft["questions_asked"],
+        transcript=transcript,
+    )
+    _raw, parsed = await orchestrator_call(
+        orchestrator_model_id=draft["orchestrator_model_id"],
+        user_prompt=prompt,
+        label="credential_intake",
+        api_log=draft.get("api_log"),
+        max_tokens=512,
+    )
+
+    if isinstance(parsed, dict):
+        kind = parsed.get("kind")
+        if kind == "summary" and isinstance(parsed.get("summary"), dict):
+            return {"kind": "summary", "summary": parsed["summary"]}
+        if kind == "question" and isinstance(parsed.get("text"), str):
+            return {"kind": "question", "text": parsed["text"].strip()}
+
+    # Defensive fallback: if the model returned garbage, ask a sensible
+    # next-question rather than crashing the modal.
+    if draft["questions_asked"] >= draft["max_questions"]:
+        return {
+            "kind": "summary",
+            "summary": {
+                "name": draft["name"],
+                "expertise": "(intake LLM did not return a summary)",
+                "personality": "",
+                "credibility_for_question": 0.5,
+                "bias_to_watch": "",
+            },
+        }
+    return {
+        "kind": "question",
+        "text": (
+            "Could you tell me a bit about your background relevant to "
+            f'this question: "{draft["question"]}"?'
+        ),
+    }
+
+
+@router.post("/chat/credentials/draft")
+async def api_credential_draft_start(req: CredentialDraftStartRequest):
+    """Kick off a new credential-intake Q&A. Returns the draft id plus
+    the LLM's first question (or, if it bailed immediately, a final
+    summary)."""
+    if not req.name.strip():
+        raise HTTPException(400, "name is required")
+    if not req.question.strip():
+        raise HTTPException(400, "question is required")
+    max_q = max(1, min(10, int(req.max_questions or 6)))
+
+    import uuid as _uuid
+    draft_id = str(_uuid.uuid4())
+    draft: dict[str, Any] = {
+        "draft_id": draft_id,
+        "name": req.name.strip(),
+        "question": req.question.strip(),
+        "max_questions": max_q,
+        "questions_asked": 0,
+        "history": [],
+        "orchestrator_model_id": (
+            req.orchestrator_model_id or settings.orchestrator_model
+        ),
+        "api_log": [],
+    }
+
+    result = await _intake_turn(draft)
+    if result["kind"] == "question":
+        draft["questions_asked"] += 1
+        draft["history"].append({"q": result["text"], "a": ""})
+        _credential_drafts[draft_id] = draft
+        return {
+            "draft_id": draft_id,
+            "kind": "question",
+            "question": result["text"],
+            "questions_asked": draft["questions_asked"],
+            "max_questions": max_q,
+        }
+
+    # The intake LLM jumped straight to a summary (no answers needed).
+    return {
+        "draft_id": draft_id,
+        "kind": "summary",
+        "summary": result["summary"],
+        "questions_asked": 0,
+        "max_questions": max_q,
+    }
+
+
+@router.post("/chat/credentials/draft/{draft_id}/answer")
+async def api_credential_draft_answer(
+    draft_id: str,
+    req: CredentialDraftAnswerRequest,
+):
+    """Submit the human's answer to the last question; receive either
+    the LLM's next question or the final credential summary."""
+    draft = _credential_drafts.get(draft_id)
+    if draft is None:
+        raise HTTPException(404, "Draft not found or already finalized")
+    if not draft["history"]:
+        raise HTTPException(409, "Draft has no pending question to answer")
+    # Stamp the answer onto the last question.
+    draft["history"][-1]["a"] = (req.answer or "").strip()
+
+    result = await _intake_turn(draft)
+    if result["kind"] == "question":
+        draft["questions_asked"] += 1
+        draft["history"].append({"q": result["text"], "a": ""})
+        return {
+            "draft_id": draft_id,
+            "kind": "question",
+            "question": result["text"],
+            "questions_asked": draft["questions_asked"],
+            "max_questions": draft["max_questions"],
+        }
+
+    # Final summary; clear the draft from the registry.
+    _credential_drafts.pop(draft_id, None)
+    return {
+        "draft_id": draft_id,
+        "kind": "summary",
+        "summary": result["summary"],
+        "questions_asked": draft["questions_asked"],
+        "max_questions": draft["max_questions"],
+    }
+
+
+@router.delete("/chat/credentials/draft/{draft_id}")
+async def api_credential_draft_cancel(draft_id: str):
+    """User abandoned the AI Q&A (e.g. closed the modal). No-op if
+    already gone."""
+    _credential_drafts.pop(draft_id, None)
+    return {"ok": True}
+
+
 # ---------------------------------------------------------------------------
 # Exports
 # ---------------------------------------------------------------------------

backend/app/services/credential.py

@@ -64,26 +64,40 @@ async def build_credential_summary(
     participants: list[Any],
     initial_opinions: dict[str, str],
     api_log: list[dict[str, Any]] | None = None,
+    human_credential: dict[str, Any] | None = None,
 ) -> list[dict[str, Any]]:
-    """Build the Credential Summary list. Returns an empty list on parse failure."""
-    block = _format_participants_block(participants, initial_opinions)
-    prompt = CREDENTIAL_BUILD_PROMPT.format(
-        question=question,
-        participants_block=block,
-    )
-    _raw, parsed = await orchestrator_call(
-        orchestrator_model_id=orchestrator_model_id,
-        user_prompt=prompt,
-        label="build_credentials",
-        api_log=api_log,
-        max_tokens=2048,
-    )
+    """Build the Credential Summary list. Returns an empty list on parse failure.
 
-    creds: list[dict[str, Any]] = []
-    if isinstance(parsed, dict) and isinstance(parsed.get("credentials"), list):
-        creds = parsed["credentials"]
+    Human participants (kind == "human") are NOT sent to the LLM - the
+    user already authored their own credential summary 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
+    isn't asked to fabricate facts about a person.
+    """
+    llm_participants = [p for p in participants if getattr(p, "kind", "") != "human"]
 
-    creds = _normalize_creds(creds, participants)
+    creds: list[dict[str, Any]] = []
+    if llm_participants:
+        block = _format_participants_block(llm_participants, initial_opinions)
+        prompt = CREDENTIAL_BUILD_PROMPT.format(
+            question=question,
+            participants_block=block,
+        )
+        _raw, parsed = await orchestrator_call(
+            orchestrator_model_id=orchestrator_model_id,
+            user_prompt=prompt,
+            label="build_credentials",
+            api_log=api_log,
+            max_tokens=2048,
+        )
+
+        if isinstance(parsed, dict) and isinstance(parsed.get("credentials"), list):
+            creds = parsed["credentials"]
+
+    creds = _normalize_creds(creds, llm_participants)
+    if human_credential:
+        creds = [normalize_one_credential(human_credential)] + creds
     return creds
 
 
@@ -96,12 +110,26 @@ async def refresh_credential_summary(
     critique_transcript: str,
     api_log: list[dict[str, Any]] | None = None,
 ) -> list[dict[str, Any]]:
-    """Refresh the Credential Summary after Phase 2 critique."""
+    """Refresh the Credential Summary after Phase 2 critique.
+
+    Human entries (kind == "human") are passed through verbatim - we
+    don't ask the LLM to second-guess the user's self-description. The
+    LLM only refreshes credentials for LLM participants.
+    """
     if not existing:
         return existing
+
+    human_pids = {p.participant_id for p in participants if getattr(p, "kind", "") == "human"}
+    human_entries = [c for c in existing if c.get("participant_id") in human_pids]
+    llm_entries = [c for c in existing if c.get("participant_id") not in human_pids]
+    llm_participants = [p for p in participants if getattr(p, "kind", "") != "human"]
+
+    if not llm_entries:
+        return existing
+
     prompt = CREDENTIAL_REFRESH_PROMPT.format(
         question=question,
-        credential_summary_json=json.dumps({"credentials": existing}, indent=2),
+        credential_summary_json=json.dumps({"credentials": llm_entries}, indent=2),
         critique_transcript=critique_transcript,
     )
     _raw, parsed = await orchestrator_call(
@@ -112,10 +140,30 @@ async def refresh_credential_summary(
         max_tokens=2048,
     )
     if isinstance(parsed, dict) and isinstance(parsed.get("credentials"), list):
-        return _normalize_creds(parsed["credentials"], participants)
+        refreshed_llm = _normalize_creds(parsed["credentials"], llm_participants)
+        return human_entries + refreshed_llm
     return existing
 
 
+def normalize_one_credential(c: dict[str, Any]) -> dict[str, Any]:
+    """Clamp credibility to [0, 1] and ensure required keys exist on a
+    single credential dict. Used for human-authored entries that bypass
+    the LLM-side _normalize_creds roster pass."""
+    try:
+        score = float(c.get("credibility_for_question", 0.5))
+    except Exception:
+        score = 0.5
+    return {
+        "participant_id": c.get("participant_id") or c.get("id") or "",
+        "name": c.get("name", ""),
+        "expertise": c.get("expertise", ""),
+        "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)),
+    }
+
+
 def _normalize_creds(
     creds: list[dict[str, Any]],
     participants: list[Any],

backend/app/services/human_io.py

@@ -0,0 +1,109 @@
+"""Human-participant I/O coordination.
+
+Bridges the streaming SSE orchestrator to the asynchronous HTTP flow
+where a human submits their response via POST. Mirrors the shape of
+the existing failsafe pause:
+
+  1. Orchestrator reaches a turn for a human participant.
+  2. It populates `session.awaiting_human` and yields a
+     `human_turn_needed` SSE event, then awaits this module's slot.
+  3. The frontend renders the green-bordered input box and a
+     lower-screen "waiting for your input" indicator.
+  4. User clicks Submit (or Skip) -> POST /api/chat/{id}/human-response.
+  5. The API layer calls `deliver_human_response`, which sets the
+     slot's `asyncio.Event` and wakes the orchestrator. Orchestrator
+     yields `human_turn_cleared`, appends the message (or a skip note),
+     and proceeds.
+
+Slot lifetime: lazily created per session_id on first wait, then
+reused turn-after-turn. Cleared via `drop_session` when the session
+ends (currently called from the orchestrator's finally block on
+conversation completion).
+"""
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class HumanTurnSlot:
+    """Per-session waiting-room for a single pending human turn.
+
+    `event` is set by the API layer when the user submits or skips.
+    `response_text` and `skipped` carry the payload across the event.
+    `started_at` is wall-clock time stamped when the orchestrator
+    starts waiting; the orchestrator subtracts it from now() to get
+    `elapsed_seconds` for the message bubble.
+
+    `pending_snapshot` stashes the result of
+    `_pending_addressed_for(session, participant)` at turn-start so the
+    orchestrator can stamp `replying_to` on the eventual message
+    without re-walking the transcript after the user types.
+    """
+
+    event: asyncio.Event = field(default_factory=asyncio.Event)
+    response_text: str = ""
+    skipped: bool = False
+    started_at: float = 0.0
+    pending_snapshot: list[Any] = field(default_factory=list)
+
+
+_slots: dict[str, HumanTurnSlot] = {}
+
+
+def slot_for(session_id: str) -> HumanTurnSlot:
+    """Get-or-create the slot for this session_id."""
+    slot = _slots.get(session_id)
+    if slot is None:
+        slot = HumanTurnSlot()
+        _slots[session_id] = slot
+    return slot
+
+
+def reset_slot(session_id: str) -> None:
+    """Clear payload state in the slot so the next turn starts fresh.
+
+    Idempotent: a no-op if no slot exists. The Event object itself is
+    retained (cleared) so any callers that captured a reference keep
+    working across turns.
+    """
+    slot = _slots.get(session_id)
+    if slot is None:
+        return
+    slot.event.clear()
+    slot.response_text = ""
+    slot.skipped = False
+    slot.started_at = 0.0
+    slot.pending_snapshot = []
+
+
+def deliver_human_response(
+    session_id: str,
+    text: str,
+    *,
+    skip: bool = False,
+) -> bool:
+    """Wake the orchestrator's wait on this session's human turn.
+
+    Returns True if a slot was waiting; False if there was nothing
+    pending (e.g. user double-clicked Submit, or sent a response after
+    the orchestrator already moved on). Callers can surface that as a
+    409 to the frontend.
+    """
+    slot = _slots.get(session_id)
+    if slot is None:
+        return False
+    if slot.event.is_set():
+        # Idempotent: already delivered, treat as no-op.
+        return False
+    slot.response_text = text or ""
+    slot.skipped = bool(skip)
+    slot.event.set()
+    return True
+
+
+def drop_session(session_id: str) -> None:
+    """Cleanup at session-end so old slots don't accumulate."""
+    _slots.pop(session_id, None)

backend/app/services/models.py

@@ -231,9 +231,15 @@ class Participant:
     """One member of the CCAI forum.
 
     `kind` distinguishes Neon HANA personas, the four bundled "extra"
-    personas, and user-created Expert Personas. `enabled` reflects the
-    sidebar slider. Disabled participants are kept on the session so
-    the user can re-enable mid-conversation, but they don't take turns.
+    personas, user-created Expert Personas, and an optional in-the-loop
+    human participant. `enabled` reflects the sidebar slider. Disabled
+    participants are kept on the session so the user can re-enable
+    mid-conversation, but they don't take turns.
+
+    Human participants have `kind == "human"`, no `model_id`, and an
+    empty `role_prompt`. The orchestrator pauses for their input via
+    SSE instead of calling an LLM; the user supplies their text through
+    POST /api/chat/{id}/human-response.
     """
 
     participant_id: str
@@ -241,7 +247,7 @@ class Participant:
     role_prompt: str
     model_id: str
 
-    kind: str = "expert"  # "neon" | "extra" | "expert"
+    kind: str = "expert"  # "neon" | "extra" | "expert" | "human"
     enabled: bool = True
 
     # Resolved provider routing (populated from settings.resolve_model)
@@ -323,9 +329,24 @@ class Session:
     orchestrator_call_cap: int = ORCHESTRATOR_CALL_PAUSE_AT
 
     paused_for_continue: bool = False
-    pause_reason: str | None = None  # "messages" | "orchestrator"
+    pause_reason: str | None = None  # "messages" | "orchestrator" | "human_turn"
     finished: bool = False
 
+    # While the orchestrator is awaiting the human participant's text,
+    # this carries the metadata the frontend needs to render the input
+    # slot (speaker_id, name, phase, etc.). None when no human turn is
+    # pending. The session is paused_for_continue while this is set.
+    awaiting_human: dict[str, Any] | None = None
+
+    # User-authored credential summary for the in-the-loop human
+    # participant (kind == "human"). None when there is no human in
+    # this session. The orchestrator prepends this entry to the
+    # LLM-built credential summary so the human always appears first
+    # in the View Credential Summary modal and exports. Schema:
+    #   {participant_id, name, expertise, personality,
+    #    credibility_for_question (float 0..1), bias_to_watch}
+    human_credential: dict[str, Any] | None = None
+
     # Streaming control: the orchestrator state-machine writes to this and
     # the API layer reads it.
     api_log: list[dict[str, Any]] = field(default_factory=list)

backend/app/services/orchestrator.py

@@ -31,7 +31,7 @@ from typing import Any, AsyncIterator
 
 from app.clients.llm_router import chat_completion
 from app.config import settings
-from app.services import context_budget
+from app.services import context_budget, human_io
 from app.services.consensus import (
     assess_consensus_status,
     classify_addressed_to,
@@ -292,6 +292,165 @@ async def _wait_for_continue(
     yield _sse("status", {"message": "Resuming conversation..."})
 
 
+# ---------------------------------------------------------------------------
+# Human-participant turn
+# ---------------------------------------------------------------------------
+
+async def _wait_for_human_text(
+    session: Session,
+    participant: Participant,
+    *,
+    phase: Phase,
+    addressed_to: str | None = None,
+    asker_id: str | None = None,
+    asker_name: str | None = None,
+    prompt_context: str | None = None,
+) -> AsyncIterator[str]:
+    """Pause the orchestrator until the human types a response (or skips).
+
+    Yields a `human_turn_needed` SSE event with the metadata the
+    frontend needs to render the input slot and the lower-screen
+    "waiting for your input" cue, then polls the human_io slot until
+    the API layer's POST /human-response sets it, then yields a
+    `human_turn_cleared` event so the frontend can dismiss the cue.
+
+    The actual response text + skipped flag are NOT returned from this
+    generator (async gens can't return values cleanly). The caller
+    reads them via `human_io.slot_for(session.session_id)` AFTER the
+    iteration completes:
+
+        slot.response_text   (str)
+        slot.skipped         (bool)
+        slot.started_at      (float)  - subtract from now() for elapsed
+        slot.pending_snapshot (list)  - pending threads at turn-start
+
+    Caller is expected to reset_slot after consuming the result.
+    """
+    started = time.time()
+    pending = _pending_addressed_for(session, participant)
+    slot = human_io.slot_for(session.session_id)
+    slot.event.clear()
+    slot.response_text = ""
+    slot.skipped = False
+    slot.started_at = started
+    slot.pending_snapshot = pending
+
+    awaiting = {
+        "speaker_id": participant.participant_id,
+        "speaker_name": participant.name,
+        "phase": phase.value,
+        "addressed_to": addressed_to,
+        "asker_id": asker_id,
+        "asker_name": asker_name,
+        "prompt_context": prompt_context,
+    }
+    session.awaiting_human = awaiting
+    session.paused_for_continue = True
+    session.pause_reason = "human_turn"
+
+    yield _sse("human_turn_needed", awaiting)
+
+    try:
+        # Poll with the same 0.25s cadence as _wait_for_continue so
+        # SSE-stream cancellation propagates promptly to the user
+        # clicking Stop.
+        while not slot.event.is_set():
+            await asyncio.sleep(0.25)
+    finally:
+        session.paused_for_continue = False
+        session.pause_reason = None
+        session.awaiting_human = None
+
+    yield _sse("human_turn_cleared", {
+        "speaker_id": participant.participant_id,
+    })
+
+
+async def _do_human_turn(
+    session: Session,
+    participant: Participant,
+    *,
+    phase: Phase,
+    actives: list[Participant],
+    addressed_to_target: str | None = None,
+    asker_id: str | None = None,
+    asker_name: str | None = None,
+    prompt_context: str | None = None,
+    classify_addressed: bool = False,
+    track_initial_opinion: bool = False,
+    track_final_opinion: bool = False,
+    addressed_state: dict[str, Any] | None = None,
+) -> AsyncIterator[str]:
+    """End-to-end human turn: emit human_turn_needed, await response,
+    emit human_turn_cleared, then either record a skip note or append a
+    participant message (with addressed-to classification when asked).
+    Yields SSE chunks throughout, then runs the failsafe-pause check.
+
+    `addressed_state`, when provided, is a caller-owned dict that gets
+    mutated with {"last_addressed": <participant_id|None>} after the
+    turn so the consensus phase can update its routing variable
+    without a return value sneaking out of the generator.
+    """
+    async for chunk in _wait_for_human_text(
+        session, participant, phase=phase,
+        addressed_to=addressed_to_target,
+        asker_id=asker_id, asker_name=asker_name,
+        prompt_context=prompt_context,
+    ):
+        yield chunk
+
+    slot = human_io.slot_for(session.session_id)
+    text = (slot.response_text or "").strip()
+    skipped = slot.skipped
+    elapsed = max(0.0, time.time() - slot.started_at)
+    pending = list(slot.pending_snapshot or [])
+    human_io.reset_slot(session.session_id)
+
+    if skipped or not text:
+        note = _add_orchestrator_message(
+            session,
+            f"{participant.name} declined to comment this turn.",
+            kind="status",
+        )
+        yield _sse("orchestrator", _msg_payload(note))
+        if addressed_state is not None:
+            addressed_state["last_addressed"] = None
+        return
+
+    addressed: str | None = None
+    if classify_addressed:
+        addressed = await classify_addressed_to(
+            orchestrator_model_id=_orchestrator_model_id(session),
+            participants=actives,
+            speaker_name=participant.name,
+            message=text,
+            api_log=session.api_log,
+        )
+        _bump_orchestrator_count(session)
+
+    msg = _add_participant_message(
+        session, participant, text,
+        phase=phase, elapsed=elapsed,
+        addressed_to=addressed,
+        replying_to=_replying_to_ids(pending),
+    )
+    if track_initial_opinion:
+        session.initial_opinions[participant.participant_id] = text
+    if track_final_opinion:
+        session.final_opinions[participant.participant_id] = text
+    if addressed_state is not None:
+        addressed_state["last_addressed"] = addressed
+
+    yield _sse("message", _msg_payload(msg))
+
+    if _participant_msg_cap_hit(session):
+        async for chunk in _wait_for_continue(session, "messages"):
+            yield chunk
+    if _orchestrator_cap_hit(session):
+        async for chunk in _wait_for_continue(session, "orchestrator"):
+            yield chunk
+
+
 # ---------------------------------------------------------------------------
 # Participant turn (with context budgeting + summarize-on-demand)
 # ---------------------------------------------------------------------------
@@ -430,6 +589,11 @@ def _add_participant_message(
         "speaker_id": participant.participant_id,
         "speaker_name": participant.name,
         "role": "participant",
+        # `kind` lets the frontend distinguish a human participant's
+        # message ("human") from LLM messages ("neon" | "extra" |
+        # "expert") so the green left-edge accent can be applied
+        # independently of the rotating color palette.
+        "kind": participant.kind,
         "text": text,
         "phase": phase.value,
         "timestamp": time.time(),
@@ -486,6 +650,17 @@ async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
 
     actives = _active_participants(session)
     for p in actives:
+        if p.kind == "human":
+            async for chunk in _do_human_turn(
+                session, p, phase=session.phase, actives=actives,
+                track_initial_opinion=True,
+                prompt_context=(
+                    "Share your initial opinion on the question. "
+                    "You're speaking BEFORE seeing the other participants."
+                ),
+            ):
+                yield chunk
+            continue
         # Phase 1 deliberately uses a *bare* prompt (no transcript) so each
         # participant's first opinion is independent of the others.
         prompt = INITIAL_OPINION_PROMPT.format(question=session.question)
@@ -525,6 +700,7 @@ async def _phase_initial_opinions(session: Session) -> AsyncIterator[str]:
         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
@@ -562,6 +738,18 @@ async def _phase_critique(session: Session, round_number: int) -> AsyncIterator[
     cred_block = credentials_to_block(session.credential_summary)
     actives = _active_participants(session)
     for p in actives:
+        if p.kind == "human":
+            async for chunk in _do_human_turn(
+                session, p, phase=session.phase, actives=actives,
+                classify_addressed=True,
+                prompt_context=(
+                    f"Critique round {round_number} of {round_total}. "
+                    "Push back on, agree with, or build on what others "
+                    "have said. Address other participants by name."
+                ),
+            ):
+                yield chunk
+            continue
         transcript = _format_history(session.messages)
         # Snapshot pending threads BEFORE the call so we can both render
         # them in the prompt and stamp them onto the outgoing message as
@@ -715,6 +903,17 @@ async def _phase_status_assessment(session: Session) -> AsyncIterator[str]:
             announce_msg = _add_orchestrator_message(session, announce, kind="status")
             yield _sse("orchestrator", _msg_payload(announce_msg))
 
+            if target.kind == "human":
+                async for chunk in _do_human_turn(
+                    session, target, phase=session.phase,
+                    actives=_active_participants(session),
+                    asker_id=(asker.participant_id if asker else None),
+                    asker_name=(asker.name if asker else None),
+                    prompt_context=question_text,
+                ):
+                    yield chunk
+                continue
+
             transcript = _format_history(session.messages)
             if asker is not None:
                 prompt2 = TARGETED_FOLLOWUP_FROM_PARTICIPANT_PROMPT.format(
@@ -773,6 +972,17 @@ async def _phase_finalization(session: Session) -> AsyncIterator[str]:
     cred_block = credentials_to_block(session.credential_summary)
     actives = _active_participants(session)
     for p in actives:
+        if p.kind == "human":
+            async for chunk in _do_human_turn(
+                session, p, phase=session.phase, actives=actives,
+                track_final_opinion=True,
+                prompt_context=(
+                    "Phase 4: state your final opinion on the question, "
+                    "incorporating whatever you've learned in the discussion."
+                ),
+            ):
+                yield chunk
+            continue
         transcript = _format_history(session.messages)
         pending = _pending_addressed_for(session, p)
         pending_block = _format_pending_block(pending)
@@ -881,6 +1091,55 @@ async def _phase_consensus(session: Session) -> AsyncIterator[str]:
             dyad_run = 0
             last_addressed = None
 
+        if speaker.kind == "human":
+            addressed_state: dict[str, Any] = {}
+            async for chunk in _do_human_turn(
+                session, speaker, phase=session.phase, actives=actives,
+                classify_addressed=True,
+                addressed_state=addressed_state,
+                prompt_context=(
+                    "Phase 5: weigh in on whether you agree, disagree, "
+                    "or want to refine. Address other participants by "
+                    "name when you're responding to something specific "
+                    "they said."
+                ),
+            ):
+                yield chunk
+            # Propagate addressed_to so dyad routing also works when the
+            # last speaker was the human.
+            last_addressed = addressed_state.get("last_addressed")
+            # Status check every full round (every len(actives) turns).
+            # Replicated here because the LLM-path code below also does
+            # it, and we need it on the human path too.
+            if consensus_turns % max(1, len(actives)) == 0:
+                transcript = _format_history(session.messages)
+                status = await assess_consensus_status(
+                    orchestrator_model_id=_orchestrator_model_id(session),
+                    question=session.question,
+                    transcript=transcript,
+                    alliance_groups=session.alliance_groups,
+                    api_log=session.api_log,
+                )
+                _bump_orchestrator_count(session)
+                if status.get("status") == "majority":
+                    session.alliance_groups = await _refresh_alliance_groups(session, actives)
+                    msg = _add_orchestrator_message(
+                        session,
+                        f"Majority reached. {status.get('rationale', '')}".strip(),
+                        kind="status",
+                    )
+                    yield _sse("orchestrator", _msg_payload(msg))
+                    return
+                if status.get("status") == "unproductive":
+                    msg = _add_orchestrator_message(
+                        session,
+                        f"Conversation no longer productive. {status.get('rationale', '')}".strip(),
+                        kind="status",
+                    )
+                    yield _sse("orchestrator", _msg_payload(msg))
+                    return
+            continue
+
         # Decide allied vs solo prompt
         speaker_group, other_groups = _find_speaker_group(speaker, session.alliance_groups)
         prompt = _build_consensus_prompt(
@@ -1228,6 +1487,9 @@ async def run_conversation(session: Session) -> AsyncIterator[str]:
     finally:
         session.finished = True
         session.phase = Phase.FINISHED
+        # Drop the human-input slot (if any) so its asyncio.Event
+        # doesn't outlive the session in the module-level registry.
+        human_io.drop_session(session.session_id)
 
     # Build per-participant contribution summaries for the table view.
     try:

backend/app/services/prompts/__init__.py

@@ -36,6 +36,10 @@ from app.services.prompts.closure import (
     CONTRIBUTION_SUMMARY_PROMPT,
 )
 from app.services.prompts.auto_select import AUTO_SELECT_PARTICIPANTS_PROMPT
+from app.services.prompts.credential_intake import (
+    CREDENTIAL_INTAKE_EMPTY_TRANSCRIPT,
+    CREDENTIAL_INTAKE_TURN_PROMPT,
+)
 
 __all__ = [
     "PARTICIPANT_BASE_DIRECTIVE",
@@ -59,4 +63,6 @@ __all__ = [
     "NO_CONSENSUS_REPORT_PROMPT",
     "CONTRIBUTION_SUMMARY_PROMPT",
     "AUTO_SELECT_PARTICIPANTS_PROMPT",
+    "CREDENTIAL_INTAKE_TURN_PROMPT",
+    "CREDENTIAL_INTAKE_EMPTY_TRANSCRIPT",
 ]

backend/app/services/prompts/credential_intake.py

@@ -0,0 +1,67 @@
+"""Prompts for the AI-assisted Credential Summary intake.
+
+When a user adds a human participant and clicks "Use AI to make a
+Credential Summary", the frontend kicks off a short adaptive Q&A loop
+backed by these prompts. On each turn the orchestrator LLM is asked
+to either ask one more question or emit a final structured summary.
+
+Adaptive: the LLM may wrap early if the human's answers are already
+rich enough; it MUST wrap by the {max_questions} cap.
+"""
+
+# Each "turn" of the intake Q&A is a single orchestrator call returning
+# strict JSON. The wrapper interpolates the transcript-so-far and the
+# question/budget counters. The wrapping JSON-call helper trims any
+# stray prose around the JSON object.
+CREDENTIAL_INTAKE_TURN_PROMPT = """\
+You are a friendly interviewer helping a human named "{name}" introduce
+themselves to a group discussion about this question:
+
+QUESTION:
+{question}
+
+Your job is to learn enough about this person to write a short
+"credential summary" describing:
+  - their relevant background / expertise
+  - their personal style or perspective in discussions
+  - how credible / well-positioned they are to answer THIS question
+  - any biases or blind spots the group should be aware of
+
+Conduct rules:
+  - You may ask up to {max_questions} short focused questions total.
+  - Ask ONE question per turn (1-2 sentences). No multi-part questions.
+  - Adapt: dig deeper on strong answers, gently restate on thin ones.
+  - Stop EARLY if you already have enough material for a useful summary.
+  - You have used {questions_asked} of {max_questions} questions so far.
+  - If {questions_asked} == {max_questions}, you MUST emit "summary"
+    on this turn rather than asking another question.
+
+Conversation so far (the human's answers may be terse or detailed):
+{transcript}
+
+On THIS turn, output exactly one of the following two JSON shapes
+(strict JSON, no commentary outside the object):
+
+  // Ask one more question:
+  {{ "kind": "question", "text": "your next short question here" }}
+
+  // Finalize - you have enough:
+  {{ "kind": "summary", "summary": {{
+       "name": "{name}",
+       "expertise": "1-2 sentences on background and what they bring",
+       "personality": "1-2 sentences on debating style or tone",
+       "credibility_for_question": 0.55,
+       "bias_to_watch": "1 sentence on biases, blind spots, or priors"
+     }} }}
+
+credibility_for_question is a float in [0, 1]:
+  - 0.8-1.0 = clear domain expert on THIS specific question
+  - 0.5    = average familiarity, opinion is informed but not deep
+  - 0.0-0.2 = clearly outside their wheelhouse on this topic
+"""
+
+
+# Phrase used when the LLM hasn't asked anything yet ({questions_asked}
+# is 0). The orchestrator just prefills "(no answers yet)" into the
+# transcript slot; this constant is exposed mostly for tests.
+CREDENTIAL_INTAKE_EMPTY_TRANSCRIPT = "(no answers yet - this is the first turn)"

frontend/src/App.js

@@ -8,6 +8,7 @@ import ChatTableView from './components/ChatTableView';
 import CredentialSummaryModal from './components/CredentialSummaryModal';
 import ConversationLimitsModal from './components/ConversationLimitsModal';
 import PromptCatalogModal from './components/PromptCatalogModal';
+import HumanParticipantModal from './components/HumanParticipantModal';
 import {
   fetchModels, fetchPersonas, fetchDemoQuestions,
   startChat, continueChat, getOrchestrator, setOrchestrator,
@@ -17,6 +18,7 @@ import {
   autoSelectParticipants,
   fetchPromptCatalog,
   getRateLimitStatus,
+  submitHumanResponse, patchHumanCredential,
 } from './utils/api';
 import * as storage from './utils/storage';
 import './styles/variables.css';
@@ -99,6 +101,21 @@ export default function App() {
   const [promptCatalog, setPromptCatalog] = useState(null);
   const [promptCatalogOpen, setPromptCatalogOpen] = useState(false);
 
+  // In-the-loop human participant.
+  //   humanParticipant is the persisted spec:
+  //     { participant_id, name, credential_summary: {...} } | null
+  //   humanModalOpen / humanEditing power the Add/Edit modal.
+  //   awaitingHuman holds the payload from the last human_turn_needed
+  //     SSE event (null when no human turn is pending).
+  //   humanSubmitting blocks the slot's buttons while POST is in flight.
+  const [humanParticipant, setHumanParticipant] = useState(
+    persisted.human_participant || null,
+  );
+  const [humanModalOpen, setHumanModalOpen] = useState(false);
+  const [humanEditing, setHumanEditing] = useState(null);
+  const [awaitingHuman, setAwaitingHuman] = useState(null);
+  const [humanSubmitting, setHumanSubmitting] = useState(false);
+
   const abortRef = useRef(null);
 
   // ─── Apply theme ────────────────────────────────────────────────
@@ -158,11 +175,30 @@ export default function App() {
     return map;
   }, [catalog, expertPersonas]);
 
+  // Synthetic catalog entry for the in-the-loop human, so they slot
+  // into the same data structures the rest of the app already uses
+  // (sidebar, start payload, credentials display).
+  const humanCatalogEntry = useMemo(() => {
+    if (!humanParticipant) return null;
+    return {
+      participant_id: humanParticipant.participant_id,
+      kind: 'human',
+      name: humanParticipant.name,
+      role_prompt: '',
+      model_id: '',
+      default_model_id: '',
+      model_display: 'Human participant',
+      display_name: 'Human participant',
+    };
+  }, [humanParticipant]);
+
   const selectedParticipants = useMemo(() => {
-    return selectedIds
+    const fromCatalog = selectedIds
       .map(id => allCatalogParticipants[id])
       .filter(Boolean);
-  }, [selectedIds, allCatalogParticipants]);
+    // The human always appears first in the sidebar / participants list.
+    return humanCatalogEntry ? [humanCatalogEntry, ...fromCatalog] : fromCatalog;
+  }, [selectedIds, allCatalogParticipants, humanCatalogEntry]);
 
   const enabledSelectedCount = useMemo(() => {
     return selectedParticipants.filter(p => enabledMap[p.participant_id] !== false).length;
@@ -176,6 +212,7 @@ export default function App() {
   useEffect(() => { storage.setOrchestratorModelId(orchestratorModel); }, [orchestratorModel]);
   useEffect(() => { storage.setSummarizerModelId(summarizerModel); }, [summarizerModel]);
   useEffect(() => { storage.setMaxParticipants(maxParticipants); }, [maxParticipants]);
+  useEffect(() => { storage.setHumanParticipant(humanParticipant); }, [humanParticipant]);
 
   // ─── Settings handlers ──────────────────────────────────────────
   const handleOrchestratorChange = useCallback(async (modelId) => {
@@ -208,6 +245,9 @@ export default function App() {
   // ─── Participant ops ────────────────────────────────────────────
   const handleToggleParticipant = useCallback((participant, kind) => {
     const id = participant.participant_id;
+    // The human occupies one of the maxParticipants slots; reserve it
+    // when computing the room left for LLM picks.
+    const humanReserved = humanParticipant ? 1 : 0;
     setSelectedIds(prev => {
       if (prev.includes(id)) {
         // Deselect entirely
@@ -218,25 +258,102 @@ export default function App() {
         });
         return prev.filter(x => x !== id);
       }
-      if (prev.length >= maxParticipants) return prev;
+      if (prev.length + humanReserved >= maxParticipants) return prev;
       setEnabledMap(em => ({ ...em, [id]: true }));
       return [...prev, id];
     });
-  }, [maxParticipants]);
+  }, [maxParticipants, humanParticipant]);
 
   const handleSidebarToggleEnabled = useCallback((participantId, enabled) => {
     setEnabledMap(em => ({ ...em, [participantId]: enabled }));
   }, []);
 
   const handleSidebarRemove = useCallback((participantId) => {
+    if (humanParticipant && participantId === humanParticipant.participant_id) {
+      setHumanParticipant(null);
+      return;
+    }
     setSelectedIds(prev => prev.filter(x => x !== participantId));
     setEnabledMap(em => {
       const next = { ...em };
       delete next[participantId];
       return next;
     });
+  }, [humanParticipant]);
+
+  // ─── Human participant ops ───────────────────────────────────────
+  const handleOpenHumanModal = useCallback(() => {
+    setHumanEditing(humanParticipant);
+    setHumanModalOpen(true);
+  }, [humanParticipant]);
+
+  const handleSaveHuman = useCallback((spec) => {
+    setHumanParticipant(spec);
+    setHumanModalOpen(false);
+    setHumanEditing(null);
+  }, []);
+
+  const handleRemoveHuman = useCallback(() => {
+    setHumanParticipant(null);
+    setHumanModalOpen(false);
+    setHumanEditing(null);
   }, []);
 
+  const handleHumanSubmit = useCallback(async (text) => {
+    if (!sessionId || !awaitingHuman) return;
+    setHumanSubmitting(true);
+    try {
+      await submitHumanResponse(sessionId, { text });
+    } catch (err) {
+      console.error('Human response failed:', err);
+      setSystemMessages(prev => [...prev, {
+        text: `Couldn't send your message: ${err.message}`,
+      }]);
+    } finally {
+      setHumanSubmitting(false);
+    }
+  }, [sessionId, awaitingHuman]);
+
+  const handleHumanSkip = useCallback(async () => {
+    if (!sessionId || !awaitingHuman) return;
+    setHumanSubmitting(true);
+    try {
+      await submitHumanResponse(sessionId, { text: '', skip: true });
+    } catch (err) {
+      console.error('Human skip failed:', err);
+    } finally {
+      setHumanSubmitting(false);
+    }
+  }, [sessionId, awaitingHuman]);
+
+  const handleEditHumanCredential = useCallback(async (patch) => {
+    if (!sessionId) return;
+    try {
+      const result = await patchHumanCredential(sessionId, patch);
+      const updated = result.credential;
+      if (updated) {
+        // Reflect the edit in the persisted spec so re-opens of the
+        // Add-a-Human modal show the latest version.
+        setHumanParticipant(prev => prev ? {
+          ...prev,
+          name: updated.name || prev.name,
+          credential_summary: {
+            name: updated.name || prev.name,
+            expertise: updated.expertise || '',
+            personality: updated.personality || '',
+            credibility_for_question: updated.credibility_for_question ?? 0.55,
+            bias_to_watch: updated.bias_to_watch || '',
+          },
+        } : prev);
+        // Refresh the credentials cache so the modal reflects the edit.
+        const data = await fetchCredentials(sessionId);
+        setCredentialsData(data);
+      }
+    } catch (err) {
+      console.error('Edit human credential failed:', err);
+    }
+  }, [sessionId]);
+
   // ─── Auto-select toggle ─────────────────────────────────────────
   // When turning ON, snapshot the current manual selection so we can
   // restore it on OFF. The actual LLM ranking happens in handleStart
@@ -400,8 +517,10 @@ export default function App() {
       kind: p.kind || (p.participant_id.startsWith('neon:') ? 'neon'
         : (p.participant_id.startsWith('extra_') ? 'extra' : 'expert')),
       name: p.name,
-      role_prompt: p.role_prompt || null,
-      model_id_override: modelAssignments[p.participant_id] || null,
+      role_prompt: p.kind === 'human' ? null : (p.role_prompt || null),
+      model_id_override: p.kind === 'human'
+        ? null
+        : (modelAssignments[p.participant_id] || null),
     }));
     const expert_payload = baseList
       .filter(p => (p.kind || '').startsWith('expert'))
@@ -411,6 +530,25 @@ export default function App() {
         model_id: modelAssignments[p.participant_id] || p.model_id,
         role_prompt: p.role_prompt,
       }));
+    // The human's pre-authored credential summary rides alongside the
+    // 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 humanInList = baseList.find(p => p.kind === 'human');
+    let human_credential = null;
+    if (humanInList && humanParticipant) {
+      const cs = humanParticipant.credential_summary || {};
+      human_credential = {
+        participant_id: humanInList.participant_id,
+        name: humanInList.name,
+        expertise: cs.expertise || '',
+        personality: cs.personality || '',
+        credibility_for_question: typeof cs.credibility_for_question === 'number'
+          ? cs.credibility_for_question
+          : 0.55,
+        bias_to_watch: cs.bias_to_watch || '',
+      };
+    }
     return {
       question: theQuestion,
       participants,
@@ -421,8 +559,9 @@ export default function App() {
       max_participants: maxParticipants,
       // Sparse override map; backend clamps and falls back per-field.
       limits: limitsOverrides,
+      human_credential,
     };
-  }, [selectedParticipants, enabledMap, modelAssignments, orchestratorModel, summarizerModel, maxParticipants, limitsOverrides]);
+  }, [selectedParticipants, enabledMap, modelAssignments, orchestratorModel, summarizerModel, maxParticipants, limitsOverrides, humanParticipant]);
 
   // ─── Stop / continue ────────────────────────────────────────────
   const handleStop = useCallback(() => {
@@ -460,6 +599,7 @@ export default function App() {
     setPause(null);
     setActiveQuestion(theQuestion.trim());
     setCredentialsData(null);
+    setAwaitingHuman(null);
 
     // Resolve the final participant list. When auto-select is on, ask
     // the orchestrator to rank every available candidate; otherwise
@@ -485,16 +625,23 @@ export default function App() {
           || p.model_id || p.default_model_id || '',
       }));
       try {
+        // The human, if any, always gets a seat; ask the orchestrator
+        // for one fewer LLM pick so the total stays at maxParticipants.
+        const humanReserved = humanParticipant ? 1 : 0;
+        const llmTarget = Math.max(2, maxParticipants - humanReserved);
         const result = await autoSelectParticipants({
           question: theQuestion.trim(),
-          count: maxParticipants,
+          count: llmTarget,
           candidates: candidatesPayload,
           orchestrator_model_id: orchestratorModel,
         });
         const chosenIds = result.selected || [];
-        resolvedParticipants = chosenIds
+        const chosenLlms = chosenIds
           .map(id => allCatalogParticipants[id])
           .filter(Boolean);
+        resolvedParticipants = humanCatalogEntry
+          ? [humanCatalogEntry, ...chosenLlms]
+          : chosenLlms;
         if (resolvedParticipants.length < 2) {
           setIsRunning(false);
           setStatusText('');
@@ -583,6 +730,18 @@ export default function App() {
               stage: data.stage || 'built',
             });
           },
+          onHumanTurnNeeded: (data) => {
+            // Orchestrator is paused waiting on the human; render the
+            // green-bordered input slot and the lower-screen indicator.
+            setAwaitingHuman(data || null);
+            setStatusText(
+              `${data?.speaker_name || 'Human'} is up next.`,
+            );
+          },
+          onHumanTurnCleared: () => {
+            setAwaitingHuman(null);
+            setHumanSubmitting(false);
+          },
           onDone: () => {
             setIsRunning(false);
             setStatusText('');
@@ -608,6 +767,7 @@ export default function App() {
     buildStartPayload, enabledSelectedCount, dailyLimit,
     autoSelectMode, allCatalogParticipants, modelAssignments,
     maxParticipants, orchestratorModel,
+    humanParticipant, humanCatalogEntry,
   ]);
 
   const handleStartRandom = useCallback(() => {
@@ -648,6 +808,8 @@ export default function App() {
         onOpenExpertModal={handleOpenExpertModal}
         autoSelectMode={autoSelectMode}
         onToggleAutoSelectMode={handleToggleAutoSelectMode}
+        humanParticipant={humanParticipant}
+        onOpenHumanModal={handleOpenHumanModal}
 
         allModels={allModelsFlat}
         orchestratorModel={orchestratorModel}
@@ -706,6 +868,10 @@ export default function App() {
             participants={sessionParticipants.length > 0 ? sessionParticipants : selectedParticipants}
             showResponseTime={showResponseTime}
             showChatStats={showChatStats}
+            awaitingHuman={awaitingHuman}
+            humanSubmitting={humanSubmitting}
+            onHumanSubmit={handleHumanSubmit}
+            onHumanSkip={handleHumanSkip}
           />
         </div>
       </main>
@@ -735,6 +901,17 @@ export default function App() {
         data={credentialsData}
         onClose={() => setCredentialsOpen(false)}
         onRefresh={handleRefreshCredentials}
+        humanParticipantId={humanParticipant?.participant_id || null}
+        onEditHumanCredential={handleEditHumanCredential}
+      />
+      <HumanParticipantModal
+        isOpen={humanModalOpen}
+        initial={humanEditing}
+        question={activeQuestion}
+        orchestratorModel={orchestratorModel}
+        onClose={() => { setHumanModalOpen(false); setHumanEditing(null); }}
+        onSave={handleSaveHuman}
+        onRemove={humanEditing ? handleRemoveHuman : null}
       />
       <ConversationLimitsModal
         isOpen={limitsOpen}

frontend/src/components/ChatArea.js

@@ -2,6 +2,8 @@ import React, { useMemo } from 'react';
 import MessageBubble from './MessageBubble';
 import OrchestratorMessage from './OrchestratorMessage';
 import FailsafePauseBanner from './FailsafePauseBanner';
+import HumanInputSlot from './HumanInputSlot';
+import HumanTurnIndicator from './HumanTurnIndicator';
 
 /**
  * Renders the conversation: a mix of participant bubbles, orchestrator
@@ -19,6 +21,10 @@ export default function ChatArea({
   participants,
   showResponseTime,
   showChatStats,
+  awaitingHuman,
+  humanSubmitting,
+  onHumanSubmit,
+  onHumanSkip,
 }) {
   const speakerIdxFor = useMemo(() => {
     const map = {};
@@ -73,6 +79,17 @@ export default function ChatArea({
           />
         );
       })}
+      {awaitingHuman && (
+        <div data-human-slot>
+          <HumanInputSlot
+            awaiting={awaitingHuman}
+            sending={humanSubmitting}
+            onSubmit={onHumanSubmit}
+            onSkip={onHumanSkip}
+            allowSkip
+          />
+        </div>
+      )}
       {(systemMessages || []).map((sys, i) => (
         <div
           key={`sys-${i}`}
@@ -87,12 +104,13 @@ export default function ChatArea({
         </div>
       )}
       <FailsafePauseBanner pause={pause} onContinue={onContinuePause} />
-      {isRunning && statusText && (
+      {isRunning && statusText && !awaitingHuman && (
         <div className="status-bar">
           <div className="spinner" />
           <span>{statusText}</span>
         </div>
       )}
+      <HumanTurnIndicator awaiting={awaitingHuman} />
     </div>
   );
 }

frontend/src/components/CredentialSummaryModal.js

@@ -1,5 +1,5 @@
-import React, { useMemo } from 'react';
-import { Download } from 'lucide-react';
+import React, { useMemo, useState, useEffect } from 'react';
+import { Download, Edit2, Check, X, User } from 'lucide-react';
 
 /**
  * Read-only modal that surfaces the orchestrator-generated Credential
@@ -19,6 +19,8 @@ export default function CredentialSummaryModal({
   data,
   onClose,
   onRefresh,
+  humanParticipantId,
+  onEditHumanCredential,
 }) {
   // Hooks must run on every render, so the filename memo lives ABOVE
   // the early return. The dependency on `isOpen` regenerates the
@@ -99,9 +101,18 @@ export default function CredentialSummaryModal({
               orchestrator builds it after Phase 1 (initial opinions).
             </div>
           ) : (
-            credentials.map((c) => (
-              <CredentialCard key={c.participant_id} cred={c} />
-            ))
+            credentials.map((c) => {
+              const isHuman = !!humanParticipantId
+                && c.participant_id === humanParticipantId;
+              return (
+                <CredentialCard
+                  key={c.participant_id}
+                  cred={c}
+                  isHuman={isHuman}
+                  onEdit={isHuman ? onEditHumanCredential : null}
+                />
+              );
+            })
           )}
         </div>
       </div>
@@ -109,13 +120,112 @@ export default function CredentialSummaryModal({
   );
 }
 
-function CredentialCard({ cred }) {
+function CredentialCard({ cred, isHuman, onEdit }) {
+  const [editing, setEditing] = useState(false);
+  const [draft, setDraft] = useState(() => ({
+    name: cred.name || '',
+    expertise: cred.expertise || '',
+    personality: cred.personality || '',
+    credibility_for_question:
+      cred.credibility_for_question !== undefined
+        ? cred.credibility_for_question
+        : 0.5,
+    bias_to_watch: cred.bias_to_watch || '',
+  }));
+
+  // Reset the draft whenever the underlying credential payload
+  // changes (e.g. a Phase-3 refresh from the SSE stream).
+  useEffect(() => {
+    setDraft({
+      name: cred.name || '',
+      expertise: cred.expertise || '',
+      personality: cred.personality || '',
+      credibility_for_question:
+        cred.credibility_for_question !== undefined
+          ? cred.credibility_for_question
+          : 0.5,
+      bias_to_watch: cred.bias_to_watch || '',
+    });
+  }, [cred]);
+
   const score = toScore(cred.credibility_for_question);
+
+  if (isHuman && editing) {
+    return (
+      <div className="ccai-credential-card ccai-credential-card-human ccai-credential-card-editing">
+        <div className="ccai-credential-card-head">
+          <div className="ccai-credential-name">
+            <User size={14} style={{ marginRight: 4, verticalAlign: '-2px' }} />
+            <input
+              className="ccai-credential-edit-name"
+              type="text"
+              value={draft.name}
+              onChange={e => setDraft(d => ({ ...d, name: e.target.value }))}
+            />
+            <span className="ccai-credential-human-tag">Human</span>
+          </div>
+        </div>
+        <EditableRow
+          label="Expertise"
+          value={draft.expertise}
+          onChange={v => setDraft(d => ({ ...d, expertise: v }))}
+        />
+        <EditableRow
+          label="Style"
+          value={draft.personality}
+          onChange={v => setDraft(d => ({ ...d, personality: v }))}
+        />
+        <EditableScoreRow
+          label="Credibility (0-1)"
+          value={draft.credibility_for_question}
+          onChange={v => setDraft(d => ({ ...d, credibility_for_question: v }))}
+        />
+        <EditableRow
+          label="Bias to watch"
+          value={draft.bias_to_watch}
+          onChange={v => setDraft(d => ({ ...d, bias_to_watch: v }))}
+        />
+        <div className="ccai-credential-edit-actions">
+          <button
+            type="button"
+            className="btn-sm btn-outline"
+            onClick={() => setEditing(false)}
+          >
+            <X size={12} style={{ marginRight: 4 }} />
+            Cancel
+          </button>
+          <button
+            type="button"
+            className="btn btn-primary btn-sm"
+            onClick={async () => {
+              await onEdit?.(draft);
+              setEditing(false);
+            }}
+          >
+            <Check size={12} style={{ marginRight: 4 }} />
+            Save
+          </button>
+        </div>
+      </div>
+    );
+  }
+
   return (
-    <div className="ccai-credential-card">
+    <div
+      className={
+        'ccai-credential-card'
+        + (isHuman ? ' ccai-credential-card-human' : '')
+      }
+    >
       <div className="ccai-credential-card-head">
         <div className="ccai-credential-name">
+          {isHuman && (
+            <User size={14} style={{ marginRight: 4, verticalAlign: '-2px' }} />
+          )}
           {cred.name || cred.participant_id}
+          {isHuman && (
+            <span className="ccai-credential-human-tag">Human</span>
+          )}
         </div>
         {score !== null && (
           <div className="ccai-credibility-wrap" title={`Credibility ${score.toFixed(2)} of 1.0`}>
@@ -129,6 +239,17 @@ function CredentialCard({ cred }) {
             <span className="ccai-credibility-num">{score.toFixed(2)}</span>
           </div>
         )}
+        {isHuman && onEdit && (
+          <button
+            type="button"
+            className="btn-sm btn-outline ccai-credential-edit-btn"
+            onClick={() => setEditing(true)}
+            title="Edit your credential summary"
+          >
+            <Edit2 size={12} style={{ marginRight: 4 }} />
+            Edit
+          </button>
+        )}
       </div>
       <FieldRow label="Expertise" value={cred.expertise} />
       <FieldRow label="Style" value={cred.personality} />
@@ -137,6 +258,40 @@ function CredentialCard({ cred }) {
   );
 }
 
+function EditableRow({ label, value, onChange }) {
+  return (
+    <div className="ccai-credential-row ccai-credential-row-edit">
+      <div className="ccai-credential-row-label">{label}</div>
+      <textarea
+        className="ccai-credential-row-input"
+        rows={2}
+        value={value}
+        onChange={e => onChange(e.target.value)}
+      />
+    </div>
+  );
+}
+
+function EditableScoreRow({ label, value, onChange }) {
+  return (
+    <div className="ccai-credential-row ccai-credential-row-edit">
+      <div className="ccai-credential-row-label">{label}</div>
+      <input
+        type="number"
+        min={0}
+        max={1}
+        step={0.05}
+        value={value}
+        className="ccai-credential-row-input ccai-credential-row-input-num"
+        onChange={(e) => {
+          const v = parseFloat(e.target.value);
+          if (!Number.isNaN(v)) onChange(Math.max(0, Math.min(1, v)));
+        }}
+      />
+    </div>
+  );
+}
+
 function FieldRow({ label, value }) {
   if (!value) return null;
   return (

frontend/src/components/Header.js

@@ -1,4 +1,5 @@
 import React from 'react';
+import { UserPlus, UserCheck } from 'lucide-react';
 import AuthBadge from './AuthBadge';
 import ParticipantDropdown from './ParticipantDropdown';
 import DownloadMenu from './DownloadMenu';
@@ -32,6 +33,8 @@ export default function Header({
   onOpenExpertModal,
   autoSelectMode,
   onToggleAutoSelectMode,
+  humanParticipant,
+  onOpenHumanModal,
 
   // Models / display
   allModels,
@@ -89,6 +92,29 @@ export default function Header({
           autoSelectMode={autoSelectMode}
           onToggleAutoSelectMode={onToggleAutoSelectMode}
         />
+        <button
+          type="button"
+          className={
+            'btn-sm btn-outline ccai-human-add-btn'
+            + (humanParticipant ? ' ccai-human-add-btn-active' : '')
+          }
+          onClick={onOpenHumanModal}
+          title={humanParticipant
+            ? `Edit ${humanParticipant.name}'s credential summary`
+            : 'Add a human participant to the conversation'}
+        >
+          {humanParticipant ? (
+            <>
+              <UserCheck size={14} style={{ marginRight: 4 }} />
+              Human: {humanParticipant.name}
+            </>
+          ) : (
+            <>
+              <UserPlus size={14} style={{ marginRight: 4 }} />
+              Add a Human Participant
+            </>
+          )}
+        </button>
         <DownloadMenu
           hasChat={hasChat}
           hasApiLog={hasApiLog}

frontend/src/components/HumanInputSlot.js

@@ -0,0 +1,119 @@
+import React, { useState, useEffect, useRef } from 'react';
+import { Send, SkipForward } from 'lucide-react';
+
+/**
+ * Inline input slot rendered in the chat stream when it's the human
+ * participant's turn. Replaces what would otherwise be the LLM's
+ * message bubble. Visually distinct via a thick green left-edge
+ * accent and a pulsing border so it's obvious "we're waiting on you".
+ *
+ * Props:
+ *   awaiting   - the awaiting_human payload from the most recent
+ *                human_turn_needed SSE event:
+ *                  { speaker_id, speaker_name, phase,
+ *                    addressed_to?, asker_name?, prompt_context? }
+ *   onSubmit   - async (text) => void
+ *   onSkip     - async ()      => void   (only when allowSkip)
+ *   allowSkip  - bool, defaults true
+ *   sending    - bool: disable the buttons while a submit is in flight
+ */
+export default function HumanInputSlot({
+  awaiting,
+  onSubmit,
+  onSkip,
+  allowSkip = true,
+  sending = false,
+}) {
+  const [text, setText] = useState('');
+  const taRef = useRef(null);
+
+  // Auto-focus when the slot first appears, so the user can start
+  // typing immediately without hunting for the textarea.
+  useEffect(() => {
+    if (awaiting && taRef.current) {
+      taRef.current.focus();
+    }
+    // We intentionally narrow the dep list to the identity of the
+    // pending turn (speaker + phase). Re-focusing on every awaiting
+    // mutation would steal focus from the user mid-type.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [awaiting?.speaker_id, awaiting?.phase]);
+
+  if (!awaiting) return null;
+
+  const name = awaiting.speaker_name || 'you';
+  const askerLine = awaiting.asker_name
+    ? `${awaiting.asker_name} asked: ${awaiting.prompt_context || '…'}`
+    : awaiting.prompt_context || '';
+
+  const handleSubmit = async () => {
+    const value = text.trim();
+    if (!value) return;
+    await onSubmit?.(value);
+    setText('');
+  };
+
+  const handleKeyDown = (e) => {
+    // Ctrl/Cmd+Enter submits; plain Enter inserts a newline (textarea default).
+    if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') {
+      e.preventDefault();
+      handleSubmit();
+    }
+  };
+
+  return (
+    <div className="ccai-human-slot" data-speaker-id={awaiting.speaker_id || ''}>
+      <div className="ccai-human-slot-accent" />
+      <div className="ccai-human-slot-body">
+        <div className="ccai-human-slot-header">
+          <span className="ccai-human-slot-name">{name}</span>
+          <span className="ccai-human-slot-pulse" aria-hidden="true" />
+          <span className="ccai-human-slot-prompt">
+            {name}, please type your response here.
+          </span>
+        </div>
+        {askerLine && (
+          <div className="ccai-human-slot-context">{askerLine}</div>
+        )}
+        <textarea
+          ref={taRef}
+          className="ccai-human-slot-textarea"
+          value={text}
+          onChange={e => setText(e.target.value)}
+          onKeyDown={handleKeyDown}
+          rows={4}
+          placeholder={`${name} please type your response here`}
+          disabled={sending}
+        />
+        <div className="ccai-human-slot-actions">
+          <span className="ccai-human-slot-hint">
+            Ctrl+Enter to submit
+          </span>
+          <div className="ccai-human-slot-actions-right">
+            {allowSkip && (
+              <button
+                type="button"
+                className="btn-sm btn-outline ccai-human-slot-skip"
+                onClick={() => onSkip?.()}
+                disabled={sending}
+                title="Skip my turn this round"
+              >
+                <SkipForward size={14} style={{ marginRight: 4 }} />
+                Skip my turn
+              </button>
+            )}
+            <button
+              type="button"
+              className="btn btn-primary btn-sm ccai-human-slot-submit"
+              onClick={handleSubmit}
+              disabled={sending || !text.trim()}
+            >
+              <Send size={14} style={{ marginRight: 4 }} />
+              {sending ? 'Sending…' : 'Submit'}
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/HumanParticipantModal.js

@@ -0,0 +1,433 @@
+import React, { useState, useCallback, useRef, useEffect } from 'react';
+import { Download, Sparkles, X } from 'lucide-react';
+import {
+  startCredentialDraft,
+  answerCredentialDraft,
+  cancelCredentialDraft,
+} from '../utils/api';
+
+/**
+ * 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).
+ */
+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('');
+
+  // 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 });
+  }, [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());
+    const pid = initial?.participant_id || `human_${Date.now()}`;
+    onSave({
+      participant_id: pid,
+      name: name.trim(),
+      credential_summary: parsed,
+    });
+  }, [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]);
+
+  if (!isOpen) return null;
+
+  const aiInProgress = !!aiDraftId && !!aiCurrentQuestion;
+
+  return (
+    <div className="ccai-credentials-overlay">
+      <div className="ccai-credentials-card ccai-human-modal-card">
+        <div className="ccai-credentials-header">
+          <div>
+            <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
+              your turn.
+            </div>
+          </div>
+          <div className="ccai-tab-spacer" />
+          <button className="modal-close" onClick={onClose}>&times;</button>
+        </div>
+
+        <div className="ccai-human-modal-body">
+          <label className="ccai-human-field">
+            <span className="ccai-human-field-label">Name</span>
+            <input
+              type="text"
+              className="ccai-human-input"
+              value={name}
+              onChange={e => setName(e.target.value)}
+              placeholder="e.g. Pat, Dr. Lopez, …"
+            />
+          </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>
+            <textarea
+              className="ccai-human-summary"
+              value={summary}
+              onChange={e => setSummary(e.target.value)}
+              rows={10}
+              spellCheck
+            />
+            <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.
+            </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>
+          )}
+        </div>
+
+        <div className="ccai-human-modal-footer">
+          <div>
+            {onRemove && initial?.participant_id && (
+              <button
+                type="button"
+                className="btn-sm btn-outline ccai-human-remove"
+                onClick={onRemove}
+                title="Remove the human participant from this session"
+              >
+                <X size={14} style={{ marginRight: 4 }} />
+                Remove human
+              </button>
+            )}
+          </div>
+          <div className="ccai-human-modal-footer-right">
+            <button
+              type="button"
+              className="btn-sm btn-outline"
+              onClick={handleDownload}
+              disabled={!summary.trim()}
+            >
+              <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()}
+            >
+              Approve
+            </button>
+          </div>
+        </div>
+      </div>
+    </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/HumanTurnIndicator.js

@@ -0,0 +1,44 @@
+import React from 'react';
+import { ArrowDown } from 'lucide-react';
+
+/**
+ * Fixed-position attention cue rendered along the bottom edge of the
+ * viewport when the orchestrator is waiting for the human's input.
+ *
+ * Per the spec we do NOT auto-scroll - the user might be reading
+ * earlier messages and resent the page jumping under them. We just
+ * surface a persistent green pulse + arrow + name so they can scroll
+ * down to the input slot on their own when ready.
+ *
+ * Clicking the indicator scrolls the input slot into view (best
+ * effort: we look for [data-human-slot] in the DOM).
+ */
+export default function HumanTurnIndicator({ awaiting }) {
+  if (!awaiting) return null;
+  const name = awaiting.speaker_name || 'you';
+  const handleClick = () => {
+    const target = document.querySelector('[data-human-slot]');
+    if (target) {
+      target.scrollIntoView({ behavior: 'smooth', block: 'center' });
+      const ta = target.querySelector('textarea');
+      if (ta) ta.focus({ preventScroll: true });
+    }
+  };
+  return (
+    <button
+      type="button"
+      className="ccai-human-indicator"
+      onClick={handleClick}
+      title={`Jump to ${name}'s input slot`}
+    >
+      <ArrowDown
+        size={16}
+        strokeWidth={2.5}
+        className="ccai-human-indicator-arrow"
+      />
+      <span className="ccai-human-indicator-text">
+        {name}, the discussion is waiting for your input
+      </span>
+    </button>
+  );
+}

frontend/src/components/MessageBubble.js

@@ -35,6 +35,11 @@ function colorForIdx(idx) {
  *     the immediately previous bubble - cheap visual threading without
  *     full nesting.
  */
+// Green tone used for in-the-loop human participants. Overrides the
+// rotating palette so a human's bubble always reads as "the human
+// one" no matter where they fall in the active roster ordering.
+const HUMAN_TONE = { color: '#16A34A', bg: '#F0FDF4' };
+
 export default function MessageBubble({
   message,
   idx,
@@ -43,7 +48,9 @@ export default function MessageBubble({
   participantNameById,
   showResponseTime,
 }) {
-  const tone = colorForIdx(idx);
+  const isHuman = message.kind === 'human'
+    || (message.model_display === 'Human participant');
+  const tone = isHuman ? HUMAN_TONE : colorForIdx(idx);
   const initial = (message.speaker_name || '?').charAt(0).toUpperCase();
   const elapsed = message.elapsed_seconds;
 
@@ -90,7 +97,8 @@ export default function MessageBubble({
 
   const rowClassName =
     'message-row ccai-message-row' +
-    (isDirectReply ? ' ccai-message-row-reply' : '');
+    (isDirectReply ? ' ccai-message-row-reply' : '') +
+    (isHuman ? ' ccai-message-row-human' : '');
 
   return (
     <div

frontend/src/components/ParticipantSidebar.js

@@ -1,5 +1,5 @@
 import React, { useState } from 'react';
-import { ChevronDown, ChevronRight, X } from 'lucide-react';
+import { ChevronDown, ChevronRight, User, X } from 'lucide-react';
 
 /**
  * Replaces LLMChats3's LLMSelector. Lists the user's currently selected
@@ -67,11 +67,14 @@ export default function ParticipantSidebar({
 
 function ParticipantCard({ participant, enabled, modelOverride, onToggleEnabled, onRemove }) {
   const [open, setOpen] = useState(false);
+  const isHuman = participant.kind === 'human';
 
   return (
     <div
       className={
-        'ccai-participant-card' + (enabled ? '' : ' ccai-participant-card-off')
+        'ccai-participant-card'
+        + (enabled ? '' : ' ccai-participant-card-off')
+        + (isHuman ? ' ccai-participant-card-human' : '')
       }
     >
       <div className="ccai-participant-row">
@@ -82,7 +85,19 @@ function ParticipantCard({ participant, enabled, modelOverride, onToggleEnabled,
         >
           {open ? <ChevronDown size={14} /> : <ChevronRight size={14} />}
         </button>
-        <div className="ccai-participant-name">{participant.name}</div>
+        <div className="ccai-participant-name">
+          {isHuman && (
+            <User
+              size={12}
+              strokeWidth={2.5}
+              style={{ marginRight: 4, verticalAlign: '-2px' }}
+            />
+          )}
+          {participant.name}
+          {isHuman && (
+            <span className="ccai-participant-human-tag">Human</span>
+          )}
+        </div>
         <div className="ccai-participant-controls">
           {enabled ? (
             <label className="ccai-toggle" title="Toggle participation">
@@ -116,18 +131,32 @@ function ParticipantCard({ participant, enabled, modelOverride, onToggleEnabled,
       )}
       {open && (
         <div className="ccai-participant-body">
-          <div className="ccai-participant-field">
-            <div className="ccai-participant-field-label">LLM</div>
-            <div className="ccai-participant-field-value">
-              {modelOverride || participant.default_model_id || participant.model_display || ''}
+          {isHuman ? (
+            <div className="ccai-participant-field">
+              <div className="ccai-participant-field-label">Role</div>
+              <div className="ccai-participant-field-value">
+                In-the-loop human participant. The orchestrator pauses
+                for your input when it's your turn. Edit your name and
+                credential summary from the "Human:&nbsp;…" button in
+                the header.
+              </div>
             </div>
-          </div>
-          <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)'}
-            </pre>
-          </div>
+          ) : (
+            <>
+              <div className="ccai-participant-field">
+                <div className="ccai-participant-field-label">LLM</div>
+                <div className="ccai-participant-field-value">
+                  {modelOverride || participant.default_model_id || participant.model_display || ''}
+                </div>
+              </div>
+              <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)'}
+                </pre>
+              </div>
+            </>
+          )}
         </div>
       )}
     </div>

frontend/src/styles/ccai.css

@@ -1288,3 +1288,547 @@
   max-height: 280px;
   overflow-y: auto;
 }
+
+
+/* ════════════════════════════════════════════════════════════════
+   Human Participant
+   Styles for the in-the-loop human: add/edit modal, sidebar entry,
+   in-chat input slot, lower-screen attention cue, green-accent bubble,
+   and the inline edit affordance on the human's credential row.
+   ════════════════════════════════════════════════════════════════ */
+
+/* ── Add a Human Participant button (header) ───────────────────── */
+
+.ccai-human-add-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  white-space: nowrap;
+}
+
+.ccai-human-add-btn-active {
+  border-color: #16A34A;
+  color: #16A34A;
+}
+
+[data-theme="dark"] .ccai-human-add-btn-active {
+  border-color: #4ADE80;
+  color: #4ADE80;
+}
+
+/* ── Human Participant modal (Add / Edit) ──────────────────────── */
+
+.ccai-human-modal-card {
+  width: min(640px, 92vw);
+}
+
+.ccai-human-modal-body {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  padding: 16px 20px;
+}
+
+.ccai-human-field {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.ccai-human-field-label {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-secondary);
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+.ccai-human-input {
+  padding: 8px 10px;
+  border: 1px solid var(--border-primary);
+  border-radius: 6px;
+  background: var(--card-bg);
+  color: var(--text-primary);
+  font-size: 14px;
+}
+
+.ccai-human-input:focus {
+  outline: none;
+  border-color: #16A34A;
+  box-shadow: 0 0 0 2px rgba(22, 163, 74, 0.18);
+}
+
+.ccai-human-summary-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.ccai-human-summary {
+  width: 100%;
+  padding: 10px 12px;
+  border: 1px solid var(--border-primary);
+  border-radius: 6px;
+  background: var(--card-bg);
+  color: var(--text-primary);
+  font-size: 13px;
+  font-family: inherit;
+  line-height: 1.5;
+  resize: vertical;
+  min-height: 160px;
+  box-sizing: border-box;
+}
+
+.ccai-human-summary:focus {
+  outline: none;
+  border-color: #16A34A;
+  box-shadow: 0 0 0 2px rgba(22, 163, 74, 0.18);
+}
+
+.ccai-human-summary-help {
+  font-size: 12px;
+  color: var(--text-tertiary);
+  font-style: italic;
+}
+
+.ccai-human-ai-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  white-space: nowrap;
+}
+
+.ccai-human-ai-panel {
+  border: 1px solid #16A34A;
+  background: rgba(22, 163, 74, 0.04);
+  border-radius: 8px;
+  padding: 12px 14px;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+[data-theme="dark"] .ccai-human-ai-panel {
+  background: rgba(74, 222, 128, 0.06);
+  border-color: #4ADE80;
+}
+
+.ccai-human-ai-counter {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  font-size: 12px;
+  font-weight: 600;
+  color: #16A34A;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+
+[data-theme="dark"] .ccai-human-ai-counter {
+  color: #4ADE80;
+}
+
+.ccai-human-ai-stop {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  background: transparent;
+  border: 1px solid var(--border-primary);
+  border-radius: 4px;
+  padding: 2px 6px;
+  font-size: 11px;
+  color: var(--text-secondary);
+  cursor: pointer;
+}
+
+.ccai-human-ai-stop:hover {
+  border-color: var(--text-secondary);
+  color: var(--text-primary);
+}
+
+.ccai-human-ai-turn {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  font-size: 12.5px;
+  padding-bottom: 6px;
+  border-bottom: 1px dashed var(--border-primary);
+}
+
+.ccai-human-ai-q {
+  color: var(--text-secondary);
+  font-style: italic;
+}
+
+.ccai-human-ai-a {
+  color: var(--text-primary);
+}
+
+.ccai-human-ai-current-q {
+  font-size: 13px;
+  color: var(--text-primary);
+  background: var(--card-bg);
+  border-left: 3px solid #16A34A;
+  padding: 6px 10px;
+  border-radius: 4px;
+}
+
+.ccai-human-ai-answer {
+  width: 100%;
+  border: 1px solid var(--border-primary);
+  border-radius: 6px;
+  background: var(--card-bg);
+  color: var(--text-primary);
+  font-family: inherit;
+  font-size: 13px;
+  padding: 8px 10px;
+  box-sizing: border-box;
+  resize: vertical;
+}
+
+.ccai-human-ai-answer:focus {
+  outline: none;
+  border-color: #16A34A;
+  box-shadow: 0 0 0 2px rgba(22, 163, 74, 0.18);
+}
+
+.ccai-human-ai-actions {
+  display: flex;
+  justify-content: flex-end;
+}
+
+.ccai-human-error {
+  font-size: 12.5px;
+  color: #DC2626;
+  background: rgba(220, 38, 38, 0.08);
+  border: 1px solid rgba(220, 38, 38, 0.3);
+  border-radius: 6px;
+  padding: 6px 10px;
+}
+
+.ccai-human-modal-footer {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 12px 20px 16px 20px;
+  border-top: 1px solid var(--border-primary);
+}
+
+.ccai-human-modal-footer-right {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.ccai-human-remove {
+  color: #DC2626;
+  border-color: rgba(220, 38, 38, 0.4);
+}
+
+.ccai-human-remove:hover {
+  background: rgba(220, 38, 38, 0.06);
+  border-color: #DC2626;
+}
+
+/* ── Sidebar: Human participant card ──────────────────────────── */
+
+.ccai-participant-card-human {
+  border-left: 4px solid #16A34A;
+}
+
+[data-theme="dark"] .ccai-participant-card-human {
+  border-left-color: #4ADE80;
+}
+
+.ccai-participant-human-tag {
+  display: inline-block;
+  margin-left: 8px;
+  padding: 1px 6px;
+  font-size: 10px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: #16A34A;
+  background: rgba(22, 163, 74, 0.1);
+  border-radius: 4px;
+}
+
+[data-theme="dark"] .ccai-participant-human-tag {
+  color: #4ADE80;
+  background: rgba(74, 222, 128, 0.12);
+}
+
+/* ── In-chat human input slot ─────────────────────────────────── */
+
+.ccai-human-slot {
+  display: flex;
+  align-items: stretch;
+  margin: 16px 0;
+  border-radius: 10px;
+  background: var(--card-bg);
+  border: 2px solid #16A34A;
+  box-shadow: 0 0 0 2px rgba(22, 163, 74, 0.12);
+  overflow: hidden;
+  animation: ccai-human-slot-pop 0.25s ease-out;
+}
+
+@keyframes ccai-human-slot-pop {
+  from { transform: scale(0.985); opacity: 0; }
+  to   { transform: scale(1);     opacity: 1; }
+}
+
+.ccai-human-slot-accent {
+  width: 6px;
+  background: #16A34A;
+  flex-shrink: 0;
+  animation: ccai-human-pulse-accent 1.6s ease-in-out infinite;
+}
+
+@keyframes ccai-human-pulse-accent {
+  0%   { background: #16A34A; }
+  50%  { background: #4ADE80; }
+  100% { background: #16A34A; }
+}
+
+.ccai-human-slot-body {
+  flex: 1;
+  padding: 12px 14px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.ccai-human-slot-header {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 13px;
+}
+
+.ccai-human-slot-name {
+  font-weight: 700;
+  color: #16A34A;
+}
+
+[data-theme="dark"] .ccai-human-slot-name {
+  color: #4ADE80;
+}
+
+.ccai-human-slot-pulse {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: #16A34A;
+  box-shadow: 0 0 0 0 rgba(22, 163, 74, 0.6);
+  animation: ccai-human-pulse-dot 1.4s ease-in-out infinite;
+}
+
+@keyframes ccai-human-pulse-dot {
+  0%   { box-shadow: 0 0 0 0 rgba(22, 163, 74, 0.6); }
+  70%  { box-shadow: 0 0 0 8px rgba(22, 163, 74, 0); }
+  100% { box-shadow: 0 0 0 0 rgba(22, 163, 74, 0); }
+}
+
+.ccai-human-slot-prompt {
+  color: var(--text-secondary);
+  font-style: italic;
+}
+
+.ccai-human-slot-context {
+  font-size: 12.5px;
+  color: var(--text-secondary);
+  background: rgba(22, 163, 74, 0.06);
+  border-left: 3px solid rgba(22, 163, 74, 0.6);
+  padding: 6px 10px;
+  border-radius: 4px;
+}
+
+.ccai-human-slot-textarea {
+  width: 100%;
+  border: 1px solid var(--border-primary);
+  border-radius: 6px;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  font-family: inherit;
+  font-size: 14px;
+  line-height: 1.45;
+  padding: 10px 12px;
+  resize: vertical;
+  min-height: 80px;
+  box-sizing: border-box;
+}
+
+.ccai-human-slot-textarea:focus {
+  outline: none;
+  border-color: #16A34A;
+  box-shadow: 0 0 0 2px rgba(22, 163, 74, 0.18);
+}
+
+.ccai-human-slot-actions {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+.ccai-human-slot-hint {
+  font-size: 11.5px;
+  color: var(--text-tertiary);
+}
+
+.ccai-human-slot-actions-right {
+  display: flex;
+  gap: 8px;
+}
+
+/* ── Bubble accent for the human's posted messages ────────────── */
+
+.ccai-message-row-human .ccai-bubble {
+  border-left: 4px solid #16A34A !important;
+  padding-left: 12px;
+}
+
+[data-theme="dark"] .ccai-message-row-human .ccai-bubble {
+  border-left-color: #4ADE80 !important;
+}
+
+/* ── Fixed-position lower-screen "waiting for your input" cue ──── */
+
+.ccai-human-indicator {
+  position: fixed;
+  bottom: 18px;
+  left: 50%;
+  transform: translateX(-50%);
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  padding: 10px 18px;
+  background: #16A34A;
+  color: #ffffff;
+  border: none;
+  border-radius: 999px;
+  font-size: 13px;
+  font-weight: 600;
+  letter-spacing: 0.01em;
+  box-shadow:
+    0 8px 22px rgba(22, 163, 74, 0.35),
+    0 0 0 0 rgba(22, 163, 74, 0.5);
+  cursor: pointer;
+  z-index: 80;
+  animation: ccai-human-indicator-pulse 1.8s ease-in-out infinite;
+}
+
+[data-theme="dark"] .ccai-human-indicator {
+  background: #22C55E;
+}
+
+@keyframes ccai-human-indicator-pulse {
+  0%   { box-shadow: 0 8px 22px rgba(22, 163, 74, 0.35), 0 0 0 0   rgba(22, 163, 74, 0.5); }
+  60%  { box-shadow: 0 8px 22px rgba(22, 163, 74, 0.35), 0 0 0 14px rgba(22, 163, 74, 0); }
+  100% { box-shadow: 0 8px 22px rgba(22, 163, 74, 0.35), 0 0 0 0   rgba(22, 163, 74, 0); }
+}
+
+.ccai-human-indicator:hover {
+  background: #15803D;
+}
+
+[data-theme="dark"] .ccai-human-indicator:hover {
+  background: #16A34A;
+}
+
+.ccai-human-indicator-arrow {
+  animation: ccai-human-indicator-arrow-bob 1.4s ease-in-out infinite;
+}
+
+@keyframes ccai-human-indicator-arrow-bob {
+  0%, 100% { transform: translateY(0); }
+  50%      { transform: translateY(3px); }
+}
+
+/* ── CredentialSummaryModal: human row + inline edit ──────────── */
+
+.ccai-credential-card-human {
+  border-left: 4px solid #16A34A;
+}
+
+[data-theme="dark"] .ccai-credential-card-human {
+  border-left-color: #4ADE80;
+}
+
+.ccai-credential-human-tag {
+  display: inline-block;
+  margin-left: 8px;
+  padding: 1px 6px;
+  font-size: 10px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  color: #16A34A;
+  background: rgba(22, 163, 74, 0.1);
+  border-radius: 4px;
+  vertical-align: middle;
+}
+
+[data-theme="dark"] .ccai-credential-human-tag {
+  color: #4ADE80;
+  background: rgba(74, 222, 128, 0.12);
+}
+
+.ccai-credential-edit-btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  margin-left: 8px;
+}
+
+.ccai-credential-card-editing {
+  background: rgba(22, 163, 74, 0.04);
+}
+
+[data-theme="dark"] .ccai-credential-card-editing {
+  background: rgba(74, 222, 128, 0.06);
+}
+
+.ccai-credential-edit-name {
+  padding: 4px 8px;
+  border: 1px solid var(--border-primary);
+  border-radius: 4px;
+  background: var(--card-bg);
+  color: var(--text-primary);
+  font-size: 14px;
+  font-weight: 600;
+  margin-left: 0;
+}
+
+.ccai-credential-row-edit {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.ccai-credential-row-input {
+  width: 100%;
+  padding: 6px 8px;
+  border: 1px solid var(--border-primary);
+  border-radius: 4px;
+  background: var(--card-bg);
+  color: var(--text-primary);
+  font-family: inherit;
+  font-size: 13px;
+  resize: vertical;
+  box-sizing: border-box;
+}
+
+.ccai-credential-row-input-num {
+  width: 90px;
+}
+
+.ccai-credential-edit-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  margin-top: 8px;
+}
+

frontend/src/utils/api.js

@@ -126,6 +126,8 @@ function eventHandlerKey(eventType) {
     case 'orchestrator_cap_pause': return 'onOrchestratorCapPause';
     case 'participant_error': return 'onParticipantError';
     case 'credentials_updated': return 'onCredentialsUpdated';
+    case 'human_turn_needed': return 'onHumanTurnNeeded';
+    case 'human_turn_cleared': return 'onHumanTurnCleared';
     default: return null;
   }
 }
@@ -244,6 +246,84 @@ export async function fetchCredentials(sessionId) {
   return resp.json();
 }
 
+/**
+ * Submit the human participant's response to the orchestrator for the
+ * currently pending turn. `skip=true` flips the turn into a "declined
+ * to comment" note rather than a message.
+ */
+export async function submitHumanResponse(sessionId, { text, skip = false } = {}) {
+  const resp = await fetch(`${API_BASE}/api/chat/${sessionId}/human-response`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ text: text || '', skip: !!skip }),
+  });
+  if (!resp.ok) {
+    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+    throw new Error(err.detail || 'Submit failed');
+  }
+  return resp.json();
+}
+
+/**
+ * Patch the in-the-loop human's credential summary. Used by the
+ * CredentialSummaryModal's edit affordance on the human's row. The
+ * backend rejects fields it doesn't know about; we send only the
+ * fields the user actually changed (sparse patch).
+ */
+export async function patchHumanCredential(sessionId, patch) {
+  const resp = await fetch(`${API_BASE}/api/chat/${sessionId}/credentials/human`, {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(patch),
+  });
+  if (!resp.ok) {
+    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+    throw new Error(err.detail || 'Edit failed');
+  }
+  return resp.json();
+}
+
+/**
+ * Start the AI-assisted credential intake Q&A flow. Returns either a
+ * first question or (rarely) a final summary if the LLM bails. The
+ * draft_id is needed for subsequent /answer calls.
+ */
+export async function startCredentialDraft({
+  name, question, max_questions = 6, orchestrator_model_id = null,
+}) {
+  const resp = await fetch(`${API_BASE}/api/chat/credentials/draft`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name, question, max_questions, orchestrator_model_id }),
+  });
+  if (!resp.ok) {
+    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+    throw new Error(err.detail || 'Credential draft start failed');
+  }
+  return resp.json();
+}
+
+export async function answerCredentialDraft(draftId, answer) {
+  const resp = await fetch(`${API_BASE}/api/chat/credentials/draft/${draftId}/answer`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ answer: answer || '' }),
+  });
+  if (!resp.ok) {
+    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+    throw new Error(err.detail || 'Credential draft answer failed');
+  }
+  return resp.json();
+}
+
+export async function cancelCredentialDraft(draftId) {
+  try {
+    await fetch(`${API_BASE}/api/chat/credentials/draft/${draftId}`, {
+      method: 'DELETE',
+    });
+  } catch (_) { /* fire-and-forget cleanup; ignore */ }
+}
+
 export async function getAuthStatus() {
   const resp = await fetch(`${API_BASE}/api/auth/status`, { credentials: 'include' });
   if (!resp.ok) return { logged_in: false, remaining_conversations: -1 };

frontend/src/utils/storage.js

@@ -28,6 +28,16 @@ const DEFAULTS = {
   // as the active mode and the per-persona checkboxes are hidden.
   // The auto-select happens just before /chat/start.
   auto_select_mode: false,
+  // In-the-loop human participant. null when no human is configured.
+  // Shape when set:
+  //   { participant_id, name, credential_summary: {
+  //       name, expertise, personality,
+  //       credibility_for_question, bias_to_watch
+  //     } }
+  // Persisted across page reloads so the user doesn't have to re-author
+  // their summary every session. Cleared from storage when the user
+  // removes the human via the sidebar.
+  human_participant: null,
 };
 
 function readAll() {
@@ -104,3 +114,7 @@ export function setConversationLimits(limitsMap) {
 export function setAutoSelectMode(on) {
   return patchState({ auto_select_mode: !!on });
 }
+
+export function setHumanParticipant(humanOrNull) {
+  return patchState({ human_participant: humanOrNull || null });
+}