feat(conversation): pluggable structures + decision methods (Robert's Rules, ranked-choice, majority)

The orchestrator is now structured as ConversationStructure → DecisionMethod
plugins joined by a standardized DecisionInput contract. The existing
six-phase flow is preserved as CollaborativeDiscussion + ConsensusDecision
(unchanged behavior); three new decision methods (MajorityRulesDecision,
RankedChoiceDecision, RobertsRulesVote) and one new structure
(RobertsRulesDiscussion) are wired into the registry. Adding a new
structure or decision method now means dropping a class into
backend/app/services/conversation/{structures,decisions}/ and adding
one line to the registry.

Backend
- New package backend/app/services/conversation/ with base classes,
DecisionInput contract, and a get_structure/get_decision registry
resolver (defaults: collaborative + consensus, so older /chat/start
payloads keep working).
- CollaborativeDiscussion + ConsensusDecision are thin wrappers over
the original _phase_* functions in orchestrator.py — zero behavior
change for the default path.
- RobertsRulesDiscussion implements opening → initial remarks → main
motion synthesis (+ seconder) → debate rounds → call the question;
hands off a DecisionInput populated with main_motion and per-member
finalized positions.
- MajorityRulesDecision: clusters finalized positions into <=6 option
labels via the orchestrator LLM, polls each AI participant for one
vote, tallies plurality. With a main_motion, switches to aye/nay/
abstain.
- RankedChoiceDecision: each participant fully ranks the options;
IRV picks a winner (with deterministic bottom-tie elimination).
- RobertsRulesVote: aye/nay/abstain on the main motion with
parliamentary phrasing; synthesizes a motion from finalized
positions if paired with a non-RR structure.
- Voting helpers (extract_candidate_options, cast_vote_*, tally_*,
run_irv) live in conversation/voting.py and are decision-method
agnostic.
- run_conversation in orchestrator.py becomes a thin dispatcher that
resolves structure + decision IDs from the session.
- StartChatRequest accepts conversation_structure_id and
decision_method_id; Session carries the choices plus main_motion /
proposed_motions for RR state.
- New GET /api/chat/conversation-formats endpoint exposes the catalog
so the frontend picker is driven by the server (no code change
needed to add plugins).
- New Phase enum values: RR_OPENING, RR_INITIAL_REMARKS, RR_MOTION,
RR_DEBATE, RR_MOVE_THE_QUESTION, VOTING.

Frontend
- New "Conversation format" accordion in Settings → DevMenu with
Structure + Decision picker lists; catalog hydrated on mount,
selections persisted to localStorage and sent in the /chat/start
payload.
- New SSE event mappings: vote_cast (per-ballot system note) and
vote_tally (one-line summary).
- OrchestratorMessage.js renders new kinds: vote_result,
ranked_choice_result, motion, ballot_options, rr_opening,
rr_call_the_question (with kind-aware label suffixes; vote_result
and ranked_choice_result get the report visual treatment).

Verified
- All 60 backend tests pass.
- Frontend production build compiles clean.
- Module-level smoke test: default + non-default IDs resolve, unknown
IDs fall back to defaults, all phases load.
- IRV / plurality / yes-no tally helpers smoke-tested with mixed
ballot shapes (clear winners, runoffs, ties, abstentions).

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

backend/app/api/chat.py

@@ -166,6 +166,13 @@ class StartChatRequest(BaseModel):
     # that has kind == "human". Capped at one human per session.
     human_credential: HumanCredentialPayload | None = None
 
+    # Conversation-format plugin selection. IDs come from
+    # app.services.conversation.STRUCTURE_REGISTRY /
+    # DECISION_REGISTRY. Missing or unknown IDs are silently coerced
+    # to the defaults (collaborative + consensus) at start time.
+    conversation_structure_id: str | None = None
+    decision_method_id: str | None = None
+
 
 # ---------------------------------------------------------------------------
 # Settings endpoints (orchestrator default + speed priority)
@@ -187,6 +194,29 @@ async def api_get_speed_priority():
     return {"enabled": settings.speed_priority}
 
 
+@router.get("/chat/conversation-formats")
+async def api_conversation_formats():
+    """Catalog the available conversation structures + decision methods.
+
+    The frontend reads this once to populate the "Conversation format"
+    accordion in Settings. IDs returned here are the same values
+    accepted by /chat/start under `conversation_structure_id` and
+    `decision_method_id`.
+    """
+    from app.services.conversation import (
+        list_structures,
+        list_decisions,
+        DEFAULT_STRUCTURE_ID,
+        DEFAULT_DECISION_ID,
+    )
+    return {
+        "structures": list_structures(),
+        "decisions": list_decisions(),
+        "default_structure_id": DEFAULT_STRUCTURE_ID,
+        "default_decision_id": DEFAULT_DECISION_ID,
+    }
+
+
 @router.put("/chat/speed-priority")
 async def api_set_speed_priority(req: SetSpeedPriorityRequest):
     settings.speed_priority = req.enabled
@@ -565,6 +595,20 @@ async def api_start_chat(req: StartChatRequest, request: Request):
             ))
     session.candidate_pool = candidate_pool
     session.substitution_chain = build_substitution_chain(neon_hana_model_ids)
+
+    # Conversation-format plugin selection. Coerce unknown IDs to the
+    # defaults via the get_structure/get_decision resolvers.
+    from app.services.conversation import (
+        get_structure as _get_structure_cls,
+        get_decision as _get_decision_cls,
+        STRUCTURE_REGISTRY as _STRUCT_REG,
+        DECISION_REGISTRY as _DEC_REG,
+    )
+    if req.conversation_structure_id and req.conversation_structure_id in _STRUCT_REG:
+        session.conversation_structure_id = req.conversation_structure_id
+    if req.decision_method_id and req.decision_method_id in _DEC_REG:
+        session.decision_method_id = req.decision_method_id
+
     if humans and req.human_credential is not None:
         session.human_credential = normalize_one_credential({
             "participant_id": req.human_credential.participant_id,

backend/app/services/conversation/__init__.py

@@ -0,0 +1,86 @@
+"""Pluggable conversation structures and decision-making methods.
+
+The orchestrator drives one ConversationStructure (how the discussion
+is organized) followed by one DecisionMethod (how a verdict is
+reached). The two are decoupled by the `DecisionInput` contract in
+`types.py`: every structure produces one, every method consumes one,
+so in principle any combination is valid.
+
+Adding a new structure or decision method means:
+
+  1. Subclass `ConversationStructure` or `DecisionMethod` in
+     `structures/` or `decisions/`.
+  2. Register the class in the appropriate registry below.
+
+Built-in choices:
+
+  Structures:
+    - "collaborative" → CollaborativeDiscussion (default)
+    - "roberts_rules" → RobertsRulesDiscussion
+
+  Decision methods:
+    - "consensus" → ConsensusDecision (default)
+    - "majority" → MajorityRulesDecision
+    - "ranked_choice" → RankedChoiceDecision
+    - "roberts_rules_vote" → RobertsRulesVote
+"""
+from __future__ import annotations
+
+from typing import Type
+
+from app.services.conversation.decisions.base import DecisionMethod
+from app.services.conversation.decisions.consensus import ConsensusDecision
+from app.services.conversation.decisions.majority import MajorityRulesDecision
+from app.services.conversation.decisions.ranked_choice import RankedChoiceDecision
+from app.services.conversation.decisions.roberts_rules_vote import RobertsRulesVote
+from app.services.conversation.structures.base import ConversationStructure
+from app.services.conversation.structures.collaborative import CollaborativeDiscussion
+from app.services.conversation.structures.roberts_rules import RobertsRulesDiscussion
+from app.services.conversation.types import DecisionInput  # noqa: F401  re-export
+
+DEFAULT_STRUCTURE_ID = "collaborative"
+DEFAULT_DECISION_ID = "consensus"
+
+
+STRUCTURE_REGISTRY: dict[str, Type[ConversationStructure]] = {
+    "collaborative": CollaborativeDiscussion,
+    "roberts_rules": RobertsRulesDiscussion,
+}
+
+
+DECISION_REGISTRY: dict[str, Type[DecisionMethod]] = {
+    "consensus": ConsensusDecision,
+    "majority": MajorityRulesDecision,
+    "ranked_choice": RankedChoiceDecision,
+    "roberts_rules_vote": RobertsRulesVote,
+}
+
+
+def get_structure(structure_id: str | None) -> Type[ConversationStructure]:
+    """Resolve a structure id to its class, defaulting on miss."""
+    if not structure_id or structure_id not in STRUCTURE_REGISTRY:
+        return STRUCTURE_REGISTRY[DEFAULT_STRUCTURE_ID]
+    return STRUCTURE_REGISTRY[structure_id]
+
+
+def get_decision(decision_id: str | None) -> Type[DecisionMethod]:
+    """Resolve a decision-method id to its class, defaulting on miss."""
+    if not decision_id or decision_id not in DECISION_REGISTRY:
+        return DECISION_REGISTRY[DEFAULT_DECISION_ID]
+    return DECISION_REGISTRY[decision_id]
+
+
+def list_structures() -> list[dict[str, str]]:
+    """Catalog data for the frontend picker."""
+    return [
+        {"id": sid, "name": cls.NAME, "description": cls.DESCRIPTION}
+        for sid, cls in STRUCTURE_REGISTRY.items()
+    ]
+
+
+def list_decisions() -> list[dict[str, str]]:
+    """Catalog data for the frontend picker."""
+    return [
+        {"id": did, "name": cls.NAME, "description": cls.DESCRIPTION}
+        for did, cls in DECISION_REGISTRY.items()
+    ]

backend/app/services/conversation/decisions/__init__.py

@@ -0,0 +1 @@
+"""DecisionMethod plugins. See `..__init__.py` for the registry."""

backend/app/services/conversation/decisions/base.py

@@ -0,0 +1,45 @@
+"""Base class every DecisionMethod plugin inherits.
+
+A decision method takes the `DecisionInput` produced by the
+ConversationStructure and runs whatever process yields a verdict —
+collaborative consensus, ranked-choice vote, simple majority, etc.
+
+Subclasses should:
+
+  1. Override `NAME` and `DESCRIPTION` for the frontend picker.
+  2. Implement `run()` as an async generator that yields SSE chunks.
+  3. Populate `session.final_report` with a dict the frontend can
+     render. Conventionally:
+        { "kind": "<decision-flavored kind>",
+          "text": "<human-readable summary>",
+          ... any per-method extras ... }
+     The `kind` flows into `orchestrator` SSE messages so
+     `OrchestratorMessage.js` can render distinct headers.
+
+Plugins live in this directory and are registered in
+`app/services/conversation/__init__.py`.
+"""
+from __future__ import annotations
+
+from typing import AsyncIterator, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from app.services.conversation.types import DecisionInput
+    from app.services.models import Session
+
+
+class DecisionMethod:
+    """Abstract base; subclass and override `NAME`, `DESCRIPTION`,
+    and `run()`."""
+
+    NAME: str = "Decision"
+    DESCRIPTION: str = ""
+
+    def __init__(self, session: "Session", decision_input: "DecisionInput") -> None:
+        self.session = session
+        self.decision_input = decision_input
+
+    async def run(self) -> AsyncIterator[str]:  # noqa: D401
+        """Drive the decision phase. Yields SSE chunks."""
+        raise NotImplementedError
+        yield  # pragma: no cover

backend/app/services/conversation/decisions/consensus.py

@@ -0,0 +1,43 @@
+"""Consensus — the original CCAI decision-making mode.
+
+This is a thin wrapper over the existing Phase 5/6 implementation in
+`app.services.orchestrator`. The structure produces a DecisionInput
+with finalized positions; we discard the input fields here because
+the consensus phase reads `session.final_opinions`,
+`session.alliance_groups`, etc. directly. The wrapper exists so the
+dispatcher in orchestrator.py can treat Consensus uniformly with the
+new decision methods.
+
+Behavior:
+  Phase 5: Consensus deliberation (turn-based, alliance-aware,
+           with dyad caps and addressed-to routing).
+  Phase 6: Closure — if a majority emerges, emit a majority report;
+           otherwise either re-run consensus with a surfaced
+           "unaddressed factor" or emit a no-consensus report.
+"""
+from __future__ import annotations
+
+from typing import AsyncIterator
+
+from app.services.conversation.decisions.base import DecisionMethod
+
+
+class ConsensusDecision(DecisionMethod):
+    NAME = "Consensus"
+    DESCRIPTION = (
+        "Participants deliberate until either an alliance forms with "
+        "majority support, or the orchestrator reports no consensus "
+        "with the remaining points of disagreement."
+    )
+
+    async def run(self) -> AsyncIterator[str]:
+        from app.services.orchestrator import (
+            _phase_consensus,
+            _phase_closure,
+        )
+
+        async for chunk in _phase_consensus(self.session):
+            yield chunk
+
+        async for chunk in _phase_closure(self.session):
+            yield chunk

backend/app/services/conversation/decisions/majority.py

@@ -0,0 +1,224 @@
+"""Majority-rules voting decision method.
+
+Two voting modes, chosen automatically:
+
+  * If the structure handed us a `main_motion` (Robert's Rules
+    typically does), each participant votes aye/nay/abstain on it.
+    Motion passes if ayes > nays.
+
+  * Otherwise, the orchestrator clusters finalized positions into a
+    small set of option labels (or uses `proposed_candidates` from
+    the structure if present), and each participant votes for ONE
+    option. Highest vote count wins.
+
+A tie at the top is reported as a "no winner" outcome — we don't
+auto-break ties because the user's design intent for majority rules
+is "most votes wins, period".
+
+Emits SSE events:
+  * `status` — phase announcement and progress.
+  * `vote_cast` — one per ballot.
+  * `vote_tally` — final counts (so the frontend can render a chart).
+  * `orchestrator` — the final report with `kind == "vote_result"`.
+"""
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from app.services.conversation.decisions.base import DecisionMethod
+from app.services.conversation.voting import (
+    cast_vote_single,
+    cast_vote_yesno,
+    extract_candidate_options,
+    tally_single_votes,
+    tally_yesno_votes,
+)
+from app.services.models import Phase
+
+
+class MajorityRulesDecision(DecisionMethod):
+    NAME = "Majority Rules Voting"
+    DESCRIPTION = (
+        "Each participant votes for one option (or aye/nay on a "
+        "motion). The choice with the most votes wins; ties are "
+        "reported as no-winner."
+    )
+
+    async def run(self) -> AsyncIterator[str]:
+        from app.services.orchestrator import (
+            _sse,
+            _add_orchestrator_message,
+            _msg_payload,
+        )
+
+        session = self.session
+        di = self.decision_input
+        session.phase = Phase.VOTING
+        yield _sse("status", {"message": "Phase 5: majority vote..."})
+
+        # AI participants only — humans abstain in the automated path.
+        voters = [p for p in di.participants if p.kind != "human"]
+        if not voters:
+            yield _sse("error", {"message": "No AI participants left to vote."})
+            return
+
+        if di.main_motion:
+            async for chunk in self._run_motion_vote(voters, di.main_motion):
+                yield chunk
+            return
+
+        # Plurality vote on derived candidates
+        async for chunk in self._run_plurality_vote(voters):
+            yield chunk
+
+    async def _run_motion_vote(self, voters, motion: str) -> AsyncIterator[str]:
+        from app.services.orchestrator import (
+            _sse,
+            _add_orchestrator_message,
+            _msg_payload,
+        )
+
+        session = self.session
+        announce_text = f"The motion on the floor is: \"{motion}\""
+        msg = _add_orchestrator_message(
+            session, announce_text, kind="motion", extra={"motion": motion},
+        )
+        yield _sse("orchestrator", _msg_payload(msg))
+
+        ballots: list[dict[str, Any]] = []
+        for p in voters:
+            result = await cast_vote_yesno(
+                session=session, participant=p, motion=motion,
+            )
+            ballot = {
+                "voter_id": p.participant_id,
+                "voter_name": p.name,
+                "vote": result.get("vote", ""),
+                "reason": result.get("reason", ""),
+                "ok": result.get("ok", False),
+            }
+            ballots.append(ballot)
+            yield _sse("vote_cast", ballot)
+
+        tally = tally_yesno_votes(ballots)
+        yield _sse("vote_tally", {"kind": "yesno", "tally": tally})
+
+        verdict = "PASSES" if tally["passes"] else (
+            "FAILS" if tally["majority"] != "tie" else "is TIED (no winner)"
+        )
+        text = (
+            f"The motion {verdict}.\n\n"
+            f"Aye: {tally['aye']}    Nay: {tally['nay']}    "
+            f"Abstain: {tally['abstain']}\n\n"
+            f"Motion: {motion}"
+        )
+        session.final_report = {
+            "kind": "vote_result",
+            "text": text,
+            "vote_kind": "yesno",
+            "motion": motion,
+            "tally": tally,
+            "ballots": ballots,
+        }
+        msg = _add_orchestrator_message(
+            session, text, kind="vote_result",
+            extra={"vote_kind": "yesno", "tally": tally, "motion": motion},
+        )
+        yield _sse("orchestrator", _msg_payload(msg))
+
+    async def _run_plurality_vote(self, voters) -> AsyncIterator[str]:
+        from app.services.orchestrator import (
+            _sse,
+            _add_orchestrator_message,
+            _msg_payload,
+        )
+
+        session = self.session
+        di = self.decision_input
+
+        # Use structure-proposed candidates if available; else derive.
+        options = list(di.proposed_candidates or [])
+        if not options:
+            yield _sse("status", {"message": "Identifying voting options..."})
+            options = await extract_candidate_options(
+                session=session,
+                question=di.question,
+                positions=di.finalized_positions,
+                participants=di.participants,
+            )
+
+        if len(options) < 2:
+            yield _sse("error", {
+                "message": "Not enough distinct positions to hold a vote.",
+            })
+            return
+
+        options_label = "\n".join(f"  {i + 1}. {o}" for i, o in enumerate(options))
+        announce = f"The following options are on the ballot:\n{options_label}"
+        msg = _add_orchestrator_message(
+            session, announce, kind="ballot_options",
+            extra={"options": options},
+        )
+        yield _sse("orchestrator", _msg_payload(msg))
+
+        ballots: list[dict[str, Any]] = []
+        for p in voters:
+            result = await cast_vote_single(
+                session=session, participant=p, question=di.question,
+                options=options,
+            )
+            ballot = {
+                "voter_id": p.participant_id,
+                "voter_name": p.name,
+                "choice": result.get("choice", 0),
+                "reason": result.get("reason", ""),
+                "ok": result.get("ok", False),
+            }
+            ballots.append(ballot)
+            yield _sse("vote_cast", ballot)
+
+        tally = tally_single_votes(ballots, len(options))
+        yield _sse("vote_tally", {
+            "kind": "plurality", "tally": tally, "options": options,
+        })
+
+        if tally["winner"] > 0:
+            winner_text = options[tally["winner"] - 1]
+            summary = (
+                f"Winning option: \"{winner_text}\" "
+                f"({tally['counts'][tally['winner'] - 1]} of "
+                f"{tally['total_cast']} votes)"
+            )
+        elif tally["tied_for_first"]:
+            tied_names = ", ".join(
+                f"\"{options[i - 1]}\"" for i in tally["tied_for_first"]
+            )
+            summary = (
+                f"Tied for first ({tally['counts'][tally['tied_for_first'][0] - 1]} votes each): "
+                f"{tied_names}. No winner under majority-rules."
+            )
+        else:
+            summary = "No votes were cast successfully — no winner."
+
+        details = "\n".join(
+            f"  - \"{opt}\": {tally['counts'][i]} vote(s)"
+            for i, opt in enumerate(options)
+        )
+        text = f"{summary}\n\nFull tally:\n{details}"
+        session.final_report = {
+            "kind": "vote_result",
+            "text": text,
+            "vote_kind": "plurality",
+            "options": options,
+            "tally": tally,
+            "ballots": ballots,
+        }
+        msg = _add_orchestrator_message(
+            session, text, kind="vote_result",
+            extra={
+                "vote_kind": "plurality",
+                "tally": tally,
+                "options": options,
+            },
+        )
+        yield _sse("orchestrator", _msg_payload(msg))

backend/app/services/conversation/decisions/ranked_choice.py

@@ -0,0 +1,170 @@
+"""Ranked-choice (instant-runoff) voting decision method.
+
+Each participant ranks ALL options. If an option holds >50% of
+first-choice votes it wins immediately. Otherwise the option with
+the fewest first-choice votes is eliminated and its voters'
+next-still-eligible choices are redistributed; the process repeats
+until a winner emerges or all remaining options tie at the bottom.
+
+When the structure handed us a `main_motion` we still hold a ranked
+vote, treating the motion text as Option 1 and the structure's
+`proposed_candidates` (or derived clusters of finalized positions)
+as the additional options. This is the user's "RR + RCV" combo: the
+chair's motion is on the ballot but doesn't get a privileged spot.
+
+Emits SSE events:
+  * `status` for progress.
+  * `vote_cast` per ballot (with the full ranking).
+  * `vote_tally` with the per-round IRV breakdown.
+  * `orchestrator` for the final report (`kind == "ranked_choice_result"`).
+"""
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from app.services.conversation.decisions.base import DecisionMethod
+from app.services.conversation.voting import (
+    cast_vote_ranking,
+    extract_candidate_options,
+    run_irv,
+)
+from app.services.models import Phase
+
+
+class RankedChoiceDecision(DecisionMethod):
+    NAME = "Ranked Choice Voting"
+    DESCRIPTION = (
+        "Each participant ranks all options from most to least "
+        "preferred. The winner is found by instant runoff: lowest "
+        "first-choice option is dropped each round, votes "
+        "redistribute, repeat until a majority emerges."
+    )
+
+    async def run(self) -> AsyncIterator[str]:
+        from app.services.orchestrator import (
+            _sse,
+            _add_orchestrator_message,
+            _msg_payload,
+        )
+
+        session = self.session
+        di = self.decision_input
+        session.phase = Phase.VOTING
+        yield _sse("status", {"message": "Phase 5: ranked-choice vote..."})
+
+        voters = [p for p in di.participants if p.kind != "human"]
+        if not voters:
+            yield _sse("error", {"message": "No AI participants left to vote."})
+            return
+
+        options: list[str] = []
+        if di.main_motion:
+            options.append(di.main_motion)
+        if di.proposed_candidates:
+            for o in di.proposed_candidates:
+                if o and o not in options:
+                    options.append(o)
+        if len(options) < 2:
+            yield _sse("status", {"message": "Identifying voting options..."})
+            derived = await extract_candidate_options(
+                session=session, question=di.question,
+                positions=di.finalized_positions,
+                participants=di.participants,
+            )
+            for o in derived:
+                if o and o not in options:
+                    options.append(o)
+
+        if len(options) < 2:
+            yield _sse("error", {
+                "message": "Not enough distinct positions for a ranked vote.",
+            })
+            return
+
+        options_label = "\n".join(f"  {i + 1}. {o}" for i, o in enumerate(options))
+        announce = (
+            f"The following options will be ranked by each participant:\n"
+            f"{options_label}"
+        )
+        msg = _add_orchestrator_message(
+            session, announce, kind="ballot_options",
+            extra={"options": options},
+        )
+        yield _sse("orchestrator", _msg_payload(msg))
+
+        ballots: list[dict[str, Any]] = []
+        rankings_only: list[list[int]] = []
+        for p in voters:
+            result = await cast_vote_ranking(
+                session=session, participant=p,
+                question=di.question, options=options,
+            )
+            ranking = result.get("ranking") or []
+            ballots.append({
+                "voter_id": p.participant_id,
+                "voter_name": p.name,
+                "ranking": ranking,
+                "reason": result.get("reason", ""),
+                "ok": result.get("ok", False),
+            })
+            rankings_only.append(list(ranking))
+            yield _sse("vote_cast", {
+                "voter_id": p.participant_id,
+                "voter_name": p.name,
+                "ranking": ranking,
+                "reason": result.get("reason", ""),
+                "ok": result.get("ok", False),
+            })
+
+        irv = run_irv(rankings_only, len(options))
+        yield _sse("vote_tally", {
+            "kind": "ranked_choice",
+            "options": options,
+            "irv": irv,
+        })
+
+        if irv["winner"] > 0:
+            winner_text = options[irv["winner"] - 1]
+            summary = (
+                f"Winning option: \"{winner_text}\" "
+                f"({len(irv['rounds'])} round(s) of instant runoff)."
+            )
+        elif irv.get("tied"):
+            summary = (
+                "All remaining options tied at the bottom of the final "
+                "round — no winner under ranked-choice."
+            )
+        else:
+            summary = (
+                "No valid ballots — no winner. (LLM voters may have "
+                "returned malformed rankings.)"
+            )
+
+        rounds_block = []
+        for r in irv["rounds"]:
+            line_counts = ", ".join(
+                f"\"{options[opt - 1]}\": {c}"
+                for opt, c in sorted(r["counts"].items())
+            )
+            line = f"  Round {r['round']}: {line_counts}"
+            if r.get("eliminated"):
+                line += f"  → eliminated \"{options[r['eliminated'] - 1]}\""
+            if r.get("winner"):
+                line += f"  → WINNER \"{options[r['winner'] - 1]}\""
+            rounds_block.append(line)
+
+        text = (
+            f"{summary}\n\nInstant-runoff rounds:\n" + "\n".join(rounds_block)
+        )
+        session.final_report = {
+            "kind": "ranked_choice_result",
+            "text": text,
+            "options": options,
+            "irv": irv,
+            "ballots": ballots,
+        }
+        msg = _add_orchestrator_message(
+            session, text, kind="ranked_choice_result",
+            extra={"options": options, "irv": irv},
+        )
+        yield _sse("orchestrator", _msg_payload(msg))

backend/app/services/conversation/decisions/roberts_rules_vote.py

@@ -0,0 +1,163 @@
+"""Robert's Rules vote — aye/nay/abstain on the main motion.
+
+Functionally identical to MajorityRulesDecision's motion-vote path,
+but presented with Robert's Rules phrasing ("The chair calls for the
+vote on the main motion...") so the conversation reads cleanly when
+the user pairs it with RobertsRulesDiscussion. It's still a separate
+plugin so the registry can list it as a first-class choice and the
+frontend picker can label it accordingly.
+
+If invoked WITHOUT a `main_motion` (e.g. the user paired this
+decision method with the Collaborative structure), we synthesize a
+motion from the finalized positions and put that on the floor —
+giving sensible behavior across all structure / decision pairings.
+"""
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from app.services.conversation.decisions.base import DecisionMethod
+from app.services.conversation.voting import (
+    cast_vote_yesno,
+    tally_yesno_votes,
+)
+from app.services.json_calls import orchestrator_call
+from app.services.models import Phase
+
+
+SYNTHESIZE_MOTION_PROMPT = """You are acting as the chair of a meeting.
+
+The body has been discussing the following question:
+  {question}
+
+The participants' final positions are:
+{positions_block}
+
+As chair, propose a single concrete motion that captures the most \
+widely-supported position. Phrase it as a complete sentence starting \
+with "Resolved, that" or "I move that".
+
+Return ONLY this JSON (no prose, no fences):
+{{
+  "motion": "..."
+}}
+"""
+
+
+class RobertsRulesVote(DecisionMethod):
+    NAME = "Robert's Rules Vote"
+    DESCRIPTION = (
+        "The chair puts the main motion to the assembly. Each "
+        "member casts aye, nay, or abstain. Motion passes on simple "
+        "majority of those voting."
+    )
+
+    async def run(self) -> AsyncIterator[str]:
+        from app.services.orchestrator import (
+            _sse,
+            _add_orchestrator_message,
+            _msg_payload,
+            _orchestrator_model_id,
+            _bump_orchestrator_count,
+            _format_history,
+        )
+
+        session = self.session
+        di = self.decision_input
+        session.phase = Phase.VOTING
+        yield _sse("status", {"message": "Phase 5: Robert's Rules vote..."})
+
+        voters = [p for p in di.participants if p.kind != "human"]
+        if not voters:
+            yield _sse("error", {"message": "No AI members present to vote."})
+            return
+
+        motion = (di.main_motion or "").strip()
+        if not motion:
+            # Synthesize a motion from finalized positions.
+            from app.services.conversation.voting import _format_positions_block
+            yield _sse("status", {"message": "Chair: drafting a motion..."})
+            prompt = SYNTHESIZE_MOTION_PROMPT.format(
+                question=di.question,
+                positions_block=_format_positions_block(
+                    di.finalized_positions, di.participants,
+                ),
+            )
+            _, parsed = await orchestrator_call(
+                orchestrator_model_id=_orchestrator_model_id(session),
+                user_prompt=prompt,
+                label="rr_synthesize_motion",
+                api_log=session.api_log,
+                expect_json=True,
+                max_tokens=400,
+                temperature=0.3,
+            )
+            _bump_orchestrator_count(session)
+            if isinstance(parsed, dict):
+                motion = str(parsed.get("motion") or "").strip()
+            if not motion:
+                motion = (
+                    "Resolved, that the assembly accepts the consensus "
+                    "view reflected by the majority of stated positions."
+                )
+            session.main_motion = motion
+
+        announce = (
+            "The chair puts the following motion before the assembly:\n\n"
+            f"\"{motion}\"\n\n"
+            "The chair calls for the vote. Members will say aye, nay, "
+            "or abstain."
+        )
+        msg = _add_orchestrator_message(
+            session, announce, kind="motion", extra={"motion": motion},
+        )
+        yield _sse("orchestrator", _msg_payload(msg))
+
+        ballots: list[dict[str, Any]] = []
+        for p in voters:
+            result = await cast_vote_yesno(
+                session=session, participant=p, motion=motion,
+            )
+            ballot = {
+                "voter_id": p.participant_id,
+                "voter_name": p.name,
+                "vote": result.get("vote", ""),
+                "reason": result.get("reason", ""),
+                "ok": result.get("ok", False),
+            }
+            ballots.append(ballot)
+            yield _sse("vote_cast", ballot)
+
+        tally = tally_yesno_votes(ballots)
+        yield _sse("vote_tally", {"kind": "yesno", "tally": tally})
+
+        if tally["passes"]:
+            verdict = "The motion is carried."
+        elif tally["majority"] == "nay":
+            verdict = "The motion is lost."
+        else:
+            verdict = "The motion is tied; the chair declares it lost."
+
+        text = (
+            f"{verdict}\n\n"
+            f"Aye: {tally['aye']}    Nay: {tally['nay']}    "
+            f"Abstain: {tally['abstain']}\n\n"
+            f"Motion: \"{motion}\""
+        )
+        session.final_report = {
+            "kind": "vote_result",
+            "text": text,
+            "vote_kind": "yesno",
+            "motion": motion,
+            "tally": tally,
+            "ballots": ballots,
+            "flavor": "roberts_rules",
+        }
+        msg = _add_orchestrator_message(
+            session, text, kind="vote_result",
+            extra={
+                "vote_kind": "yesno", "tally": tally, "motion": motion,
+                "flavor": "roberts_rules",
+            },
+        )
+        yield _sse("orchestrator", _msg_payload(msg))

backend/app/services/conversation/structures/__init__.py

@@ -0,0 +1 @@
+"""ConversationStructure plugins. See `..__init__.py` for the registry."""

backend/app/services/conversation/structures/base.py

@@ -0,0 +1,55 @@
+"""Base class every ConversationStructure plugin inherits.
+
+A structure drives the *discussion* phase of a chat: how participants
+present their views, debate, refine, and finalize positions. It does
+NOT decide the verdict — that's the DecisionMethod's job. The two are
+joined by `DecisionInput` (see `..types`).
+
+Subclasses should:
+
+  1. Override `NAME` and `DESCRIPTION` so the frontend picker can
+     present a sensible label.
+  2. Implement `run()` as an async generator that yields SSE chunks.
+     Use the orchestrator's `_sse(...)` helper (imported lazily so
+     this module doesn't pull in the whole orchestrator) — see
+     existing structures for the pattern.
+  3. Implement `build_decision_input()` to return a `DecisionInput`
+     populated from the session state your `run()` produced.
+
+Plugins live in this directory and are registered in
+`app/services/conversation/__init__.py`.
+"""
+from __future__ import annotations
+
+from typing import AsyncIterator, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from app.services.conversation.types import DecisionInput
+    from app.services.models import Session
+
+
+class ConversationStructure:
+    """Abstract base; subclass and override `NAME`, `DESCRIPTION`,
+    `run()`, and `build_decision_input()`."""
+
+    #: Short label shown in the Settings menu.
+    NAME: str = "Conversation"
+
+    #: One-line description for the picker tooltip.
+    DESCRIPTION: str = ""
+
+    def __init__(self, session: "Session") -> None:
+        self.session = session
+
+    async def run(self) -> AsyncIterator[str]:  # noqa: D401
+        """Drive the discussion. Yields SSE chunks."""
+        raise NotImplementedError
+        yield  # pragma: no cover  # keeps mypy happy that this is a generator
+
+    def build_decision_input(self) -> "DecisionInput":
+        """Produce the standardized hand-off for the decision phase.
+
+        Called once `run()` completes. The result is passed verbatim
+        to the chosen DecisionMethod's constructor.
+        """
+        raise NotImplementedError

backend/app/services/conversation/structures/collaborative.py

@@ -0,0 +1,75 @@
+"""Collaborative Discussion — the original CCAI structure.
+
+This is a thin wrapper over the existing Phase 1-4 implementation in
+`app.services.orchestrator`. We keep the function bodies in
+orchestrator.py for now (less code churn during the plugin refactor)
+and the plugin just dispatches to them in the historical order:
+
+  Phase 1: Initial opinions (each participant speaks once with no
+           transcript, so first opinions are independent).
+  Phase 2: Critique rounds (1-4, configurable). Each participant
+           critiques / agrees with / builds on what others said.
+  Phase 3: Status assessment + targeted follow-ups (orchestrator
+           surfaces open questions; max iterations from limits).
+  Phase 4: Finalization (each participant states a final opinion,
+           which is what we hand off to the decision phase).
+
+When this structure finishes, `session.final_opinions[pid]` holds
+each AI participant's last word. We marshal that into a
+DecisionInput so any DecisionMethod can take over.
+"""
+from __future__ import annotations
+
+from typing import AsyncIterator, TYPE_CHECKING
+
+from app.services.conversation.structures.base import ConversationStructure
+from app.services.conversation.types import DecisionInput
+
+if TYPE_CHECKING:
+    pass
+
+
+class CollaborativeDiscussion(ConversationStructure):
+    NAME = "Collaborative Discussion"
+    DESCRIPTION = (
+        "Initial opinions, then critique rounds, then a status check "
+        "for unanswered questions, then a final opinion from each "
+        "participant."
+    )
+
+    async def run(self) -> AsyncIterator[str]:
+        # Lazy import so this module can be loaded without dragging
+        # in the whole orchestrator (and so orchestrator.py can in
+        # turn import the structures registry without a cycle).
+        from app.services.orchestrator import (
+            _phase_initial_opinions,
+            _phase_critique,
+            _phase_status_assessment,
+            _phase_finalization,
+        )
+
+        async for chunk in _phase_initial_opinions(self.session):
+            yield chunk
+
+        for round_n in range(1, self.session.limits.critique_rounds + 1):
+            async for chunk in _phase_critique(self.session, round_n):
+                yield chunk
+
+        async for chunk in _phase_status_assessment(self.session):
+            yield chunk
+
+        async for chunk in _phase_finalization(self.session):
+            yield chunk
+
+    def build_decision_input(self) -> DecisionInput:
+        # Filter out disabled participants here — the decision phase
+        # always speaks about the *active* roster, not whoever started
+        # the chat. (Auto-disable in Phase 1/2 means some original
+        # participants may have been removed.)
+        actives = [p for p in self.session.participants if p.enabled]
+        return DecisionInput(
+            question=self.session.question,
+            participants=actives,
+            transcript_messages=list(self.session.messages),
+            finalized_positions=dict(self.session.final_opinions),
+        )

backend/app/services/conversation/structures/roberts_rules.py

@@ -0,0 +1,359 @@
+"""Robert's Rules of Order — chair-mediated parliamentary discussion.
+
+The classical RR flow, condensed for an LLM forum:
+
+  RR-1 OPENING: the chair (orchestrator) calls the meeting to order
+       and reads the question.
+
+  RR-2 INITIAL REMARKS: each member is recognized in roster order
+       and briefly states their position (a few sentences). This
+       mirrors Phase 1 of the Collaborative structure but with chair
+       framing. We also build the credential summary here so the
+       same downstream tooling (View Credential Summary, etc.) works.
+
+  RR-3 MOTION: the chair synthesizes a main motion from the initial
+       remarks and asks for a second. Members who aren't the
+       motion-maker are polled briefly for a "second" / "no second";
+       the first agreement carries.
+
+  RR-4 DEBATE: configurable number of rounds (defaults to
+       `limits.critique_rounds`). Each member speaks in turn, must
+       address the motion (support / oppose / amend / propose
+       alternative), and may name other members. Each member's last
+       remark in the debate is captured as their finalized position
+       so the decision phase has the standardized hand-off it needs.
+
+  RR-5 MOVE THE QUESTION: the chair declares debate closed and
+       hands off to the decision method (typically RobertsRulesVote
+       but any decision method is compatible).
+
+The structure is deliberately self-contained — none of the
+Collaborative phase functions are reused — so future RR features
+(amendments, points of order, etc.) can be added without
+entangling the original CCAI flow.
+"""
+from __future__ import annotations
+
+from typing import Any, AsyncIterator
+
+from app.services.conversation.structures.base import ConversationStructure
+from app.services.conversation.types import DecisionInput
+from app.services.credential import build_credential_summary
+from app.services.json_calls import orchestrator_call
+from app.services.models import Participant, Phase
+from app.services.resilience import run_resilient_turn
+
+
+RR_OPENING_TEMPLATE = (
+    "The meeting is called to order. The chair reads the question "
+    "before the assembly:\n\n"
+    "  {question}\n\n"
+    "The chair will recognize each member in turn for opening "
+    "remarks, after which the floor will be open for motions."
+)
+
+
+RR_INITIAL_REMARKS_PROMPT = """The chair has called the meeting to order and read \
+the following question:
+
+  {question}
+
+You are {speaker_name}. The chair recognizes you for opening remarks. \
+Briefly state your position on the question in two or three sentences. \
+Speak as a member of a deliberative assembly — formal but not stiff. \
+Do not yet make a formal motion; that will come later.
+"""
+
+
+RR_MOTION_SYNTHESIS_PROMPT = """You are the chair of a meeting governed by \
+Robert's Rules of Order. The following members have just given their \
+opening remarks on this question:
+
+  Question: {question}
+
+Opening remarks:
+{remarks_block}
+
+Synthesize ONE concrete motion that reflects the most strongly-supported \
+position. Also identify which member is most likely to formally make \
+this motion (the "mover") based on their remarks, and which other \
+member is most likely to second it.
+
+Return ONLY this JSON (no prose, no fences):
+{{
+  "motion": "Resolved, that ...",
+  "mover_id": "<participant_id>",
+  "seconder_id": "<participant_id>"
+}}
+"""
+
+
+RR_DEBATE_PROMPT = """You are {speaker_name}, a member of an assembly \
+governed by Robert's Rules of Order. The main motion on the floor is:
+
+  Motion: {motion}
+
+This is debate round {round_n} of {round_total}. The chair has \
+recognized you. Speak to the motion: support it, oppose it, propose \
+an amendment, or offer a substitute. Be specific. You may address \
+other members by name.
+
+Question under consideration: {question}
+
+Debate so far:
+{transcript}
+"""
+
+
+class RobertsRulesDiscussion(ConversationStructure):
+    NAME = "Robert's Rules of Order"
+    DESCRIPTION = (
+        "Chair-mediated parliamentary debate: opening remarks, the "
+        "chair synthesizes a main motion and finds a seconder, "
+        "members debate the motion in turn, then the chair calls "
+        "for the vote."
+    )
+
+    async def run(self) -> AsyncIterator[str]:
+        # Imports are local to avoid pulling the orchestrator module
+        # at package-import time (orchestrator.py itself imports the
+        # conversation package via the dispatcher path).
+        from app.services.orchestrator import (
+            _sse,
+            _active_participants,
+            _add_orchestrator_message,
+            _add_participant_message,
+            _bump_orchestrator_count,
+            _call_participant,
+            _format_history,
+            _msg_payload,
+            _orchestrator_model_id,
+            _participant_msg_cap_hit,
+            _wait_for_continue,
+        )
+
+        session = self.session
+        actives = _active_participants(session)
+        if len(actives) < 2:
+            yield _sse("error", {"message": "Robert's Rules needs at least 2 members."})
+            return
+
+        # ---- RR-1: Opening -------------------------------------------------
+        session.phase = Phase.RR_OPENING
+        yield _sse("status", {"message": "RR-1: chair calls the meeting to order..."})
+        opening_text = RR_OPENING_TEMPLATE.format(question=session.question)
+        msg = _add_orchestrator_message(
+            session, opening_text, kind="rr_opening",
+            extra={"question": session.question},
+        )
+        yield _sse("orchestrator", _msg_payload(msg))
+
+        # ---- RR-2: Initial Remarks ----------------------------------------
+        session.phase = Phase.RR_INITIAL_REMARKS
+        yield _sse("status", {"message": "RR-2: opening remarks..."})
+        remarks: dict[str, str] = {}
+        for p in _active_participants(session):
+            if p.kind == "human":
+                # For now humans skip remarks under RR; a future pass
+                # can pause for input via human_io.
+                continue
+            prompt = RR_INITIAL_REMARKS_PROMPT.format(
+                question=session.question,
+                speaker_name=p.name,
+            )
+            turn = await run_resilient_turn(
+                session=session, participant=p,
+                user_prompt=prompt,
+                label="rr_initial_remarks",
+                max_tokens=400,
+                call_participant=_call_participant,
+            )
+            for ev in turn.sse_events:
+                yield ev
+            if not turn.ok:
+                yield _sse("participant_error", {
+                    "participant_id": p.participant_id,
+                    "name": p.name,
+                    "phase": session.phase.value,
+                })
+                if p.consecutive_failures >= session.limits.auto_disable_failures:
+                    p.enabled = False
+                continue
+            speaker = turn.speaker
+            msg = _add_participant_message(
+                session, speaker, turn.text,
+                phase=session.phase, elapsed=turn.elapsed,
+            )
+            remarks[speaker.participant_id] = turn.text
+            session.initial_opinions[speaker.participant_id] = turn.text
+            yield _sse("message", _msg_payload(msg))
+            if _participant_msg_cap_hit(session):
+                async for chunk in _wait_for_continue(session, "messages"):
+                    yield chunk
+
+        # Credential summary — mirrors Phase 1 of Collaborative so the
+        # rest of the app (View Credential Summary, etc.) stays happy.
+        yield _sse("status", {"message": "Building Credential Summary..."})
+        creds = await build_credential_summary(
+            orchestrator_model_id=_orchestrator_model_id(session),
+            question=session.question,
+            participants=_active_participants(session),
+            initial_opinions=session.initial_opinions,
+            api_log=session.api_log,
+            human_credential=session.human_credential,
+        )
+        _bump_orchestrator_count(session)
+        session.credential_summary = creds
+        yield _sse("credentials_updated", {
+            "stage": "built",
+            "credentials": session.credential_summary,
+        })
+
+        # ---- RR-3: Motion --------------------------------------------------
+        session.phase = Phase.RR_MOTION
+        yield _sse("status", {"message": "RR-3: chair invites a motion..."})
+
+        remarks_block = "\n".join(
+            f"- {p.name}: {remarks.get(p.participant_id, '(no remarks)')}"
+            for p in _active_participants(session)
+        )
+        _, parsed = await orchestrator_call(
+            orchestrator_model_id=_orchestrator_model_id(session),
+            user_prompt=RR_MOTION_SYNTHESIS_PROMPT.format(
+                question=session.question, remarks_block=remarks_block,
+            ),
+            label="rr_motion_synthesis",
+            api_log=session.api_log,
+            expect_json=True,
+            max_tokens=500,
+            temperature=0.3,
+        )
+        _bump_orchestrator_count(session)
+
+        motion = ""
+        mover_id = ""
+        seconder_id = ""
+        if isinstance(parsed, dict):
+            motion = str(parsed.get("motion") or "").strip()
+            mover_id = str(parsed.get("mover_id") or "").strip()
+            seconder_id = str(parsed.get("seconder_id") or "").strip()
+        if not motion:
+            motion = (
+                "Resolved, that the assembly endorses the position most "
+                "broadly reflected in opening remarks."
+            )
+        session.main_motion = motion
+        session.proposed_motions.append({
+            "motion": motion,
+            "mover_id": mover_id,
+            "seconder_id": seconder_id,
+        })
+
+        by_id = {p.participant_id: p for p in _active_participants(session)}
+        mover = by_id.get(mover_id)
+        seconder = by_id.get(seconder_id)
+        # Fallbacks if the chair's id picks don't match the roster
+        if not mover:
+            ai_members = [p for p in _active_participants(session) if p.kind != "human"]
+            mover = ai_members[0] if ai_members else None
+        if not seconder:
+            ai_members = [
+                p for p in _active_participants(session)
+                if p.kind != "human" and mover and p.participant_id != mover.participant_id
+            ]
+            seconder = ai_members[0] if ai_members else None
+
+        motion_announce = (
+            f"The chair recognizes {mover.name if mover else 'the floor'} "
+            f"to make a motion:\n\n"
+            f"  \"{motion}\"\n\n"
+            + (f"{seconder.name} seconds the motion. " if seconder else "")
+            + "The motion is on the floor. Debate is open."
+        )
+        msg = _add_orchestrator_message(
+            session, motion_announce, kind="motion",
+            extra={
+                "motion": motion,
+                "mover_id": mover.participant_id if mover else "",
+                "seconder_id": seconder.participant_id if seconder else "",
+            },
+        )
+        yield _sse("orchestrator", _msg_payload(msg))
+
+        # ---- RR-4: Debate --------------------------------------------------
+        session.phase = Phase.RR_DEBATE
+        debate_rounds = max(1, session.limits.critique_rounds)
+        last_remark_per_member: dict[str, str] = dict(remarks)
+
+        for round_n in range(1, debate_rounds + 1):
+            yield _sse("status", {
+                "message": f"RR-4: debate round {round_n} of {debate_rounds}...",
+            })
+            for p in _active_participants(session):
+                if p.kind == "human":
+                    continue
+                prompt = RR_DEBATE_PROMPT.format(
+                    speaker_name=p.name,
+                    motion=motion,
+                    round_n=round_n,
+                    round_total=debate_rounds,
+                    question=session.question,
+                    transcript=_format_history(session.messages),
+                )
+                turn = await run_resilient_turn(
+                    session=session, participant=p,
+                    user_prompt=prompt,
+                    label=f"rr_debate_round_{round_n}",
+                    max_tokens=600,
+                    call_participant=_call_participant,
+                )
+                for ev in turn.sse_events:
+                    yield ev
+                if not turn.ok:
+                    yield _sse("participant_error", {
+                        "participant_id": p.participant_id,
+                        "name": p.name,
+                        "phase": session.phase.value,
+                    })
+                    if p.consecutive_failures >= session.limits.auto_disable_failures:
+                        p.enabled = False
+                    continue
+                speaker = turn.speaker
+                msg = _add_participant_message(
+                    session, speaker, turn.text,
+                    phase=session.phase, elapsed=turn.elapsed,
+                )
+                last_remark_per_member[speaker.participant_id] = turn.text
+                yield _sse("message", _msg_payload(msg))
+                if _participant_msg_cap_hit(session):
+                    async for chunk in _wait_for_continue(session, "messages"):
+                        yield chunk
+
+        # Final positions = last thing each member said in debate. This
+        # is what we hand off to the decision phase via DecisionInput.
+        session.final_opinions = dict(last_remark_per_member)
+
+        # ---- RR-5: Move the Question --------------------------------------
+        session.phase = Phase.RR_MOVE_THE_QUESTION
+        closing = (
+            "The chair calls the question. Debate is closed. The "
+            "assembly will now proceed to the vote on the motion: "
+            f"\"{motion}\""
+        )
+        msg = _add_orchestrator_message(
+            session, closing, kind="rr_call_the_question",
+            extra={"motion": motion},
+        )
+        yield _sse("orchestrator", _msg_payload(msg))
+
+    def build_decision_input(self) -> DecisionInput:
+        session = self.session
+        actives = [p for p in session.participants if p.enabled]
+        return DecisionInput(
+            question=session.question,
+            participants=actives,
+            transcript_messages=list(session.messages),
+            finalized_positions=dict(session.final_opinions),
+            main_motion=session.main_motion,
+            extras={"proposed_motions": list(session.proposed_motions)},
+        )

backend/app/services/conversation/types.py

@@ -0,0 +1,60 @@
+"""Shared dataclasses for the conversation plugin system.
+
+`DecisionInput` is the contract between a ConversationStructure and a
+DecisionMethod: whatever shape the discussion took, by the time the
+structure hands off, we should have a question, the active
+participants, the transcript, and each participant's finalized
+position. Structures that surface explicit options or motions
+(notably Robert's Rules) populate the optional fields.
+
+Keeping this in its own module avoids structures and decisions having
+to import from each other.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from app.services.models import Participant
+
+
+@dataclass
+class DecisionInput:
+    """Standardized hand-off from a ConversationStructure to a
+    DecisionMethod.
+
+    Fields:
+      * question: the conversation's prompt.
+      * participants: snapshot of active LLM + human participants in
+        roster order. (Disabled participants are filtered out by the
+        structure before handoff.)
+      * transcript_messages: full ordered message log; decision
+        methods may quote or summarize.
+      * finalized_positions: participant_id -> short text summary of
+        that participant's final stance. Always populated for
+        non-human AI participants by the end of discussion. Human
+        participants may also have entries when they spoke a final
+        opinion.
+      * proposed_candidates: explicit list of options the structure
+        surfaced (e.g. Robert's Rules motions, or an LLM-extracted
+        cluster of positions from a collaborative discussion). When
+        None, the decision method derives candidates from
+        `finalized_positions`.
+      * main_motion: for Robert's Rules, the text of the main motion
+        on the floor. When set, decision methods that support a
+        binary vote (RobertsRulesVote, MajorityRulesDecision) will
+        vote yes/no/abstain on this motion instead of choosing among
+        candidates.
+      * extras: free-form bag for structure-specific metadata a
+        decision method might want (motion seconder, debate
+        speaker order, etc.). Treat as opaque unless you know the
+        structure produced something specific.
+    """
+    question: str
+    participants: list["Participant"]
+    transcript_messages: list[dict[str, Any]]
+    finalized_positions: dict[str, str]
+    proposed_candidates: list[str] | None = None
+    main_motion: str | None = None
+    extras: dict[str, Any] = field(default_factory=dict)

backend/app/services/conversation/voting.py

@@ -0,0 +1,550 @@
+"""Voting helpers shared by Majority, Ranked-Choice, and Robert's
+Rules decision methods.
+
+Three pieces live here:
+
+  * `extract_candidate_options(...)`: takes a list of finalized
+    position texts, asks the orchestrator LLM to cluster them into a
+    small set of distinct option labels, returns them as a list of
+    short strings.
+
+  * `cast_vote(...)`: asks one participant to vote on a list of
+    options (or to rank them, depending on `mode`), returning a
+    structured dict.
+
+  * `run_irv(...)`: instant-runoff tally for ranked-choice ballots.
+
+All three are pure helpers (no Session mutation) so the decision
+method classes can compose them however they want.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import time
+from typing import Any
+
+from app.clients.llm_router import chat_completion
+from app.services.json_calls import (
+    orchestrator_call,
+    parse_json_response,
+)
+from app.services.models import Participant, Session
+from app.services.prompts import NO_REASONING_DIRECTIVE
+from app.utils.sanitize import strip_thinking
+
+LOG = logging.getLogger(__name__)
+
+
+# How many distinct options the candidate-extraction LLM call may
+# return. Cap is intentional: ranked-choice with > 6 options gets
+# unwieldy for both LLM voters and human readers of the report.
+MAX_CANDIDATES = 6
+
+
+CANDIDATE_EXTRACTION_PROMPT = """The following are participants' final \
+positions on this question:
+
+Question: {question}
+
+Participant positions:
+{positions_block}
+
+Cluster these into between 2 and {max_candidates} distinct option \
+labels that capture the main answers being supported. Each label \
+should be short (one sentence) and self-contained — a voter who \
+hadn't read the transcript should still understand what they're \
+voting for.
+
+Return ONLY this JSON shape (no prose, no fences):
+{{
+  "options": ["short option 1", "short option 2", ...]
+}}
+"""
+
+
+VOTE_SINGLE_PROMPT = """You are {participant_name}.
+
+The group has been discussing this question:
+  {question}
+
+After deliberation, the choices on the table are:
+{options_block}
+
+Cast your vote for the ONE option you support. Return ONLY this JSON \
+(no prose, no fences):
+{{
+  "choice": <integer 1..N of your top choice>,
+  "reason": "one sentence on why"
+}}
+"""
+
+
+VOTE_RANK_PROMPT = """You are {participant_name}.
+
+The group has been discussing this question:
+  {question}
+
+After deliberation, the choices on the table are:
+{options_block}
+
+Rank ALL of the options from most preferred (rank 1) to least \
+preferred. You must include every option exactly once. Return ONLY \
+this JSON (no prose, no fences):
+{{
+  "ranking": [<rank-1 option number>, <rank-2 option number>, ...],
+  "reason": "one sentence on your top choice"
+}}
+"""
+
+
+VOTE_YESNO_PROMPT = """You are {participant_name}.
+
+The chair has put the following motion before the assembly:
+
+  Motion: {motion}
+
+Cast your vote. Return ONLY this JSON (no prose, no fences):
+{{
+  "vote": "aye" | "nay" | "abstain",
+  "reason": "one sentence on why"
+}}
+"""
+
+
+def _format_positions_block(positions: dict[str, str], participants: list[Participant]) -> str:
+    by_id = {p.participant_id: p for p in participants}
+    lines: list[str] = []
+    for pid, text in positions.items():
+        name = by_id[pid].name if pid in by_id else pid
+        lines.append(f"- {name}: {text}".strip())
+    return "\n".join(lines) if lines else "(no positions recorded)"
+
+
+def _format_options_block(options: list[str]) -> str:
+    return "\n".join(f"  {i + 1}. {opt}" for i, opt in enumerate(options))
+
+
+async def extract_candidate_options(
+    *,
+    session: Session,
+    question: str,
+    positions: dict[str, str],
+    participants: list[Participant],
+    max_candidates: int = MAX_CANDIDATES,
+) -> list[str]:
+    """Cluster finalized positions into a short list of distinct
+    option labels for a vote.
+
+    Falls back to using each participant's position verbatim (up to
+    `max_candidates`) if the LLM call fails or returns nothing
+    parseable.
+    """
+    if not positions:
+        return []
+
+    positions_block = _format_positions_block(positions, participants)
+    prompt = CANDIDATE_EXTRACTION_PROMPT.format(
+        question=question,
+        positions_block=positions_block,
+        max_candidates=max_candidates,
+    )
+
+    from app.services.orchestrator import _orchestrator_model_id, _bump_orchestrator_count
+
+    raw, parsed = await orchestrator_call(
+        orchestrator_model_id=_orchestrator_model_id(session),
+        user_prompt=prompt,
+        label="vote_candidate_extraction",
+        api_log=session.api_log,
+        expect_json=True,
+        max_tokens=500,
+        temperature=0.2,
+    )
+    _bump_orchestrator_count(session)
+
+    options: list[str] = []
+    if isinstance(parsed, dict):
+        raw_opts = parsed.get("options") or []
+        if isinstance(raw_opts, list):
+            options = [str(o).strip() for o in raw_opts if str(o).strip()]
+
+    # Truncate to cap.
+    options = options[:max_candidates]
+
+    if not options:
+        # Fallback: take each unique position verbatim, truncated.
+        seen: set[str] = set()
+        for txt in positions.values():
+            cleaned = (txt or "").strip()
+            if not cleaned:
+                continue
+            key = cleaned[:80].lower()
+            if key in seen:
+                continue
+            seen.add(key)
+            # Single-line short version
+            single = " ".join(cleaned.split())
+            if len(single) > 160:
+                single = single[:157] + "..."
+            options.append(single)
+            if len(options) >= max_candidates:
+                break
+
+    return options
+
+
+async def cast_vote_single(
+    *,
+    session: Session,
+    participant: Participant,
+    question: str,
+    options: list[str],
+) -> dict[str, Any]:
+    """Ask one participant to pick exactly one option.
+
+    Returns {"choice": int (1-based, 0 if invalid), "reason": str,
+    "ok": bool}. Always non-fatal — a malformed reply just yields
+    {"choice": 0, ...} so the tally can skip it.
+    """
+    return await _cast_vote(
+        session=session,
+        participant=participant,
+        prompt=VOTE_SINGLE_PROMPT.format(
+            participant_name=participant.name,
+            question=question,
+            options_block=_format_options_block(options),
+        ),
+        mode="single",
+        n_options=len(options),
+    )
+
+
+async def cast_vote_ranking(
+    *,
+    session: Session,
+    participant: Participant,
+    question: str,
+    options: list[str],
+) -> dict[str, Any]:
+    """Ask one participant to fully rank all options.
+
+    Returns {"ranking": [int, ...] (1-based, may be partial if the
+    model misbehaved), "reason": str, "ok": bool}.
+    """
+    return await _cast_vote(
+        session=session,
+        participant=participant,
+        prompt=VOTE_RANK_PROMPT.format(
+            participant_name=participant.name,
+            question=question,
+            options_block=_format_options_block(options),
+        ),
+        mode="rank",
+        n_options=len(options),
+    )
+
+
+async def cast_vote_yesno(
+    *,
+    session: Session,
+    participant: Participant,
+    motion: str,
+) -> dict[str, Any]:
+    """Ask one participant to vote aye/nay/abstain on a motion.
+
+    Returns {"vote": "aye"|"nay"|"abstain"|"", "reason": str,
+    "ok": bool}.
+    """
+    return await _cast_vote(
+        session=session,
+        participant=participant,
+        prompt=VOTE_YESNO_PROMPT.format(
+            participant_name=participant.name,
+            motion=motion,
+        ),
+        mode="yesno",
+        n_options=0,
+    )
+
+
+async def _cast_vote(
+    *,
+    session: Session,
+    participant: Participant,
+    prompt: str,
+    mode: str,
+    n_options: int,
+) -> dict[str, Any]:
+    if participant.kind == "human":
+        # For now, treat human participants as abstaining in the
+        # automated vote path. Future work: pause the orchestrator
+        # and route through human_io so the user can cast a real
+        # ballot. The decision method can detect this and surface a
+        # note in the report.
+        if mode == "yesno":
+            return {"vote": "abstain", "reason": "(human participant)", "ok": False}
+        if mode == "rank":
+            return {"ranking": [], "reason": "(human participant)", "ok": False}
+        return {"choice": 0, "reason": "(human participant)", "ok": False}
+
+    system_text = (
+        f"{participant.role_prompt}\n\n{NO_REASONING_DIRECTIVE}\n\n"
+        "When asked to cast a vote, reply with ONLY the requested JSON "
+        "object and no other text."
+    )
+    messages = [
+        {"role": "system", "content": system_text},
+        {"role": "user", "content": prompt},
+    ]
+    resolved = {
+        "model_id": participant.model_id,
+        "base_url": participant.base_url,
+        "api_key": participant.api_key,
+        "is_neon": participant.is_neon,
+        "hana_model_id": participant.hana_model_id,
+        "persona_name": participant.persona_name,
+        "neon_direct_vllm": participant.neon_direct_vllm,
+        "vllm_base_url": participant.vllm_base_url,
+        "vllm_api_key": participant.vllm_api_key,
+    }
+    log_entry: dict[str, Any] = {
+        "timestamp": time.time(),
+        "label": f"vote:{mode}:{participant.participant_id}",
+        "model": participant.model_id,
+        "request": {"messages": messages, "max_tokens": 300},
+    }
+    try:
+        result = await chat_completion(
+            resolved=resolved,
+            messages=messages,
+            max_tokens=300,
+            temperature=0.2,
+            timeout=45.0,
+        )
+    except Exception as exc:  # noqa: BLE001
+        LOG.warning("vote %s for %s failed: %s", mode, participant.participant_id, exc)
+        log_entry["response"] = {"error": str(exc)}
+        session.api_log.append(log_entry)
+        return _vote_default(mode)
+
+    log_entry["response"] = result
+    session.api_log.append(log_entry)
+
+    if result.get("error"):
+        return _vote_default(mode)
+
+    raw = strip_thinking(result.get("response", ""))
+    return _parse_vote(raw, mode=mode, n_options=n_options)
+
+
+def _vote_default(mode: str) -> dict[str, Any]:
+    if mode == "yesno":
+        return {"vote": "", "reason": "", "ok": False}
+    if mode == "rank":
+        return {"ranking": [], "reason": "", "ok": False}
+    return {"choice": 0, "reason": "", "ok": False}
+
+
+def _parse_vote(raw: str, *, mode: str, n_options: int) -> dict[str, Any]:
+    parsed = parse_json_response(raw)
+    if not isinstance(parsed, dict):
+        return _vote_default(mode)
+
+    reason = str(parsed.get("reason") or "").strip()
+
+    if mode == "yesno":
+        vote = str(parsed.get("vote") or "").strip().lower()
+        if vote not in ("aye", "nay", "abstain"):
+            return {"vote": "", "reason": reason, "ok": False}
+        return {"vote": vote, "reason": reason, "ok": True}
+
+    if mode == "rank":
+        raw_rank = parsed.get("ranking") or parsed.get("rank") or []
+        if not isinstance(raw_rank, list):
+            return {"ranking": [], "reason": reason, "ok": False}
+        ranking: list[int] = []
+        seen: set[int] = set()
+        for item in raw_rank:
+            try:
+                idx = int(item)
+            except (TypeError, ValueError):
+                continue
+            if 1 <= idx <= n_options and idx not in seen:
+                seen.add(idx)
+                ranking.append(idx)
+        ok = len(ranking) == n_options
+        return {"ranking": ranking, "reason": reason, "ok": ok}
+
+    # single-choice
+    try:
+        choice = int(parsed.get("choice") or 0)
+    except (TypeError, ValueError):
+        choice = 0
+    if not (1 <= choice <= n_options):
+        choice = 0
+    return {"choice": choice, "reason": reason, "ok": choice > 0}
+
+
+# ---------------------------------------------------------------------------
+# Tallying
+# ---------------------------------------------------------------------------
+
+def tally_single_votes(
+    ballots: list[dict[str, Any]],
+    n_options: int,
+) -> dict[str, Any]:
+    """Tally one-shot plurality votes.
+
+    `ballots` items shape: {"choice": int 1..N or 0, ...}.
+
+    Returns:
+      {
+        "counts": [vote_count_for_option_1, ..._for_option_N],
+        "winner": int (1-based; 0 if no votes),
+        "tied_for_first": [int, ...],
+        "total_cast": int,
+        "abstentions": int,
+      }
+    """
+    counts = [0] * n_options
+    cast = 0
+    abst = 0
+    for b in ballots:
+        choice = b.get("choice", 0)
+        if isinstance(choice, int) and 1 <= choice <= n_options:
+            counts[choice - 1] += 1
+            cast += 1
+        else:
+            abst += 1
+    if cast == 0:
+        return {
+            "counts": counts, "winner": 0, "tied_for_first": [],
+            "total_cast": 0, "abstentions": abst,
+        }
+    top = max(counts)
+    leaders = [i + 1 for i, c in enumerate(counts) if c == top]
+    return {
+        "counts": counts,
+        "winner": leaders[0] if len(leaders) == 1 else 0,
+        "tied_for_first": leaders if len(leaders) > 1 else [],
+        "total_cast": cast,
+        "abstentions": abst,
+    }
+
+
+def tally_yesno_votes(ballots: list[dict[str, Any]]) -> dict[str, Any]:
+    """Tally aye/nay/abstain motion votes.
+
+    Returns: {"aye": int, "nay": int, "abstain": int,
+              "passes": bool, "majority": "aye"|"nay"|"tie",
+              "ratio_aye": float}.
+    """
+    aye = sum(1 for b in ballots if b.get("vote") == "aye")
+    nay = sum(1 for b in ballots if b.get("vote") == "nay")
+    abst = sum(
+        1 for b in ballots
+        if b.get("vote") == "abstain" or not b.get("vote")
+    )
+    cast = aye + nay
+    if cast == 0:
+        return {
+            "aye": aye, "nay": nay, "abstain": abst,
+            "passes": False, "majority": "tie", "ratio_aye": 0.0,
+        }
+    if aye > nay:
+        majority = "aye"
+    elif nay > aye:
+        majority = "nay"
+    else:
+        majority = "tie"
+    return {
+        "aye": aye, "nay": nay, "abstain": abst,
+        "passes": aye > nay,
+        "majority": majority,
+        "ratio_aye": aye / cast,
+    }
+
+
+def run_irv(
+    ballots: list[list[int]],
+    n_options: int,
+) -> dict[str, Any]:
+    """Instant-runoff tally on 1-based ranking ballots.
+
+    A ballot is a list of 1-based option indices in order of
+    preference; partial ballots are tolerated. Eliminate the
+    lowest-first-choice option each round, redistribute its top-rank
+    votes to the next still-eligible choice on each ballot, until one
+    option has >50% or all but one are eliminated.
+
+    Returns:
+      {
+        "rounds": [ {round: int, counts: {option_idx: count},
+                      eliminated: int or None,
+                      winner: int or None}, ... ],
+        "winner": int (1-based; 0 if no ballots),
+        "tied": bool,
+      }
+    """
+    if not ballots or n_options <= 0:
+        return {"rounds": [], "winner": 0, "tied": False}
+
+    eligible: set[int] = set(range(1, n_options + 1))
+    # Per-ballot cursor (skips eliminated options on the fly)
+    rounds: list[dict[str, Any]] = []
+    round_n = 0
+
+    while True:
+        round_n += 1
+        counts: dict[int, int] = {opt: 0 for opt in eligible}
+        for ballot in ballots:
+            top: int | None = None
+            for opt in ballot:
+                if opt in eligible:
+                    top = opt
+                    break
+            if top is not None:
+                counts[top] = counts.get(top, 0) + 1
+
+        total = sum(counts.values())
+        if total == 0:
+            rounds.append({"round": round_n, "counts": counts,
+                           "eliminated": None, "winner": None})
+            return {"rounds": rounds, "winner": 0, "tied": False}
+
+        # Check for majority winner
+        for opt, c in counts.items():
+            if c * 2 > total:
+                rounds.append({"round": round_n, "counts": counts,
+                               "eliminated": None, "winner": opt})
+                return {"rounds": rounds, "winner": opt, "tied": False}
+
+        # Only one option left → it wins by default
+        if len(eligible) == 1:
+            sole = next(iter(eligible))
+            rounds.append({"round": round_n, "counts": counts,
+                           "eliminated": None, "winner": sole})
+            return {"rounds": rounds, "winner": sole, "tied": False}
+
+        # Eliminate the option with the fewest first-rank votes; on a
+        # tie at the bottom, eliminate the one with the lowest 1-based
+        # index (deterministic tiebreak).
+        lowest = min(counts.values())
+        candidates_to_drop = sorted(
+            opt for opt, c in counts.items() if c == lowest
+        )
+        # If ALL remaining options tie at the bottom, we have a
+        # degenerate tie — no winner.
+        if len(candidates_to_drop) == len(eligible):
+            rounds.append({"round": round_n, "counts": counts,
+                           "eliminated": None, "winner": None})
+            return {"rounds": rounds, "winner": 0, "tied": True}
+        drop = candidates_to_drop[0]
+        eligible.discard(drop)
+        rounds.append({"round": round_n, "counts": counts,
+                       "eliminated": drop, "winner": None})
+
+        # Safety: cap iterations at n_options + 1.
+        if round_n > n_options + 1:  # pragma: no cover
+            return {"rounds": rounds, "winner": 0, "tied": True}

backend/app/services/models.py

@@ -29,6 +29,18 @@ class Phase(str, Enum):
     CLOSURE = "closure"
     FAILSAFE_PAUSED = "failsafe_paused"
     FINISHED = "finished"
+    # Robert's Rules of Order conversation-structure phases. These run
+    # in place of (or alongside) the Collaborative Discussion phases
+    # when the user picks the "Robert's Rules" conversation structure.
+    RR_OPENING = "rr_opening"
+    RR_INITIAL_REMARKS = "rr_initial_remarks"
+    RR_MOTION = "rr_motion"
+    RR_DEBATE = "rr_debate"
+    RR_MOVE_THE_QUESTION = "rr_move_the_question"
+    # Vote-based decision-method phases. Used by MajorityRulesDecision,
+    # RankedChoiceDecision, and RobertsRulesVote so the frontend can
+    # render an appropriate phase label.
+    VOTING = "voting"
 
 
 # How many participants a session may include (overridable by the user
@@ -379,3 +391,19 @@ class Session:
     # as ordered queues (pop from front).
     candidate_pool: list[Participant] = field(default_factory=list)
     substitution_chain: list[dict[str, Any]] = field(default_factory=list)
+
+    # Conversation-format plugin selection. Resolved via
+    # `app.services.conversation.get_structure(...)` /
+    # `get_decision(...)`. Default to the original CCAI behavior
+    # (collaborative discussion + consensus decision) so older
+    # /chat/start payloads keep working without changes.
+    conversation_structure_id: str = "collaborative"
+    decision_method_id: str = "consensus"
+
+    # Robert's Rules state. Only populated when
+    # `conversation_structure_id == "roberts_rules"`. The decision
+    # method reads `main_motion` and (optionally) `proposed_motions`
+    # so a non-RR decision method like RankedChoice can still operate
+    # on RR output.
+    main_motion: str | None = None
+    proposed_motions: list[dict[str, Any]] = field(default_factory=list)

backend/app/services/orchestrator.py

@@ -1505,7 +1505,19 @@ async def _phase_closure(session: Session) -> AsyncIterator[str]:
 # ---------------------------------------------------------------------------
 
 async def run_conversation(session: Session) -> AsyncIterator[str]:
-    """Drive the full six-phase conversation, yielding SSE chunks."""
+    """Drive the full conversation, yielding SSE chunks.
+
+    The flow is structure → decision: the chosen ConversationStructure
+    runs its phases, then hands a DecisionInput to the chosen
+    DecisionMethod which runs the decision phase(s). Both are
+    resolved from `session.conversation_structure_id` /
+    `session.decision_method_id` (defaults: collaborative + consensus,
+    which preserves the original CCAI behavior).
+    """
+    # Lazy import so the conversation package can import orchestrator
+    # helpers without a circular module load.
+    from app.services.conversation import get_structure, get_decision
+
     actives = _active_participants(session)
     if len(actives) < 2:
         yield _sse("error", {
@@ -1518,24 +1530,17 @@ async def run_conversation(session: Session) -> AsyncIterator[str]:
         for extra in actives[session.max_participants:]:
             extra.enabled = False
 
-    try:
-        async for chunk in _phase_initial_opinions(session):
-            yield chunk
-
-        for round_n in range(1, session.limits.critique_rounds + 1):
-            async for chunk in _phase_critique(session, round_n):
-                yield chunk
+    structure_cls = get_structure(session.conversation_structure_id)
+    decision_cls = get_decision(session.decision_method_id)
+    structure = structure_cls(session)
 
-        async for chunk in _phase_status_assessment(session):
-            yield chunk
-
-        async for chunk in _phase_finalization(session):
-            yield chunk
-
-        async for chunk in _phase_consensus(session):
+    try:
+        async for chunk in structure.run():
             yield chunk
 
-        async for chunk in _phase_closure(session):
+        decision_input = structure.build_decision_input()
+        decision = decision_cls(session, decision_input)
+        async for chunk in decision.run():
             yield chunk
     except Exception as exc:
         LOG.exception("Conversation crashed: %s", exc)

frontend/src/App.js

@@ -16,6 +16,7 @@ import {
   getAuthStatus,
   exportChat, exportApiLog, fetchTableView,   fetchCredentials,
   fetchConversationLimitsDefaults,
+  fetchConversationFormats,
   autoSelectParticipants,
   fetchPromptCatalog,
   getRateLimitStatus,
@@ -51,6 +52,31 @@ export default function App() {
   // Default false matches the backend default ("Prioritize model choice").
   const [speedPriority, setSpeedPriorityState] = useState(false);
 
+  // Conversation-format plugin catalog + current selection. The
+  // catalog is fetched once on mount from /api/chat/conversation-formats
+  // so adding a new structure / decision plugin server-side doesn't
+  // require a frontend change. Selections fall back to whatever the
+  // backend reports as its default until the user picks otherwise.
+  const [conversationFormats, setConversationFormats] = useState({
+    structures: [], decisions: [],
+    default_structure_id: 'collaborative',
+    default_decision_id: 'consensus',
+  });
+  const [conversationStructureId, setConversationStructureIdState] = useState(
+    persisted.conversation_structure_id || null,
+  );
+  const [decisionMethodId, setDecisionMethodIdState] = useState(
+    persisted.decision_method_id || null,
+  );
+  const handleConversationStructureChange = useCallback((id) => {
+    setConversationStructureIdState(id || null);
+    storage.setConversationStructureId(id || null);
+  }, []);
+  const handleDecisionMethodChange = useCallback((id) => {
+    setDecisionMethodIdState(id || null);
+    storage.setDecisionMethodId(id || null);
+  }, []);
+
   // Backend catalog
   const [providers, setProviders] = useState([]);
   const [neonModels, setNeonModels] = useState([]);
@@ -150,6 +176,10 @@ export default function App() {
     getSpeedPriority().then(d => {
       if (typeof d?.enabled === 'boolean') setSpeedPriorityState(d.enabled);
     }).catch(() => {});
+    fetchConversationFormats().then(catalog => {
+      if (!catalog || !Array.isArray(catalog.structures)) return;
+      setConversationFormats(catalog);
+    }).catch(() => {});
     getAuthStatus().then(setAuth).catch(() => {});
     getRateLimitStatus().then(d => {
       if (d?.daily_limit) setDailyLimit(d.daily_limit);
@@ -583,8 +613,17 @@ export default function App() {
       // Sparse override map; backend clamps and falls back per-field.
       limits: limitsOverrides,
       human_credential,
+      // Conversation format selection. null fields make the backend
+      // fall back to its built-in defaults (collaborative + consensus).
+      conversation_structure_id: conversationStructureId,
+      decision_method_id: decisionMethodId,
     };
-  }, [selectedParticipants, enabledMap, modelAssignments, orchestratorModel, summarizerModel, maxParticipants, limitsOverrides, humanParticipant]);
+  }, [
+    selectedParticipants, enabledMap, modelAssignments,
+    orchestratorModel, summarizerModel, maxParticipants,
+    limitsOverrides, humanParticipant,
+    conversationStructureId, decisionMethodId,
+  ]);
 
   // ─── Stop / continue ────────────────────────────────────────────
   const handleStop = useCallback(() => {
@@ -760,6 +799,33 @@ export default function App() {
               text: `${origName} couldn't give an initial opinion; ${altName} is taking their place.`,
             }]);
           },
+          onVoteCast: (data) => {
+            // One per-ballot from a vote-based decision method. We
+            // surface these as system notes so the user can follow
+            // the tally as it happens; the final report message will
+            // contain the canonical summary.
+            const voter = data?.voter_name || 'A voter';
+            let line;
+            if (data?.vote) {
+              line = `${voter} votes ${data.vote}.`;
+            } else if (Array.isArray(data?.ranking) && data.ranking.length > 0) {
+              line = `${voter} submitted ranking: ${data.ranking.join(' > ')}.`;
+            } else if (typeof data?.choice === 'number' && data.choice > 0) {
+              line = `${voter} votes for option ${data.choice}.`;
+            } else {
+              line = `${voter} abstained or returned an invalid ballot.`;
+            }
+            setSystemMessages(prev => [...prev, { text: line }]);
+          },
+          onVoteTally: (data) => {
+            // Final tally summary. The orchestrator message that
+            // follows contains the rendered report, so we just log
+            // a one-liner here for the system feed.
+            const kind = data?.kind || 'vote';
+            setSystemMessages(prev => [...prev, {
+              text: `Vote complete (${kind}); see report below.`,
+            }]);
+          },
           onFailsafePause: (data) => {
             setPause({ reason: 'messages', ...data });
           },
@@ -865,6 +931,11 @@ export default function App() {
         onSummarizerChange={handleSummarizerChange}
         speedPriority={speedPriority}
         onSpeedPriorityChange={handleSpeedPriorityChange}
+        conversationFormats={conversationFormats}
+        conversationStructureId={conversationStructureId}
+        onConversationStructureChange={handleConversationStructureChange}
+        decisionMethodId={decisionMethodId}
+        onDecisionMethodChange={handleDecisionMethodChange}
         showResponseTime={showResponseTime}
         onShowResponseTimeChange={setShowResponseTime}
         showChatStats={showChatStats}

frontend/src/components/DevMenu.js

@@ -44,6 +44,11 @@ export default function DevMenu({
   onSummarizerChange,
   speedPriority,
   onSpeedPriorityChange,
+  conversationFormats,
+  conversationStructureId,
+  onConversationStructureChange,
+  decisionMethodId,
+  onDecisionMethodChange,
   showResponseTime,
   onShowResponseTimeChange,
   showChatStats,
@@ -68,6 +73,7 @@ export default function DevMenu({
   // multi-item category, just add a key here.
   const [openSections, setOpenSections] = useState({
     modelSel: false,
+    conversationFormat: false,
     responsePriority: false,
     display: false,
     transparency: false,
@@ -238,6 +244,28 @@ export default function DevMenu({
 
             <div className="dev-panel-divider" />
 
+            {/* ── Conversation format (accordion) ───────────────── */}
+            {/* Two mutually-exclusive picker lists. The catalog is
+                served by /api/chat/conversation-formats so adding a
+                new structure or decision-method plugin server-side
+                doesn't need a frontend code change. */}
+            <SectionHeader
+              label="Conversation format"
+              open={openSections.conversationFormat}
+              onToggle={() => toggleSection('conversationFormat')}
+            />
+            {openSections.conversationFormat && (
+              <ConversationFormatPicker
+                catalog={conversationFormats}
+                structureId={conversationStructureId}
+                onStructureChange={onConversationStructureChange}
+                decisionId={decisionMethodId}
+                onDecisionChange={onDecisionMethodChange}
+              />
+            )}
+
+            <div className="dev-panel-divider" />
+
             {/* ── Response priority (accordion) ──────────────────── */}
             {/* Two mutually-exclusive choices. Under "Prioritize
                 conversation speed" the backend also races the chosen
@@ -485,3 +513,70 @@ function SectionHeader({ label, open, onToggle }) {
     </button>
   );
 }
+
+
+/**
+ * Two stacked radio-style pickers for the conversation structure and
+ * decision-making method. Driven entirely by the server catalog so
+ * adding a plugin doesn't need a code change here. A null current
+ * selection means "follow the backend's default" — we highlight that
+ * default but the explicit user choice always wins when set.
+ */
+function ConversationFormatPicker({
+  catalog,
+  structureId, onStructureChange,
+  decisionId, onDecisionChange,
+}) {
+  const structures = Array.isArray(catalog?.structures) ? catalog.structures : [];
+  const decisions = Array.isArray(catalog?.decisions) ? catalog.decisions : [];
+  const defStruct = catalog?.default_structure_id || null;
+  const defDec = catalog?.default_decision_id || null;
+  const effectiveStruct = structureId || defStruct;
+  const effectiveDec = decisionId || defDec;
+
+  return (
+    <>
+      <div className="dev-panel-label dev-panel-sublabel">Discussion structure</div>
+      {structures.length === 0 && (
+        <div className="dev-panel-hint" style={{ padding: '4px 10px' }}>
+          (catalog unavailable)
+        </div>
+      )}
+      {structures.map(s => (
+        <button
+          key={s.id}
+          className={`dev-panel-choice ${effectiveStruct === s.id ? 'dev-panel-choice-active' : ''}`}
+          onClick={() => onStructureChange?.(s.id)}
+          title={s.description || ''}
+        >
+          {effectiveStruct === s.id
+            ? <CheckSquare size={16} className="dev-check-icon" />
+            : <Square size={16} className="dev-check-icon" />}
+          {s.name}
+        </button>
+      ))}
+
+      <div className="dev-panel-label dev-panel-sublabel" style={{ marginTop: 6 }}>
+        Decision method
+      </div>
+      {decisions.length === 0 && (
+        <div className="dev-panel-hint" style={{ padding: '4px 10px' }}>
+          (catalog unavailable)
+        </div>
+      )}
+      {decisions.map(d => (
+        <button
+          key={d.id}
+          className={`dev-panel-choice ${effectiveDec === d.id ? 'dev-panel-choice-active' : ''}`}
+          onClick={() => onDecisionChange?.(d.id)}
+          title={d.description || ''}
+        >
+          {effectiveDec === d.id
+            ? <CheckSquare size={16} className="dev-check-icon" />
+            : <Square size={16} className="dev-check-icon" />}
+          {d.name}
+        </button>
+      ))}
+    </>
+  );
+}

frontend/src/components/Header.js

@@ -44,6 +44,11 @@ export default function Header({
   onSummarizerChange,
   speedPriority,
   onSpeedPriorityChange,
+  conversationFormats,
+  conversationStructureId,
+  onConversationStructureChange,
+  decisionMethodId,
+  onDecisionMethodChange,
   showResponseTime,
   onShowResponseTimeChange,
   showChatStats,
@@ -148,6 +153,11 @@ export default function Header({
           onSummarizerChange={onSummarizerChange}
           speedPriority={speedPriority}
           onSpeedPriorityChange={onSpeedPriorityChange}
+          conversationFormats={conversationFormats}
+          conversationStructureId={conversationStructureId}
+          onConversationStructureChange={onConversationStructureChange}
+          decisionMethodId={decisionMethodId}
+          onDecisionMethodChange={onDecisionMethodChange}
           showResponseTime={showResponseTime}
           onShowResponseTimeChange={onShowResponseTimeChange}
           showChatStats={showChatStats}

frontend/src/components/OrchestratorMessage.js

@@ -8,8 +8,37 @@ import remarkGfm from 'remark-gfm';
  * speaking. Used for status updates, follow-up announcements, factor
  * surfacing, and the final majority/no-consensus reports.
  */
+// Orchestrator message `kind` values that should get the "report"
+// visual treatment (border, larger text). Includes the originals
+// from the Consensus decision path plus the new ones emitted by the
+// majority-rules, ranked-choice, and Robert's Rules vote plugins.
+const REPORT_KINDS = new Set([
+  'majority_report',
+  'no_consensus_report',
+  'vote_result',
+  'ranked_choice_result',
+]);
+
+function labelSuffixForKind(kind, message) {
+  switch (kind) {
+    case 'majority_report': return ' - Majority Report';
+    case 'no_consensus_report': return ' - No-Consensus Report';
+    case 'factor': return ' - New Consideration';
+    case 'motion': return ' - Motion on the Floor';
+    case 'ballot_options': return ' - Ballot';
+    case 'rr_opening': return ' - Chair';
+    case 'rr_call_the_question': return ' - Chair Calls the Question';
+    case 'vote_result':
+      if (message?.flavor === 'roberts_rules') return ' - Vote Result (RR)';
+      if (message?.vote_kind === 'yesno') return ' - Vote Result (Aye/Nay)';
+      return ' - Vote Result';
+    case 'ranked_choice_result': return ' - Ranked-Choice Result';
+    default: return '';
+  }
+}
+
 export default function OrchestratorMessage({ message }) {
-  const isReport = message.kind === 'majority_report' || message.kind === 'no_consensus_report';
+  const isReport = REPORT_KINDS.has(message.kind);
   const className = (
     'ccai-orchestrator-msg' +
     (isReport ? ' ccai-orchestrator-msg-report' : '')
@@ -17,10 +46,7 @@ export default function OrchestratorMessage({ message }) {
   return (
     <div className={className}>
       <div className="ccai-orchestrator-msg-label">
-        Orchestrator{message.kind === 'majority_report' ? ' - Majority Report'
-          : message.kind === 'no_consensus_report' ? ' - No-Consensus Report'
-          : message.kind === 'factor' ? ' - New Consideration'
-          : ''}
+        Orchestrator{labelSuffixForKind(message.kind, message)}
       </div>
       <div className="ccai-orchestrator-msg-body">
         <ReactMarkdown remarkPlugins={[remarkGfm]}>

frontend/src/utils/api.js

@@ -127,6 +127,8 @@ function eventHandlerKey(eventType) {
     case 'participant_error': return 'onParticipantError';
     case 'participant_substituted': return 'onParticipantSubstituted';
     case 'participant_replaced': return 'onParticipantReplaced';
+    case 'vote_cast': return 'onVoteCast';
+    case 'vote_tally': return 'onVoteTally';
     case 'credentials_updated': return 'onCredentialsUpdated';
     case 'human_turn_needed': return 'onHumanTurnNeeded';
     case 'human_turn_cleared': return 'onHumanTurnCleared';
@@ -175,6 +177,22 @@ export async function setSpeedPriority(enabled) {
   return resp.json();
 }
 
+/**
+ * Fetch the catalog of available conversation structures and
+ * decision-making methods. The Settings menu's "Conversation format"
+ * accordion populates from this so adding a new plugin server-side
+ * doesn't require frontend code changes.
+ *
+ * Returns: { structures: [{id, name, description}, ...],
+ *            decisions: [{id, name, description}, ...],
+ *            default_structure_id, default_decision_id }
+ */
+export async function fetchConversationFormats() {
+  const resp = await fetch(`${API_BASE}/api/chat/conversation-formats`, { cache: 'no-store' });
+  if (!resp.ok) throw new Error('Failed to fetch conversation formats');
+  return resp.json();
+}
+
 export async function exportChat(sessionId, fmt = 'txt') {
   const resp = await fetch(`${API_BASE}/api/chat/${sessionId}/export?fmt=${fmt}`);
   if (!resp.ok) throw new Error('Export failed');

frontend/src/utils/storage.js

@@ -38,6 +38,12 @@ const DEFAULTS = {
   // their summary every session. Cleared from storage when the user
   // removes the human via the sidebar.
   human_participant: null,
+  // Conversation-format plugin choices (see backend
+  // /api/chat/conversation-formats). null means "use server default"
+  // — the backend returns `default_structure_id` / `default_decision_id`
+  // alongside the catalog so the UI can highlight them.
+  conversation_structure_id: null,
+  decision_method_id: null,
 };
 
 function readAll() {
@@ -118,3 +124,11 @@ export function setAutoSelectMode(on) {
 export function setHumanParticipant(humanOrNull) {
   return patchState({ human_participant: humanOrNull || null });
 }
+
+export function setConversationStructureId(id) {
+  return patchState({ conversation_structure_id: id || null });
+}
+
+export function setDecisionMethodId(id) {
+  return patchState({ decision_method_id: id || null });
+}