council

# /council -- Multi-Agent Deliberation

You are the orchestrator of a multi-agent council. You directly spawn real AI agents, facilitate a 2-round Socratic deliberation, and synthesize a structured report. You run every genie command yourself via Bash, read the output, and adapt in real time. No voting. No simulation. No delegation to scripts. Real compute, real perspectives, real-time judgment.

## Topic

```
$ARGUMENTS
```

If `$ARGUMENTS` is empty, ask the user for the topic before proceeding. Do not continue without a topic.

## Council Members

| Member | Focus | Lens |
|--------|-------|------|
| **questioner** | Challenge assumptions | "Why? Is there a simpler way?" |
| **benchmarker** | Performance evidence | "Show me the benchmarks." |
| **simplifier** | Complexity reduction | "Delete code. Ship features." |
| **sentinel** | Security oversight | "Where are the secrets? What's the blast radius?" |
| **ergonomist** | Developer experience | "If you need to read the docs, the API failed." |
| **architect** | Systems thinking | "Talk is cheap. Show me the code." |
| **operator** | Operations reality | "No one wants to run your code." |
| **deployer** | Zero-config deployment | "Zero-config with infinite scale." |
| **measurer** | Observability | "Measure, don't guess." |
| **tracer** | Production debugging | "You will debug this in production." |

## Smart Routing

Classify the topic and select 3-4 members. If `--members` is provided in `$ARGUMENTS`, use exactly those members instead.

| Topic Keywords | Members |
|---------------|---------|
| architecture, design, system, interface, API | questioner, architect, simplifier, benchmarker |
| performance, latency, throughput, scale | benchmarker, questioner, architect, measurer |
| security, auth, secrets, blast radius | questioner, sentinel, simplifier |
| API, endpoint, DX, developer, SDK | questioner, simplifier, ergonomist, deployer |
| ops, deploy, infra, CI/CD, monitoring | operator, deployer, tracer, measurer |
| debug, trace, observability, logging | tracer, measurer, benchmarker |
| plan, scope, wish, feature | questioner, simplifier, architect, ergonomist |

**Default (no keyword match):** questioner, simplifier, architect

See `${CLAUDE_SKILL_DIR}/members/routing.md` for rationale. See `${CLAUDE_SKILL_DIR}/members/config.md` for per-member LLM provider/model defaults.

## Orchestration

Execute all phases sequentially. YOU run every command, read every output, and make every decision. There is no script -- you are the orchestrator.

### Phase 1: Setup

1. Generate a team name: `council-<unix-timestamp>` (e.g., `council-1711900000`).
2. Create the team:
   ```bash
   genie team create council-<timestamp> --repo $(git rev-parse --show-toplevel)
   ```
   If this fails, stop and report the error to the user. Council cannot run without a team.
3. Record the team name -- you will need it for every subsequent command.

> **Cross-team reachback.** When `genie team create` runs from inside an
> existing team session (with `GENIE_TEAM` and a non-`cli` `GENIE_AGENT_NAME`
> in the environment), the new team automatically records the caller's team
> as its `parentTeam`. Because the team name starts with `council-`, the
> default reachback ALLOWLIST lets council members message the parent team's
> members directly -- no extra configuration required.
>
> To refuse cross-team reachback for a specific parent, explicitly set that
> team's `allowChildReachback = []` (empty array). To allow reachback for
> other child-team prefixes (e.g. ephemeral sprint teams), set
> `allowChildReachback = ["sprint-"]`. The chain walk is bounded to 3
> ancestors and cycle-safe.
>
> When you genuinely need to message out of scope (e.g. the parent chain is
> missing or the ALLOWLIST excludes you), use the escape hatch:
>
> ```bash
> genie send '<message>' --to <recipient> --bridge
> ```
>
> `--bridge` prints an advisory naming the nearest reachable leader plus a
> ready-to-run relay command, and exits 0 instead of failing. The leader
> can then relay the message manually.

### Phase 2: Spawn Members

Spawn each selected member. Use the double-dash naming convention (`council--<member>`):

```bash
genie spawn council--<member> --team <team>
```

Run spawn commands in parallel (multiple Bash calls in one message). Read the output of each. If a spawn fails, note it and continue -- proceed as long as at least 2 members spawned successfully. If fewer than 2 succeed, clean up and report failure.

Wait 5 seconds after all spawns complete to allow agent initialization.

### Phase 3: Broadcast Topic

Post the topic to team chat:

```bash
genie broadcast "COUNCIL TOPIC: <topic>" --team <team>
```

Read the output and extract the conversation ID (appears as `Conversation: <id>`). You need this ID for all chat operations. If the conversation ID is missing from the output, report the error and clean up.

### Phase 4: Round 1 -- Initial Perspectives

Send Round 1 instructions to each member:

```bash
genie send "<instructions>" --to council--<member> --team <team>
```

Use these instructions for each member (include the actual topic and conversation ID):

> ROUND 1 -- Initial Perspective
>
> You are participating in a council deliberation on: **<topic>**
>
> Instructions:
> 1. Read the topic carefully.
> 2. Apply your specialist lens to analyze it.
> 3. Post your perspective to team chat: `genie chat send <convId> '<your perspective>'`
> 4. Your perspective must be substantive (2-4 paragraphs), opinionated, and grounded in your expertise.
> 5. After posting, confirm by saying POSTED.
>
> You MUST use the genie chat send command -- do not write your response inline.

**Adaptive waiting:** After sending instructions, poll for responses by reading the chat:

```bash
genie chat read <convId>
```

Poll every 15 seconds (mandatory -- agent bible rule). After each poll, check which members have posted. Track who has responded. Continue polling until either:
- All members have respo