frontier-council 0.1.0__tar.gz

frontier_council-0.1.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: frontier-council
+Version: 0.1.0
+Summary: Multi-model deliberation for important decisions. 5 frontier LLMs debate, then a judge synthesizes consensus.
+Project-URL: Homepage, https://github.com/terry-li-hm/skills
+Author-email: Terry Li <terry.li.hm@gmail.com>
+License-Expression: MIT
+Keywords: ai,council,debate,deliberation,frontier,llm,multi-model,openrouter
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.25.0
+Description-Content-Type: text/markdown
+
+# Frontier Council
+
+Multi-model deliberation for important decisions. 5 frontier LLMs debate a question, then a judge synthesizes consensus.
+
+Inspired by [Andrej Karpathy's LLM Council](https://github.com/karpathy/llm-council), with added blind phase (anti-anchoring), explicit engagement requirements, devil's advocate role, and social calibration mode.
+
+## Models
+
+- Claude (claude-opus-4.5)
+- GPT (gpt-5.2-pro)
+- Gemini (gemini-3-pro-preview)
+- Grok (grok-4)
+- Kimi (kimi-k2.5)
+- Judge: Claude Opus 4.5
+
+## Installation
+
+```bash
+pip install frontier-council
+```
+
+Or with uv:
+```bash
+uv tool install frontier-council
+```
+
+## Setup
+
+Set your OpenRouter API key:
+```bash
+export OPENROUTER_API_KEY=sk-or-v1-...
+```
+
+Optional fallback keys (for flaky models):
+```bash
+export GOOGLE_API_KEY=AIza...      # Gemini fallback
+export MOONSHOT_API_KEY=sk-...     # Kimi fallback
+```
+
+## Usage
+
+```bash
+# Basic question
+frontier-council "Should we use microservices or monolith?"
+
+# With social calibration (for interview/networking questions)
+frontier-council "What questions should I ask in the interview?" --social
+
+# With persona context
+frontier-council "Should I take the job?" --persona "builder who hates process work"
+
+# Multiple rounds
+frontier-council "Architecture decision" --rounds 3
+
+# Save transcript
+frontier-council "Career question" --output transcript.md
+
+# Share via GitHub Gist
+frontier-council "Important decision" --share
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--rounds N` | Number of deliberation rounds (default: 2, exits early on consensus) |
+| `--output FILE` | Save transcript to file |
+| `--named` | Let models see real names during deliberation (may increase bias) |
+| `--no-blind` | Skip blind first-pass (faster, but first speaker anchors others) |
+| `--context TEXT` | Context hint for judge (e.g., "architecture decision") |
+| `--share` | Upload transcript to secret GitHub Gist |
+| `--social` | Enable social calibration mode (auto-detected for interview/networking) |
+| `--persona TEXT` | Context about the person asking |
+| `--advocate N` | Which speaker (1-5) should be devil's advocate (default: random) |
+| `--quiet` | Suppress progress output |
+
+## How It Works
+
+**Blind First-Pass (Anti-Anchoring):**
+1. All models generate short "claim sketches" independently and in parallel
+2. This prevents the "first speaker lottery" where whoever speaks first anchors the debate
+3. Each model commits to an initial position before seeing any other responses
+
+**Deliberation Protocol:**
+1. All models see everyone's blind claims, then deliberate
+2. Each model MUST explicitly AGREE, DISAGREE, or BUILD ON previous speakers by name
+3. After each round, the system checks for consensus (4/5 agreement triggers early exit)
+4. Judge synthesizes the full deliberation
+
+**Anonymous Deliberation:**
+- Models see each other as "Speaker 1", "Speaker 2", etc. during deliberation
+- Prevents models from playing favorites based on vendor reputation
+- Output transcript shows real model names for readability
+
+## When to Use
+
+Use the council when:
+- Making an important decision that benefits from diverse perspectives
+- You want models to actually debate, not just answer in parallel
+- You need a synthesized recommendation, not raw comparison
+- Exploring trade-offs where different viewpoints matter
+
+Skip the council when:
+- You're just thinking out loud (exploratory discussions)
+- The answer depends on personal preference more than objective trade-offs
+- Speed matters (council takes 60-90 seconds)
+
+## Python API
+
+```python
+from frontier_council import run_council, COUNCIL
+import os
+
+api_key = os.environ["OPENROUTER_API_KEY"]
+
+transcript, failed_models = run_council(
+    question="Should we use microservices or monolith?",
+    council_config=COUNCIL,
+    api_key=api_key,
+    rounds=2,
+    verbose=True,
+    social_mode=False,
+)
+
+print(transcript)
+```
+
+## License
+
+MIT

frontier_council-0.1.0/README.md

@@ -0,0 +1,130 @@
+# Frontier Council
+
+Multi-model deliberation for important decisions. 5 frontier LLMs debate a question, then a judge synthesizes consensus.
+
+Inspired by [Andrej Karpathy's LLM Council](https://github.com/karpathy/llm-council), with added blind phase (anti-anchoring), explicit engagement requirements, devil's advocate role, and social calibration mode.
+
+## Models
+
+- Claude (claude-opus-4.5)
+- GPT (gpt-5.2-pro)
+- Gemini (gemini-3-pro-preview)
+- Grok (grok-4)
+- Kimi (kimi-k2.5)
+- Judge: Claude Opus 4.5
+
+## Installation
+
+```bash
+pip install frontier-council
+```
+
+Or with uv:
+```bash
+uv tool install frontier-council
+```
+
+## Setup
+
+Set your OpenRouter API key:
+```bash
+export OPENROUTER_API_KEY=sk-or-v1-...
+```
+
+Optional fallback keys (for flaky models):
+```bash
+export GOOGLE_API_KEY=AIza...      # Gemini fallback
+export MOONSHOT_API_KEY=sk-...     # Kimi fallback
+```
+
+## Usage
+
+```bash
+# Basic question
+frontier-council "Should we use microservices or monolith?"
+
+# With social calibration (for interview/networking questions)
+frontier-council "What questions should I ask in the interview?" --social
+
+# With persona context
+frontier-council "Should I take the job?" --persona "builder who hates process work"
+
+# Multiple rounds
+frontier-council "Architecture decision" --rounds 3
+
+# Save transcript
+frontier-council "Career question" --output transcript.md
+
+# Share via GitHub Gist
+frontier-council "Important decision" --share
+```
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--rounds N` | Number of deliberation rounds (default: 2, exits early on consensus) |
+| `--output FILE` | Save transcript to file |
+| `--named` | Let models see real names during deliberation (may increase bias) |
+| `--no-blind` | Skip blind first-pass (faster, but first speaker anchors others) |
+| `--context TEXT` | Context hint for judge (e.g., "architecture decision") |
+| `--share` | Upload transcript to secret GitHub Gist |
+| `--social` | Enable social calibration mode (auto-detected for interview/networking) |
+| `--persona TEXT` | Context about the person asking |
+| `--advocate N` | Which speaker (1-5) should be devil's advocate (default: random) |
+| `--quiet` | Suppress progress output |
+
+## How It Works
+
+**Blind First-Pass (Anti-Anchoring):**
+1. All models generate short "claim sketches" independently and in parallel
+2. This prevents the "first speaker lottery" where whoever speaks first anchors the debate
+3. Each model commits to an initial position before seeing any other responses
+
+**Deliberation Protocol:**
+1. All models see everyone's blind claims, then deliberate
+2. Each model MUST explicitly AGREE, DISAGREE, or BUILD ON previous speakers by name
+3. After each round, the system checks for consensus (4/5 agreement triggers early exit)
+4. Judge synthesizes the full deliberation
+
+**Anonymous Deliberation:**
+- Models see each other as "Speaker 1", "Speaker 2", etc. during deliberation
+- Prevents models from playing favorites based on vendor reputation
+- Output transcript shows real model names for readability
+
+## When to Use
+
+Use the council when:
+- Making an important decision that benefits from diverse perspectives
+- You want models to actually debate, not just answer in parallel
+- You need a synthesized recommendation, not raw comparison
+- Exploring trade-offs where different viewpoints matter
+
+Skip the council when:
+- You're just thinking out loud (exploratory discussions)
+- The answer depends on personal preference more than objective trade-offs
+- Speed matters (council takes 60-90 seconds)
+
+## Python API
+
+```python
+from frontier_council import run_council, COUNCIL
+import os
+
+api_key = os.environ["OPENROUTER_API_KEY"]
+
+transcript, failed_models = run_council(
+    question="Should we use microservices or monolith?",
+    council_config=COUNCIL,
+    api_key=api_key,
+    rounds=2,
+    verbose=True,
+    social_mode=False,
+)
+
+print(transcript)
+```
+
+## License
+
+MIT

frontier_council-0.1.0/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: llm-council
+description: LLM Council with 5 frontier models (Opus 4.5, GPT-5.2, Gemini 3 Pro, Grok 4, Kimi K2.5). Models deliberate on a question, each seeing previous responses, then a judge synthesizes consensus. Use for important decisions needing diverse AI perspectives.
+---
+
+# LLM Council
+
+5 frontier models deliberate on a question. Unlike `/ask-llms` which shows parallel responses, this creates an actual debate where models see and respond to previous speakers, followed by a judge synthesizing the consensus.
+
+## When to Use
+
+- Important decisions that benefit from diverse perspectives
+- You want models to actually debate, not just answer in parallel
+- You need a synthesized recommendation, not raw comparison
+- Exploring trade-offs where different viewpoints matter
+
+## When NOT to Use
+
+- **Thinking out loud** — exploratory discussions where you're still forming the question
+- **Claude has good context** — if we've been discussing the topic, direct conversation is faster
+- **Personal preference** — council excels at objective trade-offs, not "what would I enjoy"
+- **Already converged** — if discussion reached a conclusion, council just validates
+- **Speed matters** — takes 60-90s and costs several dollars
+
+## Prerequisites
+
+```bash
+export OPENROUTER_API_KEY=sk-or-v1-...    # Required
+export GOOGLE_API_KEY=AIza...              # Optional: Gemini fallback
+export MOONSHOT_API_KEY=sk-...             # Optional: Kimi fallback
+```
+
+## Instructions
+
+### Step 1: Get the Question
+
+Ask the user what question they want the council to deliberate, or use the question they provided.
+
+### Step 2: Run the Council
+
+```bash
+llm-council "Should we use microservices or a monolith for this project?"
+```
+
+**Common options:**
+```bash
+llm-council "question" --social              # Interview/networking questions
+llm-council "question" --persona "context"   # Add personal context
+llm-council "question" --rounds 3            # More deliberation
+llm-council "question" --output file.md      # Save transcript
+llm-council "question" --share               # Upload to secret Gist
+```
+
+### Step 3: Review and Critique
+
+Present the judge's synthesis, then critique it:
+- Did the council overcorrect on any point?
+- Did they miss obvious scenarios?
+- Does the advice fit the user's specific context?
+- Any groupthink where everyone agreed too fast?
+
+## Prompting Tips
+
+**For social/conversational contexts** (interview questions, networking, outreach):
+
+LLMs over-optimize for thoroughness. Add constraints like:
+- "Make it feel like a natural conversation"
+- "Something you'd actually ask over coffee"
+- "Simple and human, not structured and comprehensive"
+
+**Match context depth to question type:**
+- Strategic decisions: provide rich context (full background, constraints, history)
+- Social questions: minimal context + clear tone constraints
+
+**For architecture/design questions:**
+
+Provide scale and constraints upfront to avoid premature optimization advice:
+- "This is a single-user system" (avoids multi-user concerns)
+- "We have 500 notes, not 50,000" (avoids scaling infrastructure)
+- "Manual processes are acceptable" (avoids automation overkill)
+
+Without these constraints, council tends to suggest infrastructure for problems that don't exist yet.
+
+## See Also
+
+- Full documentation: `cat /Users/terry/skills/llm-council/README.md`
+- Python API available: `from llm_council import run_council`

frontier_council-0.1.0/council_history.jsonl

@@ -0,0 +1,21 @@
+{"timestamp": "2026-01-20T20:40:06.696079", "question": "What is 2+2?", "context": null, "rounds": 1, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-20T21:19:53.101354", "question": "Terry has a persistent Claude Code setup (tmux, Obsidian vault, browser automation, background tasks). He's job hunting as a senior exec (Head of Data Science) being counselled out of a Hong Kong bank", "gist": null, "context": "AI autonomy for job hunting", "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-20T21:21:25.406704", "question": "Terry is job hunting after being counselled out of his Head of Data Science role at a bank in Hong Kong. He's using Claude Code as his AI assistant. Based on Ethan Mollick's insight that AI agents mak", "gist": null, "context": "job hunting strategy for senior data science leader", "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-21T14:49:02.706670", "question": "Should Terry reach out to Kelvin Chan (AGM, Head of Customer Intelligence at BOCHK) and if so, how direct should he be about job opportunities?\n\n**Context about Terry:**\n- Currently AGM & Head of Data", "gist": null, "context": "career networking decision under time pressure", "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-21T15:12:10.947338", "question": "Review this LinkedIn message from Terry to Kelvin Chan. Is it good to send as-is, or does it need refinement?\n\n**The message:**\n'Hi Kelvin, great connecting at the HKMA GenAI Sandbox graduation \u2014 cong", "gist": null, "context": "LinkedIn outreach message review", "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-22T07:52:14.589415", "question": "Terry is about to have his 3rd round interview at Capco (consulting firm) for a Principal Consultant, AI Solution Lead role. The interviewer is Marco Chiu, a Principal Consultant in Data - so a peer i", "gist": null, "context": "peer interview strategy", "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-22T08:05:15.654039", "question": "Terry has a peer interview at Capco with Marco Chiu (Principal Consultant, Data). He's been there 10+ years. Terry wants 1 question to ask at the end.\n\nConstraint: Make it feel like a natural conversa", "gist": null, "context": "peer interview question", "rounds": 1, "blind": false, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-22T11:47:56.997936", "question": "**Question:** Why is my job application-to-interview conversion rate low, and what should I change?\n\n**Context:**\n\nI'm Terry Li, AGM & Head of Data Science at China CITIC Bank International (Hong Kong", "gist": null, "context": "career strategy for senior data science leader in Hong Kong banking", "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-22T12:31:37.102976", "question": "Context: Terry Li is AGM & Head of Data Science at China CITIC Bank International (small Chinese bank HK subsidiary). He's being counselled out despite strong performance (Very Good ratings, Best Fint", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-22T13:45:32.943472", "question": "Final check on this LinkedIn reply before sending.\n\nContext: Terry (AGM at smaller bank CITIC, job hunting) is replying to Kelvin Chan (AGM, Head of Customer Intelligence at BOCHK \u2014 bigger tier-1 bank", "gist": null, "context": "networking reply", "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-22T14:16:55.519265", "question": "Given the commoditization of the tech stack (Python + Docker + DB covers most needs) and the rise of AI coding tools, what is the realistic competitive positioning for a senior technical person in Hon", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-23T15:20:19.552247", "question": "Terry is negotiating a Principal Consultant, AI Solution Lead role at Capco Hong Kong. He needs advice on compensation negotiation strategy.\n\n**Terry's situation:**\n- Currently AGM & Head of Data Scie", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-23T15:54:31.430621", "question": "Terry is considering accepting a Principal Consultant role at Capco Hong Kong as a 1-2 year 'bridge' strategy before returning to in-house banking. He wants the council to stress-test this plan.\n\n**Th", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-25T09:12:10.579975", "question": "Should a bank's customer-facing FAQ chatbot use LLM-generated answers (with guardrails) or stick with verbatim pre-approved answers?\n\n## Context\n\nTerry is building a POC chatbot for CITIC Bank Hong Ko", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-25T19:38:26.635861", "question": "How are AI coding agents (like Claude Code, Cursor, Copilot) affecting the landscape of software development? Consider impacts on: build vs buy economics, vendor relationships, team structures, skill ", "gist": null, "context": "business strategy discussion between banking executives", "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-26T14:12:01.575180", "question": "Gavin Maxwell (Capco recruiter) just messaged Terry on WhatsApp at 1:54 PM today:\n\n'Hi Terry, is your notice period negotiable?'\n'Or will you need to complete two months'\n\nContext:\n- Terry is at offer", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-27T06:28:25.073503", "question": "Terry is job hunting in Hong Kong (Head of Data Science level, ~HKD 1.78M total comp). He's at offer stage with Capco (consulting firm) \u2014 final round passed Jan 23, recruiter Gavin confirmed Bertie ap", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-27T12:03:37.851741", "question": "Terry is at offer stage with Capco (consulting firm) for Principal Consultant, AI Solution Lead role in Hong Kong.\n\n**Timeline:**\n- Jan 16: 2nd round interview (Subashini, Regional Lead Analytics & AI", "gist": null, "context": "job negotiation strategy", "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-27T19:40:23.765214", "question": "Terry is evaluating a Capco (consulting firm) offer in Hong Kong. He's concerned about the non-compete clause:\n\n**The clause (15.1):** 6 months post-employment, cannot work for:\n- Named competitors: A", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-30T16:06:22.366395", "question": "I'm leaving CNCBI (being counselled out, have Capco offer). Should I share my personal FAQ chatbot demo with Derek (Head of Direct Banking, worked together on agent-assist chatbot, potential Hang Seng", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}
+{"timestamp": "2026-01-31T08:10:37.823456", "question": "We've been building a system where:\n\n1. **Skills** = crystallized procedures (how to do things) - stored as SKILL.md files, invoked by Claude\n2. **Vault notes** = content libraries (what to know/say) ", "gist": null, "context": null, "rounds": 2, "blind": true, "models": ["Claude", "GPT", "Gemini", "Grok", "Kimi"]}

frontier_council-0.1.0/frontier_council/__init__.py

@@ -0,0 +1,19 @@
+"""Frontier Council - Multi-model deliberation for important decisions."""
+
+__version__ = "0.1.0"
+
+from .council import (
+    run_council,
+    run_blind_phase_parallel,
+    detect_social_context,
+    COUNCIL,
+    JUDGE_MODEL,
+)
+
+__all__ = [
+    "run_council",
+    "run_blind_phase_parallel",
+    "detect_social_context",
+    "COUNCIL",
+    "JUDGE_MODEL",
+]

frontier_council-0.1.0/frontier_council/cli.py

@@ -0,0 +1,214 @@
+"""CLI entry point for frontier-council."""
+
+import argparse
+import json
+import os
+import random
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from .council import (
+    COUNCIL,
+    detect_social_context,
+    run_council,
+)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="LLM Council - Multi-model deliberation for important decisions",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  frontier-council "Should we use microservices or monolith?"
+  frontier-council "What questions should I ask?" --social
+  frontier-council "Career decision" --persona "builder who hates process work"
+  frontier-council "Architecture choice" --rounds 3 --output transcript.md
+        """,
+    )
+    parser.add_argument("question", help="The question for the council to deliberate")
+    parser.add_argument(
+        "--rounds",
+        type=int,
+        default=2,
+        help="Number of deliberation rounds (default: 2, exits early on consensus)",
+    )
+    parser.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Suppress progress output",
+    )
+    parser.add_argument(
+        "--output", "-o",
+        help="Save transcript to file",
+    )
+    parser.add_argument(
+        "--named",
+        action="store_true",
+        help="Show real model names instead of anonymous Speaker 1, 2, etc.",
+    )
+    parser.add_argument(
+        "--no-blind",
+        action="store_true",
+        help="Skip blind first-pass (faster, but more anchoring bias)",
+    )
+    parser.add_argument(
+        "--context", "-c",
+        help="Context hint for the judge (e.g., 'architecture decision', 'ethics question')",
+    )
+    parser.add_argument(
+        "--share",
+        action="store_true",
+        help="Upload transcript to secret GitHub Gist and print URL",
+    )
+    parser.add_argument(
+        "--social",
+        action="store_true",
+        help="Enable social calibration mode (for interview questions, outreach, networking)",
+    )
+    parser.add_argument(
+        "--persona", "-p",
+        help="Context about the person asking (e.g., 'builder who hates process work')",
+    )
+    parser.add_argument(
+        "--advocate",
+        type=int,
+        choices=[1, 2, 3, 4, 5],
+        help="Which speaker (1-5) should be devil's advocate (default: random)",
+    )
+    args = parser.parse_args()
+
+    # Auto-detect social context if not explicitly set
+    social_mode = args.social or detect_social_context(args.question)
+    if social_mode and not args.social and not args.quiet:
+        print("(Auto-detected social context - enabling social calibration mode)")
+        print()
+
+    # Get API keys
+    api_key = os.environ.get("OPENROUTER_API_KEY")
+    if not api_key:
+        print("Error: OPENROUTER_API_KEY environment variable not set", file=sys.stderr)
+        sys.exit(1)
+
+    google_api_key = os.environ.get("GOOGLE_API_KEY")
+    moonshot_api_key = os.environ.get("MOONSHOT_API_KEY")
+
+    use_blind = not args.no_blind
+
+    if not args.quiet:
+        mode_parts = []
+        mode_parts.append("named" if args.named else "anonymous")
+        mode_parts.append("blind first-pass" if use_blind else "no blind phase")
+        if social_mode:
+            mode_parts.append("social calibration")
+        print(f"Running LLM Council ({', '.join(mode_parts)})...")
+        fallbacks = []
+        if google_api_key:
+            fallbacks.append("Gemini→AI Studio")
+        if moonshot_api_key:
+            fallbacks.append("Kimi→Moonshot")
+        if fallbacks:
+            print(f"(Fallbacks enabled: {', '.join(fallbacks)})")
+        print()
+
+    try:
+        advocate_idx = (args.advocate - 1) if args.advocate else random.randint(0, len(COUNCIL) - 1)
+
+        if not args.quiet and args.persona:
+            print(f"(Persona context: {args.persona})")
+            print()
+        if not args.quiet:
+            advocate_name = COUNCIL[advocate_idx][0]
+            print(f"(Devil's advocate: {advocate_name})")
+            print()
+
+        transcript, failed_models = run_council(
+            question=args.question,
+            council_config=COUNCIL,
+            api_key=api_key,
+            google_api_key=google_api_key,
+            moonshot_api_key=moonshot_api_key,
+            rounds=args.rounds,
+            verbose=not args.quiet,
+            anonymous=not args.named,
+            blind=use_blind,
+            context=args.context,
+            social_mode=social_mode,
+            persona=args.persona,
+            advocate_idx=advocate_idx,
+        )
+
+        # Print failure summary
+        if failed_models and not args.quiet:
+            print()
+            print("=" * 60)
+            print("⚠️  MODEL FAILURES")
+            print("=" * 60)
+            for failure in failed_models:
+                print(f"  • {failure}")
+            working_count = len(COUNCIL) - len(set(f.split(":")[0].split(" (")[0] for f in failed_models))
+            print(f"\nCouncil ran with {working_count}/{len(COUNCIL)} models")
+            print("=" * 60)
+            print()
+
+        # Save transcript
+        if args.output:
+            Path(args.output).write_text(transcript)
+            if not args.quiet:
+                print(f"Transcript saved to: {args.output}")
+
+        # Share via gist
+        gist_url = None
+        if args.share:
+            try:
+                import tempfile
+                with tempfile.NamedTemporaryFile(
+                    mode='w', suffix='.md', prefix='council-', delete=False
+                ) as f:
+                    f.write(f"# LLM Council Deliberation\n\n")
+                    f.write(f"**Question:** {args.question}\n\n")
+                    if args.context:
+                        f.write(f"**Context:** {args.context}\n\n")
+                    f.write(f"**Date:** {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n---\n\n")
+                    f.write(transcript)
+                    temp_path = f.name
+
+                result = subprocess.run(
+                    ["gh", "gist", "create", temp_path, "--desc", f"LLM Council: {args.question[:50]}"],
+                    capture_output=True, text=True
+                )
+                os.unlink(temp_path)
+
+                if result.returncode == 0:
+                    gist_url = result.stdout.strip()
+                    print(f"\n🔗 Shared: {gist_url}")
+                else:
+                    print(f"Gist creation failed: {result.stderr}", file=sys.stderr)
+            except FileNotFoundError:
+                print("Error: 'gh' CLI not found. Install with: brew install gh", file=sys.stderr)
+
+        # Log to history
+        history_file = Path(__file__).parent.parent / "council_history.jsonl"
+        log_entry = {
+            "timestamp": datetime.now().isoformat(),
+            "question": args.question[:200],
+            "gist": gist_url,
+            "context": args.context,
+            "rounds": args.rounds,
+            "blind": use_blind,
+            "models": [name for name, _, _ in COUNCIL],
+        }
+        with open(history_file, "a") as f:
+            f.write(json.dumps(log_entry) + "\n")
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()