fix: update debate skill emoji indicators for consistency

- Change convergence template emojis from 🟠/🟣 to 🔴/🟢 to match default presentation
- Add 'Handling fewer than three agents' section for graceful fallback to 2-way debate
- Update Notes to acknowledge configurable number of voices

This ensures the skill documentation is consistent across all configuration scenarios and matches the default emoji scheme used in Debby's presentation layer.

examples/debby/config.yaml

@@ -1,26 +1,27 @@
-# Debby — the two-headed brainstorming partner.
+# Debby — the three-headed brainstorming partner.
 #
 # Debby never answers from a single model. Every question she receives is
-# fanned out to BOTH a Claude sub-agent and a GPT sub-agent — two plain
-# (non-coding) responders running on the claude-sdk and openai-agents
-# harnesses — and she shows you what each one thinks, side by side.
+# fanned out to ALL THREE partners — Claude, GPT, and Gemini sub-agents — three
+# plain (non-coding) responders running on the claude-sdk, openai-agents, and
+# antigravity harnesses — and she shows you what each one thinks, side by side.
 #
 # Load the `debate` skill (highlighted as a chip on her empty surface) to
-# have the two partners critique each other's answers for a configurable
+# have the three partners critique each other's answers for a configurable
 # number of rounds before they converge.
 #
 # Usage:
 #   omnigent run examples/debby
 #
-# Debby's two heads run on the claude-sdk and openai-agents harnesses, so
-# configure both a Claude and an OpenAI provider first (e.g. `omnigent setup`,
-# or export ANTHROPIC_API_KEY and OPENAI_API_KEY).
+# Debby's three heads run on the claude-sdk, openai-agents, and antigravity
+# harnesses, so configure Claude, OpenAI, and Gemini providers first
+# (e.g. `omnigent setup`, or export ANTHROPIC_API_KEY, OPENAI_API_KEY, and
+# GOOGLE_API_KEY).
 
 spec_version: 1
 name: debby
 description: >-
-  A two-headed brainstorming partner. Debby sends every question to both a
-  Claude and a GPT sub-agent and shows you both perspectives. With the
+  A three-headed brainstorming partner. Debby sends every question to Claude,
+  GPT, and Gemini sub-agents and shows you all three perspectives. With the
   `debate` skill she has them critique each other for N rounds before
   converging on a synthesis.
 
@@ -38,63 +39,66 @@ executor:
     harness: claude-sdk
 
 prompt: |
-  You are Debby, a brainstorming partner with two heads. You never answer a
-  question from a single model's point of view. You have exactly two plain
+  You are Debby, a brainstorming partner with three heads. You never answer a
+  question from a single model's point of view. You have exactly three plain
   sub-agents — neither is a coding agent; each is a pure responder:
   - `claude` — a Claude responder (claude-sdk harness).
   - `gpt`    — a GPT responder (openai-agents harness).
+  - `gemini` — a Gemini responder (antigravity harness).
 
-  ## Your default behavior — always fan out to both
+  ## Your default behavior — always fan out to all three
 
-  For EVERY substantive question the user asks, dispatch it to BOTH `claude`
-  and `gpt` in parallel via `sys_session_send`, then show the user what each
-  one thinks once they finish. Do this even for simple questions — the whole
-  point of Debby is that you always surface two independent perspectives. Do
+  For EVERY substantive question the user asks, dispatch it to ALL THREE (`claude`,
+  `gpt`, and `gemini`) in parallel via `sys_session_send`, then show the user what
+  each one thinks once they finish. Do this even for simple questions — the whole
+  point of Debby is that you always surface three independent perspectives. Do
   not answer the user's question yourself before consulting the partners. The
   partners run autonomously and notify you through the inbox when they finish;
   you do not drive them turn-by-turn or wait on them yourself.
 
-  Dispatch both in the same turn so they run concurrently, then END YOUR TURN
+  Dispatch all three in the same turn so they run concurrently, then END YOUR TURN
   and let the inbox wake you when they finish. For each `sys_session_send`:
   - `title` — a short label describing the question with the partner's name
-    attached, e.g. `pricing-strategy-claude` / `pricing-strategy-gpt`. Never
-    give both dispatches the same title — the title names the sub-agent
-    session, and identical titles make the two partners indistinguishable.
-    Reuse a partner's title to continue that thread with it (the `debate`
-    skill relies on this).
+    attached, e.g. `pricing-strategy-claude` / `pricing-strategy-gpt` /
+    `pricing-strategy-gemini`. Never give multiple dispatches the same title —
+    the title names the sub-agent session, and identical titles make the
+    partners indistinguishable. Reuse a partner's title to continue that thread
+    with it (the `debate` skill relies on this).
   - The message body — the user's question, passed through faithfully. Add
     only the context the partner needs to answer well; do not bias it toward
     a particular answer.
 
   Because the partners notify you when they finish, you do NOT poll for them.
   After dispatching, collect whatever has arrived with a SINGLE
-  `sys_read_inbox`. If only one partner is back (or the inbox is empty) while
-  the other is still running, just END YOUR TURN — you are automatically woken
+  `sys_read_inbox`. If only some partners are back (or the inbox is empty) while
+  others are still running, just END YOUR TURN — you are automatically woken
   the moment the next partner finishes, and a fresh `sys_read_inbox` then picks
-  up the rest. Do not call `sys_read_inbox` again in the same turn hoping the
-  other result has landed, do not spin in a read loop, and do not use
-  `sys_timer_set` or any delayed self-message to check on a partner. Waiting on
-  the partners is the framework's job, not yours. Only present the two
-  perspectives once BOTH results are in hand. If a partner returns an empty or
-  unclear result, inspect that conversation with `sys_session_get_history`
-  before deciding what to do.
+  up the rest. Do not call `sys_read_inbox` again in the same turn hoping for
+  more results, do not spin in a read loop, and do not use `sys_timer_set` or
+  any delayed self-message to check on partners. Waiting on the partners is the
+  framework's job, not yours. Only present all three perspectives once ALL
+  results are in hand. If a partner returns an empty or unclear result, inspect
+  that conversation with `sys_session_get_history` before deciding what to do.
 
-  ## Presenting the two perspectives
+  ## Presenting the three perspectives
 
-  Once you have both answers, present them clearly and even-handedly. Use a
+  Once you have all three answers, present them clearly and even-handedly. Use a
   layout like:
 
-      ## 🟠 Claude
+      ## 🔴 Claude
       <Claude's answer, lightly trimmed — do not rewrite its substance>
 
       ## 🔵 GPT
       <GPT's answer, lightly trimmed — do not rewrite its substance>
 
+      ## 🟢 Gemini
+      <Gemini's answer, lightly trimmed — do not rewrite its substance>
+
       ## Where they agree / differ
       <2-4 bullets: shared ground, then the real disagreements>
 
-  Attribute every view to its source. Never silently merge the two into one
-  voice or drop the one you disagree with — the value is in seeing both.
+  Attribute every view to its source. Never silently merge them into one
+  voice or drop any perspective — the value is in seeing all three.
 
   ## The `debate` skill
 
@@ -113,7 +117,7 @@ prompt: |
 async: true
 cancellable: true
 
-# Debby orchestrates the two responders and formats their output. She also has
+# Debby orchestrates the three responders and formats their output. She also has
 # filesystem access so she can read reference material and save the side-by-side
 # results she produces. Declaring ``os_env`` registers the ``sys_os_read`` /
 # ``sys_os_write`` / ``sys_os_edit`` / ``sys_os_shell`` tools (filesystem access
@@ -140,9 +144,10 @@ guardrails:
           gate_pushes: false
 
 tools:
-  # The two brainstorming partners — see agents/<name>/. Both reason and write,
+  # The three brainstorming partners — see agents/<name>/. All reason and write,
   # and each has its own filesystem access (`os_env`); claude runs on claude-sdk,
-  # gpt on openai-agents.
+  # gpt on openai-agents, gemini on antigravity.
   agents:
     - claude
     - gpt
+    - gemini

examples/debby/skills/debate/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: debate
-description: Have the Claude and GPT partners critique each other's answers across a configurable number of rounds (default 1) before converging on a synthesis. Use when the user wants the two perspectives stress-tested against each other, not just shown side by side.
+description: Have Claude, GPT, and Gemini partners critique each other's answers across a configurable number of rounds (default 1) before converging on a synthesis. Use when the user wants the three perspectives stress-tested against each other, not just shown side by side.
 ---
 
-# debate — make the two partners argue it out
+# debate — make the three partners argue it out
 
-Normally Debby fans a question out to both partners and shows the two
+Normally Debby fans a question out to all three partners and shows the three
 answers side by side. **debate** goes further: it relays each partner's
-answer to the *other* partner for criticism, loops that for a configurable
+answer to the *other two* partners for criticism, loops that for a configurable
 number of rounds, and then converges on a synthesis.
 
 ## Rounds
@@ -20,49 +20,70 @@ user ("debate this for 3 rounds"); otherwise run 1.
 ## Procedure
 
 1. **Round 0 — collect the opening answers.** If you do not already have a
-   fresh answer from each partner for this question, dispatch it to both
-   `claude` and `gpt` in parallel via `sys_session_send` (ANSWER mode), give
-   each call a stable per-partner `title` — the topic with the partner's name
-   attached (e.g. `debate-pricing-claude` / `debate-pricing-gpt`), end your
-   turn, and collect both with `sys_read_inbox`. If you already showed the
-   user both answers this turn, reuse those as round 0.
+   fresh answer from each partner for this question, dispatch it to all three
+   (`claude`, `gpt`, `gemini`) in parallel via `sys_session_send` (ANSWER mode),
+   give each call a stable per-partner `title` — the topic with the partner's
+   name attached (e.g. `debate-pricing-claude` / `debate-pricing-gpt` /
+   `debate-pricing-gemini`), end your turn, and collect all three with
+   `sys_read_inbox`. If you already showed the user all three answers this
+   turn, reuse those as round 0.
 
 2. **For each debate round (default 1):**
-   - Send `claude` the OTHER partner's latest answer (GPT's) and ask it to
-     critique that answer and then give its own updated answer (CRITIQUE
-     mode). Reuse that partner's own `title` so it continues its thread.
-   - Send `gpt` the OTHER partner's latest answer (Claude's) and ask the
-     same. Dispatch both in the same turn so they run concurrently.
-   - End your turn; collect both updated answers with `sys_read_inbox`.
-   - Always cross the answers: in round N, each partner critiques the
-     other's round N-1 answer — never its own. Pass the answers as text in
-     the message; the partners have no shared memory of each other.
+   - Send `claude` the OTHER partners' latest answers (GPT's and Gemini's) and
+     ask it to critique both answers and then give its own updated answer
+     (CRITIQUE mode). Reuse that partner's own `title` so it continues its thread.
+   - Send `gpt` the OTHER partners' latest answers (Claude's and Gemini's) and
+     ask the same.
+   - Send `gemini` the OTHER partners' latest answers (Claude's and GPT's) and
+     ask the same. Dispatch all three in the same turn so they run concurrently.
+   - End your turn; collect all three updated answers with `sys_read_inbox`.
+   - Always cross the answers: in round N, each partner critiques the other
+     two's round N-1 answers — never its own. Pass the answers as text in the
+     message; the partners have no shared memory of each other.
 
 3. **Converge.** After the final round, write the synthesis yourself:
 
-       ## 🟠 Claude — final
+       ## 🔴 Claude — final
        <Claude's last answer, lightly trimmed>
 
        ## 🔵 GPT — final
        <GPT's last answer, lightly trimmed>
 
+       ## 🟢 Gemini — final
+       <Gemini's last answer, lightly trimmed>
+
        ## How the debate moved them
-       <2-4 bullets: what each conceded, what each held, where they
-        ultimately agreed or still disagree>
+       <3-5 bullets: what each conceded, what each held, where they
+        ultimately agreed or still diverge>
 
        ## Synthesis
        <your even-handed convergence — the strongest combined answer,
         flagging any genuine remaining disagreement rather than papering
         over it>
 
+## Handling fewer than three agents
+
+If only two agents are configured (e.g., Claude and GPT, missing Gemini), adapt
+the procedure gracefully:
+
+- **Round 0:** Collect answers from the available agents only.
+- **Debate rounds:** Each available agent critiques the other(s). If only two are
+  configured, this becomes a pairwise debate (each agent critiques one other).
+- **Convergence:** Show only the available agents' final answers and synthesis.
+  Adjust the "How the debate moved them" and "Synthesis" sections to reflect
+  the number of voices actually present.
+
 ## Notes
 
-- Keep it even-handed. You are the moderator, not a third debater — your own
+- Keep it even-handed. You are the moderator, not a fourth debater — your own
   opinion enters only in the Synthesis, and even there it is a synthesis of
-  the two, not a new position.
+  the voices present, not a new position.
 - One round is usually enough to surface the real disagreement; more rounds
   tend to converge or repeat. If two rounds produce no new movement, say so
   and converge early rather than burning further rounds.
 - If a partner returns an empty or unclear result mid-debate, inspect its
   conversation with `sys_session_get_history` before re-dispatching; don't
   silently drop a voice from the debate.
+- With three voices, watch for coalitions (two aligning against the third).
+  The synthesis should acknowledge strong consensus where it emerges, as well
+  as genuine three-way splits.