Debate Orchestrator

Manages formal debate execution through deterministic state tracking and resumability.

State Machine

Debates cycle through 2 phases per exchange:

awaiting_arguments

awaiting_judgment

After judgment: cycle repeats with

current_exchange

Key Properties:

• No "complete" state - orchestrator decides when to stop based on requested exchange count
• Parallel execution - both sides argue simultaneously each exchange
• Resumable - read state, execute required action, repeat
• Exchange 0 is special (opening) - both sides produce 3 independent arguments
• Exchange 1+ are rebuttal - sides produce single arguments with attacks/defends

Running Exchanges

1. Read State

Check

{debate}/debate.md

{
  "current_exchange": 0,
  "current_phase": "awaiting_arguments"
}

Extract motion from the

# Motion

2. Determine Exchange Type

Opening Exchange:

current_exchange == 0

• Both debaters produce 3 independent arguments simultaneously
• Judge scores all 6 arguments

Rebuttal Exchange:

current_exchange >= 1

• Both debaters produce 1 argument simultaneously
• Judge scores both new arguments

3. Execute Based on Phase + Exchange Type

Opening Exchange (Exchange 0)

When

current_exchange == 0

current_phase == awaiting_arguments

Load template:

Read

templates/debater-opening.md

Spawn both debaters in parallel:

Use a single message with two Task tool invocations to spawn both debaters simultaneously.

For each side (

proposition

opposition

1. Substitute placeholders in template:

   • {motion}

     : Extracted motion text

   • {side}

     : Side name (

     proposition

     or

     opposition

     )

2. Spawn debater:

   Use Task tool with subagent_type: "debater"
   Prompt: [substituted template content]
   

Process outputs:

After both debaters complete:

1. Write proposition output to

   /tmp/prop_arg.json

2. Write opposition output to

   /tmp/opp_arg.json

3. Execute the python package

   debate_ops

   :

   python3 {skill_base_dir}/debate_ops process-exchange {debate} 0 --prop-file /tmp/prop_arg.json --opp-file /tmp/opp_arg.json

Check result JSON for errors or warnings. On errors, state remains unchanged - report to user and halt. On warnings, note them and continue.

The script creates 6 argument files:

prop_000a.md

prop_000b.md

prop_000c.md

opp_000a.md

opp_000b.md

opp_000c.md

State automatically updates to

current_phase: awaiting_judgment

Judge opening arguments:

When

current_exchange == 0

current_phase == awaiting_judgment

Load template:

Read

templates/judge.md

Substitute placeholders:

• {argument_files}

  : Space-separated list of all 6 opening arguments:

  @{debate}/arguments/prop_000a.md @{debate}/arguments/prop_000b.md @{debate}/arguments/prop_000c.md @{debate}/arguments/opp_000a.md @{debate}/arguments/opp_000b.md @{debate}/arguments/opp_000c.md
  

• {motion}

  : Extracted motion text

Spawn judge:

Use Task tool with subagent_type: "judge"
Prompt: [substituted template content]

Process output:

1. Use Write tool to save agent output to

   /tmp/judge.json

2. Execute the python package

   debate_ops

   :

   python3 {skill_base_dir}/debate_ops process-judge {debate} --json-file /tmp/judge.json

Check result JSON for errors or warnings. On errors, state remains unchanged - report to user and halt. On warnings, note them and continue.

State automatically updates to

current_phase: awaiting_arguments

current_exchange: 1

Rebuttal Exchange (Exchange 1+)

When

current_exchange >= 1

current_phase == awaiting_arguments

Build argument context:

1. List all files in

   {debate}/arguments/

2. Separate into proposition and opposition arguments:
   • Proposition: Files matching

     prop_*.md

   • Opposition: Files matching

     opp_*.md

3. Filter to arguments from previous exchanges only:
   • Extract exchange number from filename (e.g.,

     prop_003

     → exchange 3)
   • Include only arguments where exchange < current_exchange
4. Sort by exchange number (chronological order)

Load template:

Read

templates/debater-rebuttal.md

Spawn both debaters in parallel:

Use a single message with two Task tool invocations to spawn both debaters simultaneously.

For proposition debater:

• Substitute placeholders:

  • {motion}

    : Extracted motion text

  • {side}

    :

    proposition

  • {exchange}

    : Current exchange number

  • {your_arguments}

    : Newline-separated list:

    @{debate}/arguments/prop_000a.md

    ,

    @{debate}/arguments/prop_000b.md

    , etc.

  • {opponent_arguments}

    : Newline-separated list:

    @{debate}/arguments/opp_000a.md

    ,

    @{debate}/arguments/opp_000b.md

    , etc.

For opposition debater:

• Substitute placeholders:

  • {motion}

    : Extracted motion text

  • {side}

    :

    opposition

  • {exchange}

    : Current exchange number

  • {your_arguments}

    : Newline-separated list of opposition arguments

  • {opponent_arguments}

    : Newline-separated list of proposition arguments

Process outputs:

After both debaters complete:

1. Write proposition output to

   /tmp/prop_arg.json

2. Write opposition output to

   /tmp/opp_arg.json

3. Execute the python package

   debate_ops

   :

   python3 {skill_base_dir}/debate_ops process-exchange {debate} {current_exchange} --prop-file /tmp/prop_arg.json --opp-file /tmp/opp_arg.json

Check result JSON for errors or warnings. On errors, state remains unchanged - report to user and halt. On warnings, note them and continue.

State automatically updates to

current_phase: awaiting_judgment

Judge rebuttal arguments:

When

current_exchange >= 1

current_phase == awaiting_judgment

Load template:

Read

templates/judge.md

Substitute placeholders:

• {argument_files}

  : Space-separated list of both new arguments:

  @{debate}/arguments/prop_{current_exchange:03d}.md @{debate}/arguments/opp_{current_exchange:03d}.md
  

• {motion}

  : Extracted motion text

Spawn judge:

Use Task tool with subagent_type: "judge"
Prompt: [substituted template content]

Process output:

1. Use Write tool to save agent output to

   /tmp/judge.json

2. Execute the python package

   debate_ops

   :

   python3 {skill_base_dir}/debate_ops process-judge {debate} --json-file /tmp/judge.json

Check result JSON for errors or warnings. On errors, state remains unchanged - report to user and halt. On warnings, note them and continue.

State automatically updates to

current_phase: awaiting_arguments

current_exchange

4. Decide When to Stop

After each phase, check if you should continue:

• Read the updated state from

  {debate}/debate.md

• Compare current exchange number to requested total exchanges
• If sufficient exchanges completed: stop and report
• Otherwise: loop back to step 1

The state itself doesn't track "completion" - you decide when done based on user request.

Error Handling

Processing scripts return:

{
  "success": true/false,
  "argument_id": "prop_001" | ["prop_000a", "prop_000b", "prop_000c"],
  "errors": ["fatal errors"],
  "warnings": ["non-fatal warnings"]
}

On errors:

• State remains unchanged - can safely retry
• Report error to user
• Ask how to proceed (retry, skip, abort)

On warnings:

• Note them
• Continue execution
• Mention warnings in completion summary

Note: By default the

tmp

tmp

Read

Resumability

Execution can be interrupted at any point and resumed by reading state:

• State indicates exactly what phase is needed next
• Execute that phase
• State updates atomically on success
• On failure, state remains unchanged - retry is safe

Completion Report

When requested exchanges complete, report current state:

✓ Completed {N} exchanges for '{debate_slug}'

**Current Scores** (zero-sum tug-of-war):
- Proposition: {total} ({count} arguments)
- Opposition: {total} ({count} arguments)

**Next steps**:
- Continue debating: `/debate-run {debate_slug} X` to run X more exchanges
- Generate report: `/debate-report {debate_slug}` to create comprehensive analysis with visualizations

Extract totals and counts from

cumulative_scores

{debate}/debate.md

Note on zero-sum scoring: Positive total = winning, negative total = losing, zero = even. One side typically has positive total, the other negative (tug-of-war).