roundtable-sh 0.1.1__tar.gz

roundtable_sh-0.1.1/.claude-plugin/marketplace.json

@@ -0,0 +1,19 @@
+{
+  "name": "frontier-infra",
+  "owner": {
+    "name": "Frontier Infra",
+    "url": "https://frontierinfra.org"
+  },
+  "description": "Frontier Infra plugins for Claude Code.",
+  "plugins": [
+    {
+      "name": "roundtable",
+      "source": "./",
+      "description": "Ask a council of AI models one question and get one decision back. Bundles the roundtable command, a skill, and an MCP tool.",
+      "version": "0.1.1",
+      "homepage": "https://roundtable.sh",
+      "license": "MIT",
+      "keywords": ["roundtable", "council", "consensus", "multi-model", "deliberation", "ai"]
+    }
+  ]
+}

roundtable_sh-0.1.1/.claude-plugin/plugin.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
+  "name": "roundtable",
+  "displayName": "Roundtable",
+  "version": "0.1.1",
+  "description": "Ask a council of AI models (Claude, OpenAI, Gemini, Grok, GLM, MiniMax) one question and get one decision back. Includes the roundtable command, a skill, and an MCP tool. Nothing else to install.",
+  "author": {
+    "name": "Frontier Infra",
+    "url": "https://frontierinfra.org"
+  },
+  "homepage": "https://roundtable.sh",
+  "repository": "https://github.com/frontier-infra/roundtable",
+  "license": "MIT",
+  "keywords": ["roundtable", "council", "consensus", "multi-model", "deliberation", "ai"],
+  "mcpServers": {
+    "roundtable": {
+      "command": "${CLAUDE_PLUGIN_ROOT}/bin/roundtable",
+      "args": ["mcp", "serve"],
+      "env": {
+        "ANTHROPIC_API_KEY": "${user_config.anthropic_api_key}",
+        "OPENAI_API_KEY": "${user_config.openai_api_key}",
+        "GEMINI_API_KEY": "${user_config.gemini_api_key}",
+        "XAI_API_KEY": "${user_config.xai_api_key}"
+      }
+    }
+  },
+  "userConfig": {
+    "anthropic_api_key": {
+      "type": "string",
+      "title": "Anthropic API key (optional)",
+      "description": "Adds the Claude head and the chair that calls consensus. Leave blank to skip.",
+      "sensitive": true
+    },
+    "openai_api_key": {
+      "type": "string",
+      "title": "OpenAI API key (optional)",
+      "description": "Adds the OpenAI head. Leave blank to skip.",
+      "sensitive": true
+    },
+    "gemini_api_key": {
+      "type": "string",
+      "title": "Gemini API key (optional)",
+      "description": "Adds the Gemini head. Leave blank to skip.",
+      "sensitive": true
+    },
+    "xai_api_key": {
+      "type": "string",
+      "title": "xAI API key (optional)",
+      "description": "Adds the Grok head. Leave blank to skip.",
+      "sensitive": true
+    }
+  }
+}

roundtable_sh-0.1.1/.gitignore

@@ -0,0 +1,15 @@
+# Roundtable tool repo
+*.log
+.DS_Store
+__pycache__/
+*.pyc
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+# never commit user secrets / local config
+config.env
+.api_keys
+# orchestration/session tooling state (not project files)
+.omx/

roundtable_sh-0.1.1/AGENTS.md

@@ -0,0 +1,172 @@
+# AGENTS.md — Roundtable
+
+A guide for coding agents (and the humans wiring them up). Roundtable is a CLI + MCP
+server that convenes a **council of frontier models** on a question and, optionally,
+runs a **chaired deliberation to consensus**. It's a [Frontier Infra](https://frontierinfra.org)
+project — we eat our own cooking: our own agents call Roundtable before the decisions
+that matter.
+
+## What it is
+
+One command, several model "heads", run in parallel:
+
+- **Advisory** (default) — every configured head answers once, blind to the others.
+- **Deliberation** (`--rounds N`) — heads read each other and revise; a Claude **chair**
+  declares `CONSENSUS` / `CONTINUE` and the run stops early on consensus.
+- **Research** (`--research`) — web on, multi-step, for answers that need current facts.
+
+Heads: `grok` · `codex` · `openai` · `glm` · `minimax` · `claude` · `gemini`. A head with
+no key/CLI is skipped inline — the council runs on whatever subset is configured (so it
+works on **API keys alone**, no local CLIs required).
+
+## Install
+
+### In Claude
+
+Paste these two lines into Claude Code:
+
+```text
+/plugin marketplace add frontier-infra/roundtable
+/plugin install roundtable@frontier-infra
+```
+
+That is all. The plugin brings the `roundtable` command, the Roundtable skill, and the
+`roundtable` MCP tool. Claude Code then asks for your API keys. Every key is optional, and
+any one key is enough to start. Run `/roundtable:setup` to see which models are ready.
+
+### Command line
+
+```bash
+uv tool install roundtable-sh
+```
+
+Other ways, one line each:
+
+```bash
+pipx install roundtable-sh
+pip install roundtable-sh
+uv tool install git+https://github.com/frontier-infra/roundtable   # works now, before the PyPI release
+pipx install git+https://github.com/frontier-infra/roundtable      # same, with pipx
+```
+
+The package is `roundtable-sh`. The command is `roundtable`. The PyPI package named
+`roundtable` is an unrelated project, so do not install it. Then run `roundtable auth` to
+add your keys.
+
+### Or run our installer
+
+```bash
+curl -fsSL https://roundtable.sh/install.sh | bash
+```
+
+What it does:
+
+- Checks that `bash`, `python3`, and `curl` are present.
+- Downloads Roundtable from this GitHub repository into `~/.local/share/roundtable`.
+- Links the `roundtable` command into `~/.local/bin`, and tells you if that folder is not
+  on your `PATH`.
+- Offers to run `roundtable auth` and `roundtable install`. Both are optional.
+
+It needs no `sudo` and changes nothing else. Read it first at
+https://roundtable.sh/install.sh.
+
+From a clone: `git clone https://github.com/frontier-infra/roundtable && cd roundtable && ./install.sh --from .`
+
+## Configure keys
+
+```bash
+roundtable auth                 # interactive: masked paste per provider, shows ✓/✗
+roundtable auth anthropic       # configure just one provider
+roundtable doctor               # which heads are configured + a reachability ping
+```
+
+Keys live in `~/.config/roundtable/config.env` (dotenv, `chmod 600`, sourced — no parser).
+You can also write it directly:
+
+```bash
+mkdir -p ~/.config/roundtable
+cat > ~/.config/roundtable/config.env <<'EOF'
+ANTHROPIC_API_KEY=sk-ant-...
+OPENAI_API_KEY=sk-...
+XAI_API_KEY=xai-...
+ZAI_API_KEY=...
+MINIMAX_API_KEY=...
+GEMINI_API_KEY=...
+EOF
+chmod 600 ~/.config/roundtable/config.env
+```
+
+Per-head model/enable overrides: `roundtable models` and `roundtable heads` (or edit
+`config.env`; `roundtable config` shows/edits it).
+
+## Run
+
+```bash
+roundtable "Should we use Postgres or SQLite for this service?"     # shorthand
+roundtable ask -q "..." --heads grok,claude,gemini                  # subset of heads
+roundtable ask -q "..." --rounds 3                                  # deliberate to consensus
+roundtable ask -q "..." -c ./context.md                            # shared background for every head
+roundtable ask -q "..." --research                                 # web on
+roundtable ask -q "..." --out /tmp/rt.md                           # also save the transcript
+```
+
+Flags: `-q/--question`, `-c/--context <file>`, `--heads ...`, `--rounds N`, `--research`,
+`--timeout <secs>`, `--out <file>`. Exit 0 if ≥1 head answered.
+
+**Output discipline:** always return the per-head results table **and** the judge's
+decision (chair verdict + your own moderator call). Never summarize without the table.
+
+## Use as MCP / wire into your harness
+
+Roundtable ships an MCP server as a subcommand of the one binary:
+
+```bash
+roundtable mcp serve     # stdio JSON-RPC; one tool: roundtable(question, heads?, rounds?, research?)
+roundtable mcp config    # prints the server JSON block to paste manually
+```
+
+One line for Claude Code (needs the command line install):
+
+```bash
+claude mcp add --scope user roundtable -- roundtable mcp serve
+```
+
+Auto-wire detected harnesses (idempotent — backs up first, never clobbers):
+
+```bash
+roundtable install                       # detect + wire everything present
+roundtable install --harness cursor,codex
+roundtable install --all                 # non-interactive
+```
+
+- **Claude Code** — installs this skill into `~/.agents/skills/roundtable/` (and `~/.claude*` profiles) **and** registers the MCP server.
+- **Cursor** — `~/.cursor/mcp.json`.
+- **Codex CLI** — `~/.codex/config.toml` `[mcp_servers.roundtable]`.
+- **generic** — prints the MCP JSON to paste anywhere else.
+
+The MCP server config any harness can use:
+
+```json
+{ "command": "roundtable", "args": ["mcp", "serve"] }
+```
+
+## Use in Claude Code (plugin)
+
+```text
+/plugin marketplace add frontier-infra/roundtable
+/plugin install roundtable@frontier-infra
+```
+
+The plugin bundles everything: the `roundtable` command on the Bash tool's `PATH`, the
+`roundtable` skill, `/roundtable:ask`, `/roundtable:setup`, and the `roundtable` MCP server.
+No separate CLI install is needed. API keys entered in the plugin settings reach the MCP
+server. The Bash command reads `~/.config/roundtable/config.env` instead.
+
+## Keep it current
+
+`roundtable version` · `roundtable update` (prints the right upgrade command for how you installed).
+
+---
+
+*Roundtable — a Frontier Infra project. MIT. https://roundtable.sh ·
+https://github.com/frontier-infra/roundtable*

roundtable_sh-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Frontier Infra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

roundtable_sh-0.1.1/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.5
+Name: roundtable-sh
+Version: 0.1.1
+Summary: A council of frontier models — for the decisions that matter. (a Frontier Infra project)
+Project-URL: Homepage, https://roundtable.sh
+Project-URL: Repository, https://github.com/frontier-infra/roundtable
+Project-URL: Issues, https://github.com/frontier-infra/roundtable/issues
+Author: Frontier Infra
+License: MIT
+License-File: LICENSE
+Keywords: ai,claude,cli,council,deliberation,gemini,grok,llm,mcp,openai
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# 🪑 Roundtable
+
+### A council of frontier models — for the decisions that matter.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](./LICENSE)
+[![A Frontier Infra project](https://img.shields.io/badge/Frontier_Infra-project-ff2e88)](https://frontierinfra.org)
+[![Website](https://img.shields.io/badge/web-roundtable.sh-0b0a0f)](https://roundtable.sh)
+[![CLI · MCP](https://img.shields.io/badge/CLI_·_MCP-any_harness-444)](#mcp--wire-into-your-harness)
+
+**One question → many minds → one decision.**
+
+Fan a question out to **Grok, Codex/OpenAI, GLM, MiniMax, Claude, and Gemini** in parallel,
+optionally **deliberate to consensus** with a chaired vote, and get back one decided answer —
+from the command line or any MCP-capable coding harness.
+
+</div>
+
+## Install
+
+### In Claude
+
+Paste these two lines into Claude Code:
+
+```text
+/plugin marketplace add frontier-infra/roundtable
+/plugin install roundtable@frontier-infra
+```
+
+That is all. The plugin brings the `roundtable` command, the Roundtable skill, and the
+`roundtable` MCP tool. Claude Code then asks for your API keys. Every key is optional, and
+any one key is enough to start. Run `/roundtable:setup` to see which models are ready.
+
+### Command line
+
+```bash
+uv tool install roundtable-sh
+```
+
+Other ways, one line each:
+
+```bash
+pipx install roundtable-sh
+pip install roundtable-sh
+uv tool install git+https://github.com/frontier-infra/roundtable   # works now, before the PyPI release
+pipx install git+https://github.com/frontier-infra/roundtable      # same, with pipx
+```
+
+The package is `roundtable-sh`. The command is `roundtable`. The PyPI package named
+`roundtable` is an unrelated project, so do not install it. Then run `roundtable auth` to
+add your keys.
+
+### Or run our installer
+
+```bash
+curl -fsSL https://roundtable.sh/install.sh | bash
+```
+
+What it does:
+
+- Checks that `bash`, `python3`, and `curl` are present.
+- Downloads Roundtable from this GitHub repository into `~/.local/share/roundtable`.
+- Links the `roundtable` command into `~/.local/bin`, and tells you if that folder is not
+  on your `PATH`.
+- Offers to run `roundtable auth` and `roundtable install`. Both are optional.
+
+It needs no `sudo` and changes nothing else. Read it first at
+https://roundtable.sh/install.sh.
+
+---
+
+## Why Roundtable?
+
+Every model has a blind spot it can't see. Right before an irreversible call — an
+architecture, a migration, a rewrite — is exactly when one model's confident answer
+deserves a second (and third, and fourth) opinion.
+
+Roundtable convenes a **panel of frontier models**. Each answers independently; then, for
+high-stakes calls, a **multi-round deliberation** lets every head read the whole table and
+revise until a **Claude chair** declares `CONSENSUS` or names the remaining disagreement.
+Disagreement is signal, not noise.
+
+- **🗳️ Advisory** *(default)* — every head answers once, blind to the others. Raw, independent reads.
+- **⚖️ Deliberation** (`--rounds N`) — heads see each other and revise; a neutral chair rules `CONSENSUS` / `CONTINUE` and stops early on agreement.
+- **🔑 API keys are enough** — no local CLIs required. Missing heads are skipped; the council runs on whatever subset you've configured.
+- **📦 One package, everywhere:** a Claude Code plugin, a CLI, and an MCP server from the same code.
+
+## Example
+
+```text
+$ roundtable "Reply with exactly: OK three words" --heads claude,gemini
+
+# 🪑 Round Table — 2 heads — advisory
+## 🔵 Claude (claude-opus-4-8, Anthropic)      → OK three words
+## ✨ Gemini (gemini-3.1-pro-preview, Google)  → OK three words
+```
+
+Add `--rounds 3` and the heads deliberate; a chair prints `VERDICT: CONSENSUS` (or
+`CONTINUE`) with the points they agreed on and any dissent named.
+
+## Quickstart
+
+```bash
+# 1. Configure keys (masked prompts; shows which heads are ✓/✗). Stored chmod-600
+#    in ~/.config/roundtable/config.env. Any subset works — missing heads are skipped.
+roundtable auth
+
+# 2. Ask the council
+roundtable "Postgres or SQLite for a single-tenant internal tool?"
+
+# 3. Deliberate to consensus on a high-stakes call
+roundtable ask -q "Should we rewrite the billing service in Go?" --rounds 3
+```
+
+`roundtable doctor` shows which heads are configured and pings each for reachability.
+
+### Flags
+
+`-q/--question` · `-c/--context <file>` (shared background for every head) ·
+`--heads grok,codex,openai,glm,minimax,claude,gemini` · `--rounds N` (deliberation) ·
+`--research` (web on, multi-step) · `--timeout <secs>` · `--out <file>`.
+
+Exit 0 if at least one head answered.
+
+## The heads
+
+| Head | Provider | Key / auth |
+|------|----------|------------|
+| 🤖 **Grok** | xAI | `XAI_API_KEY` (or local `grok` CLI / Hermes OAuth) |
+| 🧠 **Codex** | OpenAI | local `codex` CLI (read-only) |
+| 🧠 **OpenAI** | OpenAI | `OPENAI_API_KEY` (direct API — no local CLI needed) |
+| 🟣 **GLM** | Z.AI | `ZAI_API_KEY` |
+| 🟠 **MiniMax** | MiniMax | `MINIMAX_API_KEY` |
+| 🔵 **Claude** | Anthropic | `ANTHROPIC_API_KEY` (also the deliberation **chair**) |
+| ✨ **Gemini** | Google | `GEMINI_API_KEY` / `GOOGLE_API_KEY` |
+
+Heads with no key/CLI are skipped inline — the council runs on whatever subset you've
+configured, so **API keys alone are enough** (no local CLIs required).
+
+## MCP + wire into your harness
+
+Roundtable ships an MCP server as a subcommand of the one binary:
+
+```bash
+roundtable mcp serve     # stdio JSON-RPC; one tool: roundtable(question, heads?, rounds?, research?)
+roundtable mcp config    # prints the server JSON block to paste manually
+```
+
+Add it to Claude Code with one line (needs the command line install):
+
+```bash
+claude mcp add --scope user roundtable -- roundtable mcp serve
+```
+
+Auto-wire detected harnesses (idempotent — backs up first, never clobbers):
+
+```bash
+roundtable install                  # detect + wire everything present
+roundtable install --harness cursor,codex
+roundtable install --all            # non-interactive
+```
+
+Wires **Claude Code** (skill + MCP), **Cursor** (`~/.cursor/mcp.json`),
+**Codex CLI** (`~/.codex/config.toml`), and prints a generic JSON block for anything else:
+
+```json
+{ "command": "roundtable", "args": ["mcp", "serve"] }
+```
+
+## Use in Claude Code
+
+Install the plugin with the two lines under [In Claude](#in-claude). It adds:
+
+- `/roundtable:ask <question>`: ask the council and get one decision back.
+- `/roundtable:setup`: see which models are ready and how to add keys.
+- The Roundtable skill, which Claude uses when you say "ask the council" or "get a second opinion".
+- The `roundtable` MCP tool and the `roundtable` command.
+
+Already installed the command line version? `roundtable install` wires the skill and the MCP
+server into Claude Code, Cursor, and Codex instead.
+
+## Commands
+
+```
+roundtable "question"          shorthand for `ask`
+roundtable ask                 run the council (all engine flags)
+roundtable auth [provider]     configure API keys (masked, chmod-600)
+roundtable models              per-head model picker
+roundtable heads               enable/disable heads
+roundtable doctor              which heads are configured + reachability ping
+roundtable config              show / edit config.env
+roundtable mcp serve|config    MCP stdio server / print config
+roundtable install             auto-wire detected harnesses
+roundtable version | update    show version / upgrade in place
+```
+
+## For agents
+
+Building on top of Roundtable? See [`AGENTS.md`](./AGENTS.md) — a concise guide for an
+AI agent to install, configure, run, and wire Roundtable into its own harness.
+
+## Links
+
+- **Website & docs** — https://roundtable.sh
+- **Source** — https://github.com/frontier-infra/roundtable
+- **Frontier Infra** — https://frontierinfra.org
+
+## Privacy, trademarks, and decision limits
+
+Roundtable runs locally and does not send prompts, credentials, or outputs to a
+Frontier Infra service. It sends each requested prompt and supplied context
+directly to the model providers or authenticated local CLIs that the user
+configures. Those requests are governed by the selected providers' terms,
+privacy policies, retention settings, and charges. Keep secrets and data you
+are not authorized to disclose out of council inputs.
+
+Roundtable output is advisory. Agreement among models is not proof that a
+recommendation is correct, safe, lawful, or suitable for a production change.
+Provider and product names identify compatible services only. Roundtable and
+Frontier Infra are independent and are not sponsored or endorsed by those
+providers. See [TRADEMARKS.md](./TRADEMARKS.md).
+
+Website policies: [Privacy](https://roundtable.sh/docs/privacy) ·
+[Terms](https://roundtable.sh/docs/terms) ·
+[Support](https://github.com/frontier-infra/roundtable/issues)
+
+## License
+
+[MIT](./LICENSE) © Frontier Infra