trantor 0.17.48 → 0.17.50

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + context-handoff for independent AI coding agents (Claude, Codex, Gemini, …)",
-    "version": "0.17.48"
+    "version": "0.17.50"
   },
   "plugins": [
     {
       "name": "trantor",
       "source": "./",
       "description": "The hub-world for AI agent crews. Say \"fire up the crew\" and Claude becomes the architect: a plan-aware Advisor routes the work (solo / cheap inline calls / live crew of Codex, GLM, Kimi & DeepSeek in their own terminal windows), a Kanban/flow command center with a testing gate tracks it, and an economics brain (Scrooge) keeps the receipts. Includes the relay MCP, a SessionStart auto-discovery hook, and a PreCompact context-handoff so a fresh session can take over a full window instead of compacting.",
-      "version": "0.17.48",
+      "version": "0.17.50",
       "author": {
         "name": "Sasha Bogojevic"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.48",
+  "version": "0.17.50",
   "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + crew orchestration for independent AI coding agents (Claude, Codex, Gemini, Kimi, DeepSeek)",
   "mcpServers": {
     "relay": {

package/README.md

@@ -12,14 +12,14 @@
 ### The hub-world for AI agent crews.
 
 **One Advisor decides how your work runs — solo, cheap inline calls, or a live crew of
-Claude Code, Codex, GLM, Kimi & DeepSeek in their own terminal windows — routed by your
-actual plans, supervised on a live + historical board you can scroll back through, learning
-from every failure.**
+Claude Code, Codex, GLM, Kimi, DeepSeek — or *any model you bring* — in their own terminal
+windows, routed by your actual plans, supervised on a live + historical board you can scroll
+back through, learning from every failure.**
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
 ![Node](https://img.shields.io/badge/node-%E2%89%A518-339933?logo=node.js&logoColor=white)
-![Agents](https://img.shields.io/badge/crew-Claude%20%C2%B7%20Codex%20%C2%B7%20Gemini%20%C2%B7%20Kimi%20%C2%B7%20DeepSeek-D97757)
-![Tests](https://img.shields.io/badge/tests-80%2F80-2DD4BF)
+![Agents](https://img.shields.io/badge/crew-Claude%20%C2%B7%20Codex%20%C2%B7%20GLM%20%C2%B7%20Kimi%20%C2%B7%20DeepSeek%20%C2%B7%20%2BBYOM-D97757)
+![Tests](https://img.shields.io/badge/tests-passing-2DD4BF)
 
 </div>
 
@@ -42,6 +42,12 @@ claude plugin install trantor
 That's it. (Prefer source? `git clone https://github.com/sashabogi/trantor && cd trantor &&
 npm install && bash deploy/setup.sh` — identical result.)
 
+**Recommended companion (macOS):** [**cmux**](https://cmux.com) — `brew install --cask cmux` — a
+native terminal built for running multiple AI agents. Trantor groups each crew into one cmux workspace
+with live per-seat status in the sidebar and project-scoped teardown. See
+*[Grouped crews in cmux](#grouped-crews-in-cmux-recommended)*. Optional — crews also run in tmux or plain
+Terminal windows.
+
 ## What gets installed — footprint & safety
 
 Trantor is a **local-first multi-agent orchestrator with a built-in cost router** — not a cloud
@@ -65,9 +71,10 @@ on your machine, so you (or an agent installing it for you) can see the whole fo
   **SubagentStop** (record each sub-agent's notional cost on the board).
 
 **What it does *not* do:** no cloud, no accounts, no telemetry, nothing phones home; it never uploads
-your code or keys; it doesn't touch other CLIs' credentials — Codex, Gemini, Kimi and DeepSeek are
-ones *you* already installed and signed into, and Trantor just coordinates them locally. The optional
-API keys in `~/.agent-bus/.env` are used only to call the cheap models *you* opted into for routing.
+your code or keys; it doesn't touch other CLIs' credentials — Codex, Kimi, DeepSeek, GLM (and any
+provider you bring) are ones *you* already installed and signed into, and Trantor just coordinates
+them locally. The optional API keys in `~/.agent-bus/.env` are used only to call the models *you*
+opted into for routing.
 
 **Remove everything, anytime:**
 ```bash
@@ -134,12 +141,16 @@ project takes over with a full window (and a PreCompact hook does this automatic
    (`solo | scrooge | crew | hybrid`), a routing table with a **reason per package**, why
    that many seats ("seats follow the work, not the install list"), and a real-money estimate
    with quota-pool accounting. You say go.
-2. **Windows open.** `trantor up codex kimi deepseek:deepseek glm:zai-coding-plan` spawns one titled
-   terminal window per agent. `agent:model` pins a model; `agent:provider --difficulty hard`
-   picks the **best live model** for the work at spawn (capability × cost), enumerated from the
-   CLI itself — never a guessed endpoint. **Serialized and then verified on the bus** — the
-   launcher ends with "crew verified" or names the no-shows loudly. The orchestrator never gets
-   a green lie.
+2. **Windows open.** `trantor up codex kimi deepseek:deepseek glm:zai-coding-plan` spawns the crew in
+   visible terminals — grouped into **one [cmux](https://cmux.com) workspace per project** when cmux is
+   installed (seats tiled, live status in the sidebar; see *[Grouped crews in cmux](#grouped-crews-in-cmux-recommended)*
+   below), else tmux, else one titled Terminal window per seat. The seats aren't a fixed list — they're **whatever you've got**:
+   the native CLIs (Codex, Kimi) plus *any* provider wired through OpenCode (DeepSeek, GLM, and
+   **OpenRouter's hundreds of models, or a custom endpoint you bring** — see *Bring your own
+   model* below). `agent:model` pins a model; `agent:provider --difficulty hard` picks the
+   **best live model** for the work at spawn (capability × cost), enumerated from the provider
+   itself — never a guessed endpoint. **Serialized and then verified on the bus** — the launcher
+   ends with "crew verified" or names the no-shows loudly. The orchestrator never gets a green lie.
 3. **Work flows over the bus.** Contracts arrive as messages; each agent owns its own files;
    coordination happens in <280-char messages you can read on the dashboard. Crew members
    live under a **runner**: the CLI works one turn and exits, the runner long-polls the bus
@@ -156,6 +167,33 @@ project takes over with a full window (and a PreCompact hook does this automatic
 6. **It learns.** Failures become lessons (`relay_lesson`), stored on the hub and **injected
    into every future crew's prompts** — global or per-CLI. Your crew gets smarter every run.
 
+### Grouped crews in cmux (recommended)
+
+Trantor runs crews in visible terminals so nothing dies or fails silently. On macOS it prefers
+**[cmux](https://cmux.com)** — a native, Ghostty-based terminal *built for managing multiple AI coding
+agents* — and falls back to **tmux**, then plain Terminal windows.
+
+With cmux, each crew becomes **one workspace tab per project**, its seats tiled inside, every pane
+labeled `<agent> · <project>`, and each seat pushes its **live state into cmux's sidebar** —
+`building` (blue) while a turn runs, `idle` when it's waiting, `error`/`down` (red) on a failed turn —
+plus a per-crew progress pill. Teardown is **project-scoped**: `trantor down` closes only *this*
+project's workspace, so when you run several sessions each driving its own crew, one session's teardown
+can't nuke another's. `trantor down <agent>` drops a single seat; `trantor down --all --yes` tears down
+every project's crew.
+
+**One-time setup:**
+- Install cmux — `brew install --cask cmux` (or grab it from **[cmux.com](https://cmux.com)**).
+- Trantor drives cmux over its control socket, which is off to outside processes by default. Enable it in
+  `~/.config/cmux/cmux.json` (cmux auto-reloads):
+  ```json
+  { "automation": { "socketControlMode": "allowAll" } }
+  ```
+  This lets local processes drive your terminals. Leave it on the default `cmuxOnly` and Trantor
+  automatically falls back to AppleScript (same grouped layout, minus the native sidebar status).
+- The `cmux` CLI is symlinked onto your PATH on your first `trantor up`.
+
+No cmux or tmux? Crews still work — one titled Terminal window per seat, still project-scoped teardown.
+
 ## The dashboard — `trantor ui`
 
 A live command center at `http://127.0.0.1:4477`, grouped by **project** — and a *durable,
@@ -202,6 +240,39 @@ ledger; Trantor turns that into decisions:
 - **Fractal delegation** (`relay_scrooge`): the architect *and* crew members push stateless
   grunt work to cheap models, with ledger receipts.
 
+## Bring your own model (BYOM)
+
+The crew roster isn't a hardcoded list — it's **derived from what you've configured**. Trantor
+ships built-in seats for Codex and Kimi (native CLIs) and DeepSeek + GLM (via OpenCode), but
+**any** provider OpenCode can reach becomes a first-class seat with its own identity on the
+board — no code change, no waiting for us to add it.
+
+- **OpenRouter is the on-ramp.** One key fronts **hundreds of models** (incl. vendors that have
+  no CLI of their own). Drop `OPENROUTER_API_KEY` in `~/.agent-bus/.env` and `openrouter` is a
+  seat: `trantor up openrouter` live-selects the best model for the work, or
+  `trantor up openrouter:openrouter/<vendor>/<model>` pins one.
+- **Add any provider in one command:**
+  ```bash
+  trantor provider add <name> --key sk-… --plan api          # a provider OpenCode already knows
+  trantor provider add acme --key sk-… --base-url https://api.acme.ai/v1 --models acme-lg,acme-sm
+  ```
+  The second form wires a **custom OpenAI-compatible endpoint** into OpenCode for you (no
+  hand-editing config). Then `trantor provider` lists every seat with its availability + tier, and
+  `trantor models [<provider>]` browses the live models behind a seat — including the router's pick
+  per difficulty so you can see *hard → strong, easy → cheap* at a glance.
+- **It routes by difficulty, not just price.** `scrooge-capabilities` scores a provider's whole
+  catalog (real Artificial-Analysis benchmarks where a model matches, a price-tier proxy for the
+  long tail) and the router weighs **capability × cost, gated by the work's difficulty** — so hard
+  work escalates to a genuinely strong model while easy work stays cheap. Run it once (a weekly
+  cron keeps it fresh): `scrooge-capabilities`.
+- **Every seat is its own colleague.** Each opencode-driven provider gets a distinct bus label
+  (`glm:<project>`, `openrouter:<project>`, `acme:<project>`), so they never collide and each shows
+  up as its own agent on the dashboard.
+
+> Brought a key for Inception, a new Japanese model, a niche fine-tune? `trantor provider add` it,
+> `scrooge-capabilities` scores it, and the Advisor routes to it by difficulty — same as the
+> built-ins.
+
 ## Context handoff — sessions that never hit the wall
 
 A PreCompact hook writes a rich handoff before Claude Code compacts; a fresh session in the
@@ -231,29 +302,41 @@ rate, not work rate.
 ## The CLI
 
 ```
-trantor setup | doctor | connect | profile | up <agents…> | swap <old> <new> | down | ui | advise | hub | watch
+trantor setup | doctor | connect | profile | provider | models
+        | up <agents…> | swap <old> <new> | down | ui | advise | hub | watch
 ```
 
-`trantor up` notes: `agent:model` pins a model (`deepseek:deepseek-v4-pro`); `agent:provider
---task <k> --difficulty <d>` picks the **best live model** for the work at spawn
-(`glm:zai-coding-plan --difficulty hard`); spawns are verified on the bus with one retry;
-geometry auto-detects the screen you're working on (`CREW_RECT="X,Y,W,H"` to override). `trantor
-swap <oldAgent> <newSpec>` replaces an exhausted agent with a live-selected one. `trantor down`
-kills crew processes via their ttys and closes windows without macOS "Terminate?" dialogs.
+- **`trantor provider`** — `list` every crew seat (built-in + brought) with availability + tier ·
+  `add <name> --key … [--plan api] [--base-url <url> --models a,b]` to bring any provider (custom
+  endpoints are wired into OpenCode for you) · `remove <name>`.
+- **`trantor models [<provider>]`** — browse the live models behind each seat + the router's pick
+  per difficulty.
+- **`trantor up`** — `agent:model` pins a model (`deepseek:deepseek-v4-pro`); `agent:provider
+  --task <k> --difficulty <d>` picks the **best live model** for the work at spawn
+  (`glm:zai-coding-plan --difficulty hard`); spawns are verified on the bus with one retry;
+  geometry auto-detects the screen you're working on (`CREW_RECT="X,Y,W,H"` to override).
+- **`trantor swap <oldAgent> <newSpec>`** replaces an exhausted agent with a live-selected one.
+- **`trantor down`** kills crew processes via their ttys and closes windows without macOS
+  "Terminate?" dialogs.
 
 ## Works with any MCP agent
 
-Claude Code, Codex CLI, Gemini CLI, Kimi Code CLI, OpenCode (DeepSeek) are wired by
-`trantor connect` automatically (idempotent, backed-up, never overwrites your customizations).
-Anything else that speaks MCP: point it at `mcp.mjs` with `RELAY_AGENT=<brand>` — loading the
-server auto-registers the session, so presence works before the model says a word.
+Claude Code, Codex CLI, Kimi Code CLI, and **OpenCode** (the universal adapter — DeepSeek, GLM,
+OpenRouter, and any provider you bring) are wired by `trantor connect` automatically (idempotent,
+backed-up, never overwrites your customizations). Anything else that speaks MCP: point it at
+`mcp.mjs` with `RELAY_AGENT=<brand>` — loading the server auto-registers the session, so presence
+works before the model says a word.
+
+*(Gemini CLI: Google retired the free seat in 2026, so it's no longer a default crew seat —
+GLM via OpenCode is its replacement. Gemini still works as a Scrooge cheap-model via
+`GEMINI_API_KEY`, and a paid-key holder can still run `trantor up gemini`.)*
 
 ## How it works
 
 ```
- Claude (architect/plugin)   codex ─ runner   gemini ─ runner   kimi ─ runner   deepseek ─ runner
+ Claude (architect/plugin)   codex ─ runner   kimi ─ runner   opencode ─ runner (DeepSeek·GLM·OpenRouter·BYOM)
         │ advise/contracts        │ one turn, exit; runner long-polls (free) + resumes with context
-        └───────────┬─────────────┴──────────────┴────────────────┴────────────────┘
+        └───────────┬─────────────┴──────────────┴───────────────────────────────────┘
                     ▼
               hub.mjs  ←— plain HTTP + SSE · presence/messages/board/history/lessons/learning/economics
               (Node built-ins only · state in ~/.agent-bus/bus.json · loopback by default)
@@ -286,10 +369,11 @@ The `relay_*` tool names and the `~/.agent-bus` state dir remain until a later r
 ## Tests
 
 ```bash
-npm test    # 80 checks: unit + protocol-level scenario drills with mock agents (no LLMs, seconds, $0):
-            # honest presence + TTL prune, spawn no-shows, the testing gate, bounce trails, lessons,
-            # /history + backfill, /learning shape, /todos sync, /card detail, advisor decisions across
-            # plan tiers, deps validation, virgin-machine doctor, and failure-classification drills
+npm test    # unit + 120+ protocol-level scenario drills + capability-routing, all with mock agents
+            # (no LLMs, seconds, $0): honest presence + TTL prune, spawn no-shows, the testing gate,
+            # bounce trails, lessons, /history + backfill, /learning shape, /todos sync, /card detail,
+            # advisor decisions across plan tiers, BYOM roster derivation + brought-provider routing,
+            # difficulty-aware model selection, deps validation, virgin-machine doctor, failure drills
 ```
 
 ## License

package/bin/cli.mjs

@@ -23,7 +23,7 @@ switch (cmd) {
   case "advise":  run("bin/advise.mjs"); break;
   case "verify":  run("bin/crew-verify.mjs"); break;
   case "up":      process.argv.splice(2, 1); spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "up", ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
-  case "down":    spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "down"], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
+  case "down":    spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "down", ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
   case "swap":    spawn("/bin/bash", [join(ROOT, "bin/crew.sh"), "swap", ...args], { stdio: "inherit", cwd: process.cwd() }).on("exit", c => process.exit(c ?? 0)); break;
   case "hub":     run("hub.mjs"); break;
   case "watch":   run("bin/relay-watch.mjs"); break;
@@ -31,6 +31,7 @@ switch (cmd) {
   case "agents":  run("bin/agents.mjs"); break;
   case "gates":   run("bin/gates.mjs"); break;
   case "backfill": run("bin/git-backfill.mjs"); break;
+  case "sweep": run("bin/sweep.mjs"); break;
   case "init-hooks": run("bin/init-hooks.mjs"); break;
   case "balances": case "balance": case "credits": run("bin/balances.mjs"); break;
   case "recost": run("bin/recost.mjs"); break;

package/bin/crew-runner.mjs

@@ -50,6 +50,22 @@ async function api(path, body) {
   return r.json();
 }
 
+// ---- cmux sidebar integration ----
+// When this runner is inside a cmux surface (CMUX_SURFACE_ID is auto-set there), push its live state into
+// cmux's sidebar for THIS seat. An inside process is allowed by cmux's default cmuxOnly socket mode — no
+// allowAll needed. Fail-silent + short timeout; must never block or slow a turn.
+const CMUX_BIN = process.env.CMUX_BIN
+  || (existsSync("/Applications/cmux.app/Contents/Resources/bin/cmux") ? "/Applications/cmux.app/Contents/Resources/bin/cmux" : "cmux");
+const inCmux = () => !!process.env.CMUX_SURFACE_ID;
+function cmuxStatus(value, color, icon = "robot") {
+  if (!inCmux()) return;
+  try { spawnSync(CMUX_BIN, ["set-status", "trantor", value, "--color", color, "--icon", icon], { stdio: "ignore", timeout: 1500, env: { ...process.env, CMUX_QUIET: "1" } }); } catch {}
+}
+function cmuxLog(message, level = "info") {
+  if (!inCmux()) return;
+  try { spawnSync(CMUX_BIN, ["log", String(message).slice(0, 200), "--level", level], { stdio: "ignore", timeout: 1500, env: { ...process.env, CMUX_QUIET: "1" } }); } catch {}
+}
+
 // ---- per-CLI invocation (first turn vs resume turn). {P} = prompt file path ----
 // CREW_MODEL env pins the model: each CLI gets its own flag via {M} (empty when unset).
 let MODEL = process.env.CREW_MODEL || "";
@@ -119,6 +135,7 @@ async function reportFailure(exit, trigger) {
     ? `🛑 ${SESSION} DOWN — ${consecFails} consecutive failures (${reason}, exit ${exit})${hint}`
     : `⚠️ ${SESSION} turn FAILED (${trigger}, exit ${exit} · ${reason})${hint}`;
   await api("/send", { from: SESSION, to: "all", text, project: PROJ }).catch(() => {});
+  cmuxStatus(down ? "down" : "error", "#ef6a6a", "alert"); cmuxLog(`turn failed: ${reason} (exit ${exit})`, "error");
   log(`\x1b[31mreported failure to bus: ${reason} (exit ${exit})\x1b[0m`);
 }
 
@@ -127,6 +144,7 @@ async function reportHealthy() {
   consecFails = 0;
   await api("/register", { session: SESSION, project: PROJ, status: `active in ${PROJ}` }).catch(() => {});
   await api("/send", { from: SESSION, to: "all", text: `✅ ${SESSION} recovered`, project: PROJ }).catch(() => {});
+  cmuxStatus("ok", "#14b8a6", "check");
 }
 
 let sid = "";
@@ -142,6 +160,7 @@ function runTurn(prompt, isFirst, trigger = "kickoff") {
   const envs = [join(homedir(), ".agent-bus", ".env"), cli.env].filter(f => f && existsSync(f));
   for (const f of envs.reverse()) cmd = `set -a; source ${f}; set +a; ${cmd}`;   // ~/.agent-bus/.env wins
   log(`turn starting (${isFirst ? "fresh session" : "resume"})${MODEL ? ` · model=${MODEL}` : ""}`);
+  cmuxStatus("building", "#4a90d9", "hammer");
   // inherit stdio so the window shows the agent working live; also capture for sid-parsing.
   // Tee stderr to ERRF (still shown live in the window) so a failed turn can be classified.
   try { appendFileSync(ERRF, "", { flag: "w" }); } catch {}
@@ -155,6 +174,7 @@ function runTurn(prompt, isFirst, trigger = "kickoff") {
   if (cli.sid && r.stdout) { const m = r.stdout.match(cli.sid); if (m) sid = m[1]; }
   telemetry({ ts: Date.now(), agent: AGENT, project: PROJ, turn: TURN, trigger, model: MODEL || "default", duration_ms: Date.now() - t0, exit: r.status });
   log(`turn ended (exit ${r.status}, ${((Date.now() - t0) / 1000).toFixed(0)}s)`);
+  if (r.status === 0) cmuxStatus("idle", "#8a94a6", "robot");   // finished this turn, waiting for the next
   return r.status;
 }