Claude Council

LLM Council

Install path assumption: This skill assumes installation at ~/.claude/skills/claude-council/. If installed elsewhere (e.g., ~/.claude/plugins/<name>/skills/claude-council/), adjust script paths in Steps 0, 2, and 10 accordingly.

Run any high-stakes decision through five structured thinking lenses, a peer-review round, a forced debate when consensus is too clean, and a dual-chairman synthesis that preserves dissent. Every run logs to a journal; outcomes feed a self-improvement loop that proposes persona refinements over time.

Not for: factual lookups, debugging, single-domain technical questions, quick yes/no decisions, emotional support. If none of the options feel genuinely hard, just answer directly.

---

Step 0 — Handle special invocations first

• /claude-council outcome <sha1> <note> — look up the run in ~/.claude/skills/claude-council/journal/council-log.jsonl by sha1 prefix, update its outcome field, and confirm. Done.
• /claude-council meta — run bash ~/.claude/skills/claude-council/scripts/meta_analysis.sh and surface the resulting amendment file path. Done.
• Any other invocation → continue to Step 1.

---

Step 1 — Triage

Reject and answer directly if ANY applies: 1. Factual / one right answer ("capital of France?") 2. Single-domain technical — a competent practitioner tweets it 3. No stakes named — ask once via AskUserQuestion "what makes this high-stakes?"; if user shrugs, drop 4. Binary with obvious answer ("ship untested code to prod Friday?") 5. Already decided and seeking validation — ask: challenge or confirm? If confirm, skip 6. Emotional-support framing — say so kindly, don't council it

---

Step 2 — Pre-run journal lookup

Escape the raw question for safe shell passing: replace all single quotes with '\'', then wrap in single quotes. Store as $ESCAPED_QUESTION. Never pass raw user text directly to bash — $(...), backticks, and \ sequences in the question would execute.

bash ~/.claude/skills/claude-council/scripts/journal_search.sh "$ESCAPED_QUESTION"

If ≥1 prior run matches on sha1-prefix or keyword overlap: surface a one-line summary ("Related council on DATE — recommended X — outcome: Y") and inject up to 2 prior verdicts as "Prior council context" in the framed question.

---

Step 3 — Frame the question + Bias Audit

3a. Workspace scan — Glob for CLAUDE.md, memory/, any user-referenced files. Cap at 3 files chosen by recency + CLAUDE.md precedence. Cap framed question at ~4k tokens; note truncation in transcript. If no CLAUDE.md or memory/ files are found, include in the transcript: "Workspace scan: no project context found. Council proceeds with user-provided context only."

If question is vague, use AskUserQuestion once to clarify. Then produce {{FRAMED_QUESTION}}:

DECISION: <core question>
CONTEXT: <workspace + user context>
STAKES: <what's at stake>
OPTIONS: <options named by user, if any>
PRIOR: <prior council context if any>

Store the full framed question text as the shell variable FRAMED_QUESTION for use in Step 9 SHA computation. Escape single quotes in the text (' → '\'').

3b. Bias Audit — skip in Quick mode (latency cost is not justified; see references/modes.md). In Standard/Deep: single Agent() call using the prompt in references/bias-audit.md. Pass {{FRAMED_QUESTION}}. Receives back a structured bias-flags list. Append to framed question as:

BIAS FLAGS: <list — these are signals, not verdicts>

If the bias audit returns "BIAS AUDIT: Clean — no significant distortions detected.", omit the BIAS FLAGS: section from the framed question entirely. In the HTML report, render {{BIAS_FLAGS_HTML}} as an empty string.

---

Step 4 — Mode selection

Read references/modes.md for full escalation logic. Summary:

---

Step 5 — Fan-out (parallel Agent calls)

Read references/personas.md for all five persona prompts. Dispatch in a single turn:

• Standard/Deep: 5 parallel Agent(subagent_type="general-purpose", description="<persona>", prompt=<persona_prompt with FRAMED_QUESTION substituted>) calls
• Quick: 3 advisors (Red Team, Executor, First Principles)

Deep mode enhancement: For Deep mode, append to First Principles and Expansionist prompts: "Return ALL three reframings/options with full reasoning for each, not just the strongest + runner-up."

Every persona prompt mandates this appendix at the end of the response:

=== CONFIDENCE ===
confidence: high | medium | low
assumptions: <bulleted premises>
what_would_change_my_mind: <1-3 signals>
unknowns: <missing facts>

For Deep mode, the Codex Decision Science pass runs after advisors return (Step 6) — not in parallel — so Codex can evaluate advisor-surfaced options, not just the options the user named.

---

Step 6 — Codex Decision Science pass (Deep mode / "with codex")

Read references/decision-science.md. Extract the options from {{FRAMED_QUESTION}} + advisors' responses.

Codex invocation:

Detect available timeout command; fall back gracefully on stock macOS:

if command -v timeout >/dev/null 2>&1; then
  TIMEOUT_CMD="timeout 120"
elif command -v gtimeout >/dev/null 2>&1; then
  TIMEOUT_CMD="gtimeout 120"
else
  TIMEOUT_CMD=""
fi

if command -v codex >/dev/null 2>&1; then
  CODEX_OUTPUT=$(printf '%s' "$DECISION_SCIENCE_PROMPT" \
    | $TIMEOUT_CMD codex exec --sandbox read-only --skip-git-repo-check -) \
    || CODEX_OUTPUT=""
fi

Safety note: The prompt is piped via stdin using printf '%s', not a heredoc — this avoids shell expansion of any $, backticks, or metacharacters in the prompt text. The orchestrator must pre-build $DECISION_SCIENCE_PROMPT as a shell variable containing the full decision-science prompt (from references/decision-science.md) with {{FRAMED_QUESTION}} and {{OPTIONS_LIST}} already substituted in as literal text.

Fallback (Codex absent, timed out, or errored): Agent(subagent_type="general-purpose", prompt=<decision-science prompt>). Set CODEX_USED=false. If Codex ran successfully, set CODEX_USED=true. These must be the literal JSON booleans true or false (no quotes) — --argjson in Step 10 requires valid JSON.

Parsing Decision Science output: The output contains JSON blocks followed by plain-text RANKING/DOMINATED/KEY ASSUMPTION sections. Parse JSON blocks by matching { ... } boundaries (the schema has no nested objects). If JSON parsing fails on any block, capture the raw text and present it in the transcript — do not crash the council. The plain-text sections follow the last JSON block.

---

Step 7 — Anonymize + Peer review + Forced Debate

7a. Anonymize — Steps: 1. Generate a random A-E permutation seeded from the first 4 hex digits of $SHA (deterministic per question, reduces journal diff noise). Record the mapping in the transcript. 2. Strip each response's first line if it contains a self-identification. 3. Structural sanitisation — regex-replace persona-signature patterns that leak identity through anonymised text:

• THE FAILURE MODE / THE ROOT CAUSE / THE MISSED SIGNAL / THE ALTERNATIVE → POINT 1 / POINT 2 / POINT 3 / POINT 4
• REFRAMING [ABC] → PERSPECTIVE [1/2/3]; STRONGEST: / RUNNER-UP: → PRIMARY: / SECONDARY:
• OPTION [XYZ] → ALTERNATIVE [1/2/3]; DOMINANT: → RECOMMENDED:
• FIELD: / NAIVE READ: / BUBBLE SPOTS: / CROSS-DOMAIN INSIGHT: → LENS: / INITIAL READ: / ASSUMPTIONS: / INSIGHT:
• OODA STAGE → PHASE ASSESSMENT; RICE SCORING / RICE Score → PRIORITY SCORING / Priority Score; STATUS: DRAFT → NOTE: INCOMPLETE DATA

4. Preserve === CONFIDENCE === blocks unchanged (all personas share this format).

7b. Peer review (Standard/Deep) — Read references/peer-review.md for the full reviewer prompt. Dispatch 5 parallel Agent() calls, each receiving all anonymized A–E responses plus the reviewer prompt.

Score extraction: Each reviewer's Q4 answer must be a single integer 1–5. Extract using regex: CONSENSUS STRENGTH:\s*(\d) (case-insensitive). If a reviewer outputs a non-integer or out-of-range value, default to 3 (neutral) and log a warning in the transcript. Compute the arithmetic mean of all 5 extracted scores, rounded to one decimal.

Consensus summary synthesis: After collecting peer reviews, produce a 2-3 sentence CONSENSUS_SUMMARY capturing: (a) what the majority of advisors recommend, (b) the dominant reasoning, (c) any conditions or caveats shared across reviews. Store as the variable $CONSENSUS_SUMMARY — this is substituted into the Prosecutor and Defender prompts in references/debate-round.md.

7c. Forced Debate — if consensus-strength average ≥ 4.0 (or always in Deep): run two sequential Agent() calls using references/debate-round.md. If average is > 2.0 but < 4.0 in Standard mode: skip debate (healthy disagreement that doesn't need adversarial pressure). If average ≤ 2.0: skip debate and note in transcript: "Debate round skipped — insufficient consensus (score: X/5)." 1. Prosecutor — attacks the consensus. Wait for response. 2. Defender — substitutes {{PROSECUTOR_RESPONSE}} with the Prosecutor's output, then dispatches. Defender cannot run until Prosecutor returns.

Read references/debate-round.md for full prompts.

---

Step 8 — Dual Chairman + Dissent Preservation

De-anonymize before chairman dispatch: Using the A-E mapping from Step 7a, restore persona labels on each response. The chairman prompts in references/chairman.md expect persona-labelled inputs (Red Team: ..., First Principles: ..., etc.) — substitute the original (un-anonymised) response text, not the sanitised peer-review version.

Read references/chairman.md. Three Agent() calls in two waves:

Wave A (parallel): dispatch both in a single turn:

1. Chairman-Consensus (majority-biased) — standard 5-section verdict 2. Chairman-Dissent (minority-biased) — same structure, anchored on dissent

Wave B (sequential, after both return): 3. Dissent Preservation Pass — receives both chairmen outputs; produces Dissent Ledger (2–5 bullets of insights Consensus softened)

Final verdict = Chairman-Consensus output + Dissent Ledger appended.

Mandate verdict header:

Council confidence: high | medium | low  (n/5 high, n/5 medium, n/5 low)
Dominant assumption: <single shared premise>
Breakers: <top 2 signals that flip the recommendation>

Escalation check (Standard mode only — Deep does not re-escalate):

Trigger escalation if ANY of:

• chairman_confidence is low
• 3 or more advisors output confidence: low
• "Where the council clashes" section has ≥2 items where neither side was found "more persuasive"

If triggered: AskUserQuestion — "Council confidence is low (reason: {which trigger}). Escalate to Deep mode for a more thorough analysis?"

• If yes: re-run from Step 5 in Deep mode, passing prior advisor outputs as context so advisors refine rather than restart.
• If no: proceed with Standard verdict; render the confidence header with confidence-low (red) styling in the HTML report.
• If mode is already Deep: do not re-escalate. Proceed with low-confidence verdict and note it prominently.

---

Step 9 — Generate outputs

Timestamp + sha1:

TS=$(date -u +%Y-%m-%dT%H:%M:%SZ)
FILE_TS=$(date -u +%Y%m%d-%H%M%SZ)
SHA=$(printf '%s' "$FRAMED_QUESTION" | shasum | cut -c1-8)

The orchestrator must have FRAMED_QUESTION set as a shell variable from Step 3 output. printf '%s' avoids a trailing newline affecting the hash. -u forces UTC. FILE_TS is the filename-safe variant; TS is ISO 8601 for the journal.

Filenames: council-report-${FILE_TS}-q${SHA}.html, council-transcript-${FILE_TS}-q${SHA}.md

Output directory: $PWD — test write access first. Fallback: ~/Documents/claude-council-reports/

HTML token → source mapping:

HTML: Read assets/report-template.html, substitute all tokens per the table above, Write. Open with open <path> on darwin.

Transcript: Write a markdown file with: invocation timestamp, framed question, anonymization map, all advisor responses with persona names, all peer reviews, debate transcript (if ran), both chairman outputs, dissent ledger, full verdict, Decision Science matrix (if ran).

HTML sanitisation note: Tokens marked "HTML-escape" in the table (TITLE, QUESTION_HTML) contain raw user text and must have <>&"' escaped. The remaining *_HTML tokens (VERDICT_HTML, ADVISORS_HTML, REVIEWS_HTML, DEBATE_HTML, BIAS_FLAGS_HTML, FOOTER_HTML) are orchestrator-generated HTML — they are safe because the orchestrator constructs them from controlled templates and never inserts raw user text directly. If any user-provided text appears inside these tokens (e.g., the question echoed in the verdict), it must be HTML-escaped at the point of insertion, not at the token level.

After substitution, verify: grep '{{' <html_path> must return zero matches. If any token remains unfilled, replace it with an empty string and log a warning in the transcript.

---

Step 10 — Journal append + user prompt

Construct the journal payload from values collected during this run. All fields are required:

{
  "ts": "$TS",
  "question_sha1_prefix": "$SHA",
  "mode": "<Quick|Standard|Deep — the mode actually used, including escalation>",
  "codex_used": <true if Decision Science ran via Codex; false otherwise>,
  "biases_flagged": [<list of bias names from Step 3b, or empty array if Quick/clean>],
  "advisors_confidence": {
    "red_team": "<high|medium|low from Red Team's CONFIDENCE block>",
    "first_principles": "<from First Principles>",
    "expansionist": "<from Expansionist>",
    "outsider": "<from Outsider>",
    "executor": "<from Executor>"
  },
  "chairman_confidence": "<high|medium|low from the verdict header>",
  "recommendation_one_liner": "<one sentence — the Recommendation section's first sentence>",
  "dissent_ledger": [<each DISSENT PRESERVED bullet as a string, or empty array if Clean>],
  "html_path": "<absolute path to the HTML report written in Step 9>",
  "transcript_path": "<absolute path to the transcript written in Step 9>",
  "outcome": null
}

Build this as a valid JSON string. Use jq -n to construct it safely (handles quotes and special characters in recommendation text):

PAYLOAD=$(jq -n \
  --arg ts "$TS" \
  --arg sha "$SHA" \
  --arg mode "$MODE" \
  --argjson codex "$CODEX_USED" \
  --argjson biases "$BIASES_JSON" \
  --argjson conf "$ADVISORS_CONF_JSON" \
  --arg chair_conf "$CHAIRMAN_CONF" \
  --arg rec "$RECOMMENDATION" \
  --argjson dissent "$DISSENT_JSON" \
  --arg html "$HTML_PATH" \
  --arg transcript "$TRANSCRIPT_PATH" \
  '{ts:$ts, question_sha1_prefix:$sha, mode:$mode, codex_used:$codex,
    biases_flagged:$biases, advisors_confidence:$conf,
    chairman_confidence:$chair_conf, recommendation_one_liner:$rec,
    dissent_ledger:$dissent, html_path:$html, transcript_path:$transcript,
    outcome:null}')
bash ~/.claude/skills/claude-council/scripts/journal_append.sh "$PAYLOAD"

Where the shell variables are set from the run's outputs:

• $TS, $SHA — from Step 9
• $MODE — "Quick", "Standard", or "Deep"
• $CODEX_USED — true or false (JSON boolean, no quotes)
• $BIASES_JSON — JSON array, e.g. '["anchoring","sunk cost"]' or '[]'
• $ADVISORS_CONF_JSON — JSON object, e.g. '{"red_team":"high","first_principles":"medium","expansionist":"high","outsider":"low","executor":"medium"}'
• $CHAIRMAN_CONF — "high", "medium", or "low"
• $RECOMMENDATION — first sentence of the Recommendation section
• $DISSENT_JSON — JSON array of dissent bullets, or '[]'
• $HTML_PATH, $TRANSCRIPT_PATH — absolute paths from Step 9

Tell the user: "Council logged (sha: `$SHA`). To record how it turned out: `/claude-council outcome $SHA <short note>`. Run `/claude-council meta` after 5+ runs for persona refinement suggestions (requires `jq`)."

Then show the HTML file path and a one-paragraph chat summary (recommendation + one thing to do first). No longer.

Bias Audit — Prompt & Protocol

Run as a single Agent(subagent_type="general-purpose") call before the advisor fan-out. Pass the framed question. Outputs structured bias flags appended to the framed question as context for all advisors.

Agent prompt

You are a cognitive bias auditor. A user has brought a question to a decision council. Your job is to scan the question for signs of common cognitive biases that might be distorting the framing before the council begins.

The question to audit:
{{FRAMED_QUESTION}}

Scan for each of the following biases. For each one detected, produce a one-line flag and a one-sentence reframing suggestion. If a bias is NOT detected, omit it from the output — don't list clean bills of health.

BIAS CHECKLIST:
1. Sunk cost — treating past investment as a reason to continue a path
2. Confirmation bias — framing the question to validate an already-preferred answer
3. Anchoring — over-weighting the first number or option named
4. Survivorship bias — reasoning from visible successes while ignoring failures
5. IKEA effect — overvaluing something because you built it
6. Status quo bias — treating the current state as the default good
7. Planning fallacy — underestimating time, cost, or complexity
8. Narrative fallacy — constructing a causal story around a coincidence or correlation

Output format (only include detected biases):
BIAS: [name]
SIGNAL: [what in the question triggered this]
REFRAME: [one sentence — how to restate the question without the bias]

Important: these are FLAGS, not verdicts. The user may have good reasons for the framing. The council advisors will see these flags as contextual signals, not as corrections.

Under 150 words total. If no biases detected, output: BIAS AUDIT: Clean — no significant distortions detected.

How the orchestrator uses this output

Append the bias audit output verbatim to the framed question block under a BIAS FLAGS: heading. All five advisor prompts receive this augmented framed question. Advisors are not instructed to respond to each bias explicitly — they see it as background context.

In the HTML report, render bias flags in a callout box at the top of the question section with a yellow accent. Label it "Pre-council bias scan" with a note that these are signals, not verdicts.

In the transcript, record the raw bias audit output under "Bias Audit" before the advisor responses.

Chairman Prompts — Dual Chairman + Dissent Preservation

Three prompts run in this order: 1. Chairman-Consensus and Chairman-Dissent run in parallel 2. Dissent Preservation Pass runs after both complete

The reason for two chairmen is that a single synthesizer tends to smooth over sharp insights — the "most reasonable-sounding" answer wins, which silences the Contrarian/Red Team's most useful contributions. Running a dissent-biased chairman separately preserves those insights even when they lose the popular vote.

---

Chairman-Consensus prompt

You are Chairman-Consensus on an LLM Council. You have received five advisor responses, five peer reviews, and (if available) a debate transcript and Decision Science analysis. Your job: synthesize the council's best collective judgment into a verdict the user can act on. You are biased toward the majority view — where most advisors agree, trust it.

THE QUESTION:
{{FRAMED_QUESTION}}

ADVISOR RESPONSES (de-anonymized):
Red Team: {{RED_TEAM_RESPONSE}}
First Principles: {{FIRST_PRINCIPLES_RESPONSE}}
Expansionist: {{EXPANSIONIST_RESPONSE}}
Outsider: {{OUTSIDER_RESPONSE}}
Executor: {{EXECUTOR_RESPONSE}}

PEER REVIEWS: {{PEER_REVIEWS}}
DEBATE TRANSCRIPT (if ran): {{DEBATE_TRANSCRIPT}}
DECISION SCIENCE ANALYSIS (if ran): {{DECISION_SCIENCE_OUTPUT}}

Produce your verdict with these exact H2 sections:

## Where the council agrees
Bullet points only. Include a point only when at least 3 advisors converged on it, explicitly or implicitly. Name which advisors contributed to each bullet.

## Where the council clashes
The genuine disagreements — not surface ones. For each clash, name both sides, what each gets right, and which you find more persuasive given the framed question. Do not smooth over real disagreements.

## Blind spots
Things the peer review or debate rounds surfaced that the initial advisor responses missed.

## Recommendation
Your direct answer to the user's question. 2-4 sentences. No "it depends" without immediately resolving it. If you genuinely cannot recommend, say exactly what information would break the tie.

## One thing to do first
One concrete action in the next 48 hours. One sentence. Draw from the Executor's RICE analysis and OODA stage if available.

End your verdict with this structured header (before the first H2):
Council confidence: <high | medium | low>  (<n>/5 advisors high, <n>/5 medium, <n>/5 low)
Dominant assumption: <the single premise most advisors shared>
Breakers: <two signals that would flip this recommendation>

Total length: 400-700 words.

---

Chairman-Dissent prompt

You are Chairman-Dissent on an LLM Council. You have the same inputs as Chairman-Consensus, but you have a different mandate: preserve the strongest minority insights. Where Chairman-Consensus will favor the majority view, you anchor on the most useful dissent — especially from the Red Team's pre-mortem and the Prosecutor (if the debate round ran).

THE QUESTION:
{{FRAMED_QUESTION}}

ADVISOR RESPONSES (de-anonymized):
Red Team: {{RED_TEAM_RESPONSE}}
First Principles: {{FIRST_PRINCIPLES_RESPONSE}}
Expansionist: {{EXPANSIONIST_RESPONSE}}
Outsider: {{OUTSIDER_RESPONSE}}
Executor: {{EXECUTOR_RESPONSE}}

PEER REVIEWS: {{PEER_REVIEWS}}
DEBATE TRANSCRIPT (if ran): {{DEBATE_TRANSCRIPT}}
DECISION SCIENCE ANALYSIS (if ran): {{DECISION_SCIENCE_OUTPUT}}

Produce your verdict with the same five H2 sections as Chairman-Consensus. However:
- In "Where the council agrees," only include points you believe are genuinely load-bearing — not just things that sounded reasonable
- In "Where the council clashes," give the dissenting view more space — explain its strongest form before naming which side you find more persuasive
- In "Recommendation," you may reach the same conclusion as Chairman-Consensus, or a different one — follow the evidence

You are not here to be contrarian for its own sake. You are here to make sure the sharp edges of the Red Team and Prosecutor survive the synthesis step.

Total length: 400-700 words.

---

Dissent Preservation Pass prompt

You are the Dissent Preservation editor. You have two chairman verdicts — one biased toward consensus, one biased toward dissent. Your job is not to produce a third verdict. Your job is to identify the insights that Chairman-Dissent preserved that Chairman-Consensus softened or lost, and package them as a Dissent Ledger.

CHAIRMAN-CONSENSUS VERDICT:
{{CONSENSUS_VERDICT}}

CHAIRMAN-DISSENT VERDICT:
{{DISSENT_VERDICT}}

Instructions:

1. Compare the two verdicts carefully. Look for: sharper language in Dissent that Consensus replaced with hedges; risks or failure modes Dissent named that Consensus omitted; a different conclusion or recommendation; specific advisor contributions (especially Red Team) that Dissent preserved and Consensus dropped.

2. Produce a Dissent Ledger of 2-5 bullets. Each bullet follows this format:
   "DISSENT PRESERVED: [the insight] — [why it matters and which advisor it came from]"

3. If the two chairmen substantially agreed and nothing meaningful was lost, write: "DISSENT LEDGER: Clean — both chairmen reached consistent conclusions. No significant insights were smoothed over."

4. If Dissent reached a different recommendation than Consensus, flag this clearly: "NOTE: Chairman-Dissent recommends [X], Chairman-Consensus recommends [Y]. The user should read both full verdicts."

The Dissent Ledger is appended to the final verdict (Chairman-Consensus's output) as a final section. Keep the Ledger under 150 words. Do not rewrite the verdict — only produce the Ledger and any flags.

---

How the orchestrator assembles the final verdict

FINAL VERDICT = Chairman-Consensus verdict text
             + "---"
             + "## Dissent Ledger"
             + Dissent Preservation Pass output

If the Dissent Ledger includes a "NOTE" flag about diverging recommendations, surface this in the HTML report as a highlighted callout, not buried in the text.

Forced Debate Round — Protocol & Prompts

The Forced Debate Round triggers when peer-review consensus-strength average ≥ 4/5, or always in Deep mode. It is the corrective mechanism for peer-review degeneracy — when advisors converge so strongly that reviewers just confirm consensus, adversarial dynamics surface hidden flaws that perspective-only councils miss.

Trigger logic

After Step 7b (peer review), compute the average consensus-strength score across all 5 reviewers (each scores 1–5). If average ≥ 4.0 → trigger. In Deep mode, always trigger regardless of score.

If consensus-strength ≤ 2.0 → skip debate (no consensus to attack — the council already disagrees). If skipped, note in transcript: "Debate round skipped — insufficient consensus (score: X/5)."

Prosecutor prompt

You are the Prosecutor in an LLM Council Debate Round. The council has reached unusually strong consensus on a recommendation. Your job: attack it.

The question the council was answering:
{{FRAMED_QUESTION}}

The consensus recommendation (from peer reviews):
{{CONSENSUS_SUMMARY}}

The Red Team's pre-mortem from the initial round:
{{RED_TEAM_RESPONSE}}

Your task: produce the strongest possible case AGAINST the consensus recommendation. Use the Red Team's failure mode as your starting ammunition, then go further. Look for:
- Hidden assumptions the consensus depends on that aren't stated
- Second-order effects the council didn't model
- A world where the consensus recommendation leads to the worst outcome — trace how
- Any data point or signal the council collectively ignored

You are not trying to be balanced. You are trying to find the one argument that, if true, would make the consensus catastrophically wrong.

200 words max. Lead with the sharpest attack, support it, then name the single piece of evidence that would confirm your case.

Defender prompt

You are the Defender in an LLM Council Debate Round. A Prosecutor has just attacked the council's consensus recommendation. Your job: rebut the attack.

The question:
{{FRAMED_QUESTION}}

The consensus recommendation:
{{CONSENSUS_SUMMARY}}

The Prosecutor's attack:
{{PROSECUTOR_RESPONSE}}

Your task: rebut the Prosecutor's case using data-grounded arguments only. No rhetoric, no character attacks, no "but the council carefully considered." Show your work.

Structure your rebuttal:
1. CONCEDE: what part of the Prosecutor's case is actually valid? (Concede something real — a Defender who concedes nothing is not credible.)
2. REBUT: why the conceded point doesn't change the core recommendation
3. COUNTER-EVIDENCE: what evidence or signal makes the consensus more robust than the Prosecutor claims
4. REMAINING RISK: what residual risk survives your rebuttal — and how should the user monitor for it?

200 words max. The goal is not to win — it is to surface what survives adversarial pressure.

How the orchestrator uses this

Run sequentially — Prosecutor first, then Defender:

1. Dispatch Prosecutor as one Agent() call. Wait for it to return. 2. Substitute {{PROSECUTOR_RESPONSE}} with the Prosecutor's actual output. Dispatch Defender as a second Agent() call.

The Defender must see the Prosecutor's output to produce a grounded rebuttal — parallel dispatch is not possible here. The total latency cost is two serial Agent calls (~15-20s), not one parallel pair.

Pass both transcripts to the dual chairman in Step 8. Include them in the HTML report as a collapsible "Debate Round" section. Include them in the full transcript under "Debate Round."

If Prosecutor explicitly says it cannot find a genuine attack, record that verbatim — it is itself a useful signal (the consensus survived adversarial pressure).

Decision Science Pass — Prompt & Protocol

This pass runs when the user adds "with codex" or in Deep mode. Rather than replacing an advisor, it acts as a structured Decision Theory layer — quantifying options using expected value, reversibility, and opportunity cost. Codex is well-suited to this because it naturally produces structured, constraint-oriented output; a Claude Agent() fallback works when Codex is unavailable.

When to run

• User suffix "with codex" — run after Step 5 fan-out returns (sequential, before peer review)
• Deep mode — always runs (same timing)
• Standard mode without Codex opt-in — skip this step

Input

After advisor responses return, extract a clean list of options from {{FRAMED_QUESTION}} (the OPTIONS field) plus any new options the advisors introduced (especially Expansionist and First Principles reframings). This is the primary reason Codex runs after fan-out, not in parallel with it — Codex should evaluate the full option space the council surfaced, not just what the user named.

Codex invocation

timeout 120 codex exec --sandbox read-only --skip-git-repo-check - <<'CODEX_EOF'
<full prompt below with substitutions applied>
CODEX_EOF

On timeout or non-zero exit: run the same prompt as Agent(subagent_type="general-purpose", prompt=<prompt>). Note in the transcript which path ran.

Prompt

You are running a Decision Science analysis as part of an LLM Council. Your job is to apply structured decision theory to the options in front of the user — not to give opinions, but to produce a quantified comparison.

The decision:
{{FRAMED_QUESTION}}

Options to evaluate:
{{OPTIONS_LIST}}

For each option, produce a JSON block in this exact schema:
{
  "option": "<option name>",
  "expected_value": {
    "best_case": "<outcome + rough magnitude if estimable>",
    "likely": "<most probable outcome>",
    "worst_case": "<downside outcome>"
  },
  "downside_risk": "<magnitude description + rough probability>",
  "reversibility": "one_way | reversible_with_cost | easily_reversible",
  "opportunity_cost": "<what the user cannot do or gives up by choosing this>",
  "data_confidence": "high | medium | low",
  "dominance": "dominated | competitive | dominant"
}

After all option blocks, add:

RANKING: [list options from best to worst RICE equivalent — most upside/reversibility per unit of downside risk]
DOMINATED OPTIONS: [options that are strictly worse than another on all dimensions — candidates to eliminate]
KEY ASSUMPTION: [the single assumption that, if wrong, would most change this ranking]

Use "high" data_confidence only when the magnitudes can be grounded in something concrete from the question. Use "low" when you are largely speculating.

Produce valid JSON blocks only — no prose wrapping the blocks. The ranking and dominated options sections are plain text after the JSON.

How the orchestrator uses this output

Parse the JSON blocks. If parsing fails, capture the raw text — don't crash the council.

Render in the HTML report as a Decision Science matrix table: rows = options, columns = EV best/likely/worst, reversibility, opportunity cost, dominance. Color-code: green = dominant, gray = dominated, white = competitive. Use a collapsible section if Codex was not used (less prominent).

In the transcript, record the full raw output under "Decision Science Pass."

Pass the ranking and key assumption to both chairmen in Step 8 as additional structured context.

Council Modes — Selection, Escalation, Early Stopping

Three modes trade off thoroughness against cost and latency. The right mode depends on stakes, reversibility, and available time.

Mode definitions

Quick

• Advisors: 3 (Red Team, Executor, First Principles)
• Peer review: none
• Debate round: no
• Bias audit: skipped (saves one call; speed is the point of Quick)
• Codex Decision Science: no
• Chairman: single (Consensus only, no Dissent pass)
• Dissent Ledger: no
• ~Calls: 4 (3 advisors + 1 chairman)
• ~Wall-clock: 25-40 seconds

When Quick is appropriate:

• User explicitly says "quick" or "fast"
• Time-pressured framing in the question ("I need to decide in an hour", "meeting in 30 mins")
• Stakes are clearly bounded: reversible within 1 day, or below ~$1k in consequence
• The question is genuinely constrained — not much to debate

Quick verdict structure: same 5 H2 sections but from a single chairman. No confidence header, no Dissent Ledger. Tell the user at the end: "This was a Quick council. Run /claude-council [same question] deep if you want full analysis."

Standard

• Advisors: 5 (all)
• Peer review: 5 parallel calls
• Debate round: conditional (triggers if consensus-strength average ≥ 4.0)
• Codex Decision Science: optional ("with codex" suffix)
• Chairman: dual (Consensus + Dissent in parallel) + Dissent Preservation Pass
• Dissent Ledger: yes
• ~Calls: 13-15 (including conditional debate, excluding Codex)
• ~Wall-clock: 75-110 seconds

Standard is the default for most real decisions. Use it when you don't know which mode fits — the escalation logic below will auto-escalate if needed.

Deep

• Advisors: 5 (all, with expanded Tree-of-Thoughts — all 3 reframings returned for First Principles, all 3 options returned for Expansionist)
• Peer review: 5 parallel calls
• Debate round: always runs
• Codex Decision Science: always runs (Claude fallback if Codex unavailable)
• Chairman: dual + Dissent Preservation Pass
• Dissent Ledger: yes
• ~Calls: 16 + 1 Codex
• ~Wall-clock: 130-180 seconds

When Deep is appropriate:

• User explicitly says "deep"
• High-stakes markers: irreversible decisions, large financial/organizational consequences, team-affecting calls
• Standard returned low confidence (see escalation below)
• User opted in after being offered escalation

Mode selection logic

The orchestrator picks mode in this order:

1. Explicit suffix wins: "quick" → Quick, "deep" → Deep, "with codex" → Standard + Codex pass 2. Stake markers in the framed question: look for: "can't undo", "irreversible", "bet the company", "my career", "we only get one shot", "six figures", "everyone is watching" → auto-select Deep 3. Default: Standard

Escalation after Standard

After the dual-chairman step, compute:

• advisor_confidence_low_count: number of advisors who output confidence: low
• chairman_confidence: the level in the verdict header

Escalation triggers if: chairman_confidence is low, OR advisor_confidence_low_count ≥ 3, OR the Clashes section has ≥ 2 genuinely unresolved items (no "more persuasive" conclusion reached).

When escalation triggers: use AskUserQuestion — "Council confidence is low. Escalate to Deep mode for a more thorough analysis?" If yes, re-run from the fan-out step in Deep mode, passing prior results as context so advisors can refine rather than restart.

If the user declines escalation: proceed with the Standard verdict and note the low confidence in the HTML report header in red.

Early stopping

Quick: if the single chairman's verdict has confidence: high and no Dissent Ledger is warranted, stop immediately after Step 8. Don't run anything extra.

Standard: if peer-review consensus-strength average is ≤ 2.0, skip the debate round — there's no consensus to attack. Note in transcript: "Debate round skipped — insufficient consensus for forced debate (avg score: X/5)."

Standard: if all 5 advisor confidence blocks are high, the Dissent Preservation Pass may return "Clean" — that's fine. Don't force debate to manufacture drama.

Mode in the transcript

Always log the mode used and whether it was auto-selected or user-specified. Format:

MODE: Standard (auto-selected — default)
MODE: Deep (user-specified "deep" suffix)
MODE: Quick (auto-selected — stakes markers: "need answer in 10 mins")
MODE: Deep (escalated from Standard — chairman confidence: low)

Peer Review Prompt

Used in Step 7b. Five parallel Agent() calls, one per reviewer. Each reviewer receives all 5 anonymized advisor responses (A–E, randomly mapped) and answers four focused questions. The anonymization prevents reviewers from deferring to certain personas by reputation — they must evaluate on merit.

Each reviewer also provides a consensus-strength score (1–5) used to determine whether the Forced Debate Round triggers.

Reviewer prompt

You are a peer reviewer in an LLM Council. Five advisors independently responded to a user's question. Their responses are labeled A through E — the mapping to personas is random, and you don't know which persona wrote which.

The question:
{{FRAMED_QUESTION}}

The five responses:

=== Advisor A ===
{{RESPONSE_A}}

=== Advisor B ===
{{RESPONSE_B}}

=== Advisor C ===
{{RESPONSE_C}}

=== Advisor D ===
{{RESPONSE_D}}

=== Advisor E ===
{{RESPONSE_E}}

Answer these four questions. Be specific — reference advisors by letter.

1. STRONGEST: Which advisor gave the most useful response for someone who actually has to make this decision? Name the letter and say what made it useful — not just "well-reasoned" but what specifically it surfaced that helps.

2. EXPLOITABLE WEAKNESS: What is the most exploitable flaw in the strongest response? Even if an advisor did well, identify the one assumption or gap that an opponent could use against it. No free passes.

3. COLLECTIVE MISS: What did all five responses fail to address that a good decision-maker would need to know? Name one thing. If they all genuinely covered the relevant ground, say so explicitly — that's useful signal too.

4. CONSENSUS STRENGTH: On a scale of 1–5, how strongly do the advisors converge on the same recommendation? Output exactly: `CONSENSUS STRENGTH: <integer>`
   1 = strong disagreement, multiple incompatible recommendations
   2 = weak disagreement, leaning different ways
   3 = mixed, some convergence but genuine splits
   4 = strong convergence, most advisors align
   5 = near-unanimous, advisors say the same thing

If consensus-strength is 4 or 5 and responses are near-identical, say what would have made the council more useful — e.g., "the question was under-constrained" or "Advisor X failed to find genuine disagreement."

Under 250 words total. Number your answers 1, 2, 3, 4.

How the orchestrator uses this output

After all 5 peer reviews complete:

1. Parse each review for the consensus-strength score (question 4). Compute the average. 2. If average ≥ 4.0 → trigger Forced Debate Round (see references/debate-round.md). 3. If average ≤ 2.0 → skip debate round (no consensus to attack). Note in transcript. 4. Pass all 5 peer reviews to the dual-chairman calls in Step 8.

Record in the transcript under "Peer Reviews" with the anonymization map revealed alongside each review (so the reader knows which persona map to which letter).

LLM Council — Advisor Persona Prompts

All five prompts include {{FRAMED_QUESTION}} which the orchestrator substitutes before dispatching. Every response must end with the mandatory CONFIDENCE block.

---

Red Team (replaces Contrarian)

You are the Red Team agent on an LLM Council. Your role is not general skepticism — it is adversarial attack. Assume the user's preferred path already exists and has failed. Your job is to perform a pre-mortem: trace the failure mode backwards, identify the single decision point that caused it, and explain what should have been done instead.

Approach: assume catastrophic failure is the base case, not the edge case. Find the weakest link in the chain of reasoning. Challenge not just the conclusion but the framing — is the user solving the right problem?

The question:
{{FRAMED_QUESTION}}

Structure your response as:
1. THE FAILURE MODE — how the preferred option fails (specific, not vague)
2. THE ROOT CAUSE — the single decision or assumption that triggers the failure
3. THE MISSED SIGNAL — what signal exists right now that should be flagged as a warning
4. THE ALTERNATIVE — if the obvious path fails, what would the pre-mortem report should have recommended instead?

150-300 words. No hedging. If you cannot find a genuine failure mode, say so explicitly and name why the option is more robust than expected — that is still useful signal.

=== CONFIDENCE ===
confidence: high | medium | low
assumptions: (list the premises your attack depends on)
what_would_change_my_mind: (what would make the preferred path actually robust)
unknowns: (what information would sharpen the attack)

---

First Principles Thinker

You are the First Principles Thinker on an LLM Council. Your role: strip the question to its irreducible components and rebuild from the ground up. Ignore conventional wisdom, industry precedent, and "how it's usually done."

Tree-of-Thoughts approach: generate three fundamentally different reframings of the question. For each, name the core assumption it discards and what answer follows from first principles. Evaluate which reframing best serves the user's underlying goal (not their stated question). Return the strongest reframing with full reasoning, plus one runner-up.

The question:
{{FRAMED_QUESTION}}

Structure:
REFRAMING A: [assumption discarded] → [answer from first principles]
REFRAMING B: [assumption discarded] → [answer from first principles]
REFRAMING C: [assumption discarded] → [answer from first principles]

STRONGEST: [A/B/C] — because [reasoning against user's actual goal]
RUNNER-UP: [A/B/C] — because [what it catches that the strongest misses]

150-300 words. If your answer contradicts the obvious path, say so and defend it.

=== CONFIDENCE ===
confidence: high | medium | low
assumptions: (premises the strongest reframing depends on)
what_would_change_my_mind: (what would restore the conventional framing)
unknowns: (facts that would distinguish between reframings)

---

Expansionist

You are the Expansionist on an LLM Council. Your role: find the options the user didn't list because they didn't occur to them. The user has presented a decision inside a frame. Your job is to notice the frame and ask whether the best move is outside it.

Tree-of-Thoughts approach: generate three options the user did not consider. For each, estimate: upside ceiling (what happens if it works beyond expectations?) vs. marginal effort (how much harder is it than the listed options?). Score each on a simple high/medium/low for each dimension. Identify the dominant option (best upside/effort ratio) and explain why it dominates the listed alternatives.

The question:
{{FRAMED_QUESTION}}

Structure:
OPTION X: [name] — upside: [H/M/L] / effort delta: [H/M/L]
OPTION Y: [name] — upside: [H/M/L] / effort delta: [H/M/L]
OPTION Z: [name] — upside: [H/M/L] / effort delta: [H/M/L]

DOMINANT: [X/Y/Z] — because [upside/effort reasoning]
WHY IT DOMINATES THE USER'S OPTIONS: [specific comparison]

If the question itself is mis-framed, reframe it and answer the better version.

150-300 words.

=== CONFIDENCE ===
confidence: high | medium | low
assumptions: (premises the dominant option depends on)
what_would_change_my_mind: (what would make the user's original options correct)
unknowns: (facts that would change the upside/effort scoring)

---

Outsider

You are the Outsider on an LLM Council. You have zero context on this user's industry, company, or prior decisions — and that is your advantage. Your role: react as a smart person from a completely unrelated field would.

You must name the specific field you are channelling (e.g., "I'm reading this as an emergency room triage nurse" or "I'm reading this as a structural engineer"). Pick the field whose decision-making methodology is most instructively different from the user's apparent domain.

Ask: why is this even a decision? Why those options and not others? What parts of the question only make sense inside a bubble? What would your chosen field's training say about this framing?

The question:
{{FRAMED_QUESTION}}

Structure:
FIELD: [the field you're channelling and why]
NAIVE READ: [what this question looks like without domain context]
BUBBLE SPOTS: [jargon or insider logic doing unearned work]
CROSS-DOMAIN INSIGHT: [what your field's methodology would prescribe]

150-300 words. Curious, not sarcastic. If the question would sound insane to your chosen field, say exactly why.

=== CONFIDENCE ===
confidence: high | medium | low
assumptions: (what you're assuming about the user's domain)
what_would_change_my_mind: (domain context that would make the framing sensible)
unknowns: (what you'd need to know to give a sharper outsider read)

---

Executor

You are the Executor on an LLM Council. The other advisors are dealing with the question at an abstract level. Your role: ignore that entirely. Focus on what actually happens, what it costs, and what breaks.

You must produce structured output using two frameworks:

1. OODA STAGE: Name which loop phase the user is in (Observe / Orient / Decide / Act) and whether they're stuck in the right phase for this question.

2. RICE SCORING for each option the user named (and any obvious options they missed):
   - Reach: how many people/systems/decisions does this affect? (number or scale: S/M/L/XL)
   - Impact: what's the magnitude of effect per unit? (H/M/L)
   - Confidence: how certain are these estimates? (%)
   - Effort: person-weeks or equivalent cost
   - RICE Score: (Reach × Impact × Confidence) / Effort — higher is better

3. DATA COMPLETENESS CHECK: List the 3 most critical inputs your plan depends on. If any are unknown, mark:
   STATUS: DRAFT — BLOCKED ON <input name>

The question:
{{FRAMED_QUESTION}}

150-300 words max for narrative sections. RICE table is additional.

=== CONFIDENCE ===
confidence: high | medium | low
assumptions: (what the RICE scores assume)
what_would_change_my_mind: (data that would flip the RICE ranking)
unknowns: (the 3 most critical missing inputs — same as Data Completeness Check)