trantor 0.17.46 → 0.17.48

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.46"
+    "version": "0.17.48"
   },
   "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.46",
+      "version": "0.17.48",
       "author": {
         "name": "Sasha Bogojevic"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.46",
+  "version": "0.17.48",
   "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

@@ -134,7 +134,7 @@ 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 opencode:zai-coding-plan` spawns one titled
+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
@@ -236,7 +236,7 @@ trantor setup | doctor | connect | profile | up <agents…> | swap <old> <new> |
 
 `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
-(`opencode:zai-coding-plan --difficulty hard`); spawns are verified on the bus with one retry;
+(`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.

package/bin/advise.mjs

@@ -19,52 +19,73 @@ import { pathToFileURL } from "node:url";
 const H = homedir();
 const read = (p, fb) => { try { return JSON.parse(readFileSync(p, "utf8")); } catch { return fb; } };
 
-// ---- canonical crew roster (single source of truth, mirrors bin/doctor.mjs) ----
-// Each token maps to: the CLI binary that must exist · the `trantor up` LAUNCH spec the
-// orchestrator runs · the bus SESSION name (= spec's agent part) · the profile PROVIDER
-// key that gates the seat and supplies the tier.
+// ---- crew roster: BUILT-IN seats + ANY opencode provider the user has brought (BYOM) ----
+// Each seat: the CLI binary that must exist (`cli`) · the `trantor up` LAUNCH spec · the bus
+// SESSION label (its identity on the board) · the profile PROVIDER key (tier/cost) · for
+// opencode-driven seats, the opencode PROVIDER id (`providerOc`) used to enumerate models + auth.
 //
-// GEMINI is deliberately ABSENT: Google retired the free Gemini CLI seat (2026-06-18), so
-// even though the `gemini` binary is usually still on PATH, `gemini --yolo` crashes (exit 1)
-// for everyone without a paid enterprise key. Its replacement seat is GLM via opencode.
-// (Gemini still works as a Scrooge cheap-model via GEMINI_API_KEY — a separate path.) A
-// paid-key holder can still force it with an explicit `trantor up gemini`; we just never
-// auto-recommend a dead seat.
-export const ROSTER = {
-  codex:    { cli: "codex",    launch: "codex",                  session: "codex",    provider: "codex" },
-  kimi:     { cli: "kimi",     launch: "kimi",                   session: "kimi",     provider: "kimi" },
-  deepseek: { cli: "opencode", launch: "deepseek:deepseek",      session: "deepseek", provider: "deepseek" },
-  glm:      { cli: "opencode", launch: "opencode:zai-coding-plan", session: "opencode", provider: "zai" },
-  // OpenRouter = the BYOM on-ramp: one key fronts hundreds of models (incl. vendors with no
-  // CLI of their own). Rides the opencode runner like glm/deepseek, but under its OWN bus label
-  // `openrouter` (distinct session, never collides with the glm `opencode` seat). The launcher
-  // live-selects the best OpenRouter model for the work's difficulty (or pin one:
-  // `openrouter:openrouter/<vendor>/<model>`). The model picked is what determines its strength,
-  // so it sits LAST in every CREW_PREF tier — a wildcard that fills once the proven native seats
-  // are taken, and the ONLY seat for a user who brought nothing but an OpenRouter key.
-  openrouter: { cli: "opencode", launch: "openrouter:openrouter", session: "openrouter", provider: "openrouter" },
+// GEMINI is deliberately absent: Google retired the free CLI seat (2026-06-18) → `gemini --yolo`
+// crashes exit 1. Its replacement is GLM via opencode.
+//
+// The opencode-driven seats are the BYOM substrate: opencode is a UNIVERSAL adapter, so any
+// provider the user configures in opencode (or declares in their profile) becomes a crew seat
+// with ZERO code change here — `buildRoster()` discovers them at runtime. The built-ins below are
+// just the curated defaults + the two opencode seats with non-obvious mappings (glm: profile key
+// `zai` ↔ opencode provider `zai-coding-plan`).
+export const BUILTIN_ROSTER = {
+  codex:      { cli: "codex",    launch: "codex",                   session: "codex",      provider: "codex" },
+  kimi:       { cli: "kimi",     launch: "kimi",                    session: "kimi",       provider: "kimi" },
+  deepseek:   { cli: "opencode", launch: "deepseek:deepseek",       session: "deepseek",   provider: "deepseek",   providerOc: "deepseek" },
+  glm:        { cli: "opencode", launch: "glm:zai-coding-plan",      session: "glm",        provider: "zai",        providerOc: "zai-coding-plan" },
+  openrouter: { cli: "opencode", launch: "openrouter:openrouter",   session: "openrouter", provider: "openrouter", providerOc: "openrouter" },
 };
+// opencode provider ids already claimed by a built-in (so discovery never duplicates them) + the
+// names that are native CLIs / built-in profile aliases (never opencode-driven seats).
+const BUILTIN_OC = new Set(Object.values(BUILTIN_ROSTER).filter(s => s.providerOc).map(s => s.providerOc));
+const NEVER_DISCOVER = new Set(["claude", "codex", "kimi", "gemini", "zai", "opencode"]);
+
+// Discover opencode providers the user has configured — from opencode.json `provider` keys AND
+// from profile providers declared via `trantor provider add` — that aren't already built-in. Each
+// becomes an opencode-driven seat under its OWN bus label (distinct session, no collisions). THIS
+// is what lets a brought provider (Inception, a Japanese model, any opencode vendor) light up a
+// seat with no code edit. T2's capability ingestion then makes it route well by difficulty.
+export function discoverSeats(profile, ocConfig) {
+  const out = {};
+  const provKeys = new Set([...Object.keys(ocConfig?.provider || {}), ...Object.keys(profile?.providers || {})]);
+  for (const p of provKeys) {
+    if (BUILTIN_OC.has(p) || NEVER_DISCOVER.has(p)) continue;
+    const label = String(p).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+    out[label] = { cli: "opencode", launch: `${label}:${p}`, session: label, provider: p, providerOc: p, discovered: true };
+  }
+  return out;
+}
+
+export function buildRoster(profile, ocConfig) {
+  return { ...BUILTIN_ROSTER, ...discoverSeats(profile, ocConfig) };
+}
 
 export function loadWorld() {
   const profile = read(join(H, ".agent-bus", "profile.json"), { providers: {} });
   const registry = read(join(H, ".token-scrooge", "registry.json"), { models: {}, tasks: {} });
   const caps = read(join(H, ".token-scrooge", "capabilities.json"), {});
+  const ocConfig = read(join(H, ".config", "opencode", "opencode.json"), {});
+  const roster = buildRoster(profile, ocConfig);
   const has = (c) => { try { execSync(`command -v ${c}`, { stdio: "ignore", shell: "/bin/sh" }); return true; } catch { return false; } };
-  const opencodeKey = (prov) => !!read(join(H, ".config", "opencode", "opencode.json"), {})?.provider?.[prov]?.options?.apiKey;
+  const opencodeKey = (prov) => !!ocConfig?.provider?.[prov]?.options?.apiKey;
   // a key the user already has for Scrooge counts too — the opencode runner sources these .env
-  // files, so OPENROUTER_API_KEY in ~/.token-scrooge/.env lights up the crew seat with no extra setup.
+  // files, so e.g. OPENROUTER_API_KEY in ~/.token-scrooge/.env lights up the seat with no extra setup.
   const envHasKey = (k) => !!process.env[k] || [join(H, ".token-scrooge", ".env"), join(H, ".agent-bus", ".env")]
     .some(f => { try { return readFileSync(f, "utf8").includes(k); } catch { return false; } });
-  // a seat is available only if its CLI exists AND its provider is actually set up — a present
-  // binary with a dead/missing seat (gemini, or opencode with no provider key) must NOT be recommended.
+  // a seat is available only if its CLI exists AND (for opencode-driven seats) the provider is
+  // actually set up — a present binary with a dead/missing seat must NOT be recommended.
   const hasSeat = (tok) => {
-    const r = ROSTER[tok]; if (!r || !has(r.cli)) return false;
-    if (tok === "glm") return !!profile?.providers?.zai || opencodeKey("zai-coding-plan");
-    if (tok === "openrouter") return !!profile?.providers?.openrouter || opencodeKey("openrouter") || envHasKey("OPENROUTER_API_KEY");
-    return true;
+    const s = roster[tok]; if (!s || !has(s.cli)) return false;
+    if (s.cli !== "opencode") return true;                       // native CLI present = ready
+    const envKey = `${String(s.providerOc).toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
+    return opencodeKey(s.providerOc) || envHasKey(envKey) || !!profile?.providers?.[s.provider];
   };
-  const agents = Object.keys(ROSTER).filter(hasSeat);
-  return { profile, registry, caps, agents, scrooge: has("scrooge") };
+  const agents = Object.keys(roster).filter(hasSeat);
+  return { profile, registry, caps, roster, agents, scrooge: has("scrooge") };
 }
 
 const tierOf = (profile, prov) => profile?.providers?.[prov]?.tier || "api";
@@ -86,7 +107,11 @@ const FORECAST = { easy: 0.3e6, medium: 1.5e6, hard: 6e6 };  // tokens
 const CREW_PREF = { hard: ["codex", "glm", "kimi", "deepseek", "openrouter"], medium: ["kimi", "glm", "codex", "deepseek", "openrouter"], easy: ["deepseek", "kimi", "glm", "codex", "openrouter"] };
 
 export function advise(input, world = loadWorld()) {
-  const { profile, registry, caps, agents, scrooge } = world;
+  const { profile, registry, caps, agents, scrooge, roster = BUILTIN_ROSTER } = world;
+  // brought (discovered) opencode providers extend the preference list — appended LAST in every
+  // tier (unknown strength a priori, like openrouter), so they fill once the curated seats are
+  // taken, and are the only option for a user who brought nothing but a custom provider.
+  const broughtPref = Object.keys(roster).filter(t => roster[t].discovered && !CREW_PREF.hard.includes(t));
   const pkgs = (input.packages || []).map(p => ({ title: p.title || "work", difficulty: ["easy", "medium", "hard"].includes(p.difficulty) ? p.difficulty : "medium", kind: p.kind || "code", owner: p.owner === "self" ? "self" : (/(foundation|integration|scaffold)/i.test(p.title) ? "self" : "") }));
   const horizon = input.horizon || (pkgs.length >= 4 ? "long" : pkgs.length >= 2 ? "medium" : "short");
   const orchTier = tierOf(profile, "claude");
@@ -121,10 +146,10 @@ export function advise(input, world = loadWorld()) {
     }
     if (p.owner === "self") return { ...p, executor: "orchestrator", pool: tierOf(profile, "claude"), reason: "architect-owned (foundation/integration doctrine) — the orchestrator keeps the shared contract in its own hands" };
     if (mode === "solo") return { ...p, executor: "orchestrator", pool: tierOf(profile, "claude"), reason: "small enough to do inline" };
-    const pref = CREW_PREF[p.difficulty].filter(a => agents.includes(a));
+    const pref = [...CREW_PREF[p.difficulty], ...broughtPref].filter(a => agents.includes(a));
     const agent = pref.sort((a, b) => (used[a] || 0) - (used[b] || 0))[0] || agents[0] || "deepseek";
     used[agent] = (used[agent] || 0) + 1;
-    const pool = tierOf(profile, ROSTER[agent]?.provider || agent);
+    const pool = tierOf(profile, roster[agent]?.provider || agent);
     let est = null;
     if (pool === "api") { // deepseek API etc — estimate real $ via registry
       const m = registry.models?.["deepseek-v4-flash"] || { cost_in: 0.14, cost_out: 0.28 };
@@ -165,15 +190,15 @@ export function advise(input, world = loadWorld()) {
   const selfPkgs = routing.filter(r => r.executor === "orchestrator");
   const foundationIdx = selfPkgs.length ? [1] : [];
   const cards = routing.map((r, i) => {
-    const seat = ROSTER[r.executor];
+    const seat = roster[r.executor];
     return {
     order: i + 1, title: r.title, difficulty: r.difficulty,
-    // bus identity = the runner's session name (spec's agent part) — glm rides the `opencode`
-    // runner so its session/assignee is `opencode:<project>`, NOT `glm:<project>`.
+    // bus identity = the seat's session label (every opencode-driven seat has its OWN label, so
+    // glm is `glm:<project>`, openrouter `openrouter:<project>`, a brought provider `<name>:<project>`).
     assignee: r.executor === "scrooge" || r.executor === "orchestrator" ? undefined : `${seat?.session || r.executor}:<project>`,
     // launch = the EXACT `trantor up` spec to spawn this seat; the orchestrator runs
     // `trantor up <launch> --task <task> --difficulty <difficulty>`. Carrying it explicitly is
-    // what teaches the orchestrator the GLM path (`opencode:zai-coding-plan`) instead of guessing.
+    // what teaches the orchestrator the GLM path (`glm:zai-coding-plan`) instead of guessing.
     launch: ["scrooge", "orchestrator"].includes(r.executor) ? undefined : (seat?.launch || r.executor),
     // "auto" = resolve a LIVE model at spawn (the launch spec already pins the provider; the
     // runner picks the best live model for it). Was `<cli>-default` — a stale default.

package/bin/cli.mjs

@@ -18,6 +18,8 @@ switch (cmd) {
   case "doctor":  run("bin/doctor.mjs"); break;
   case "connect": run("bin/connect.mjs"); break;
   case "profile": run("bin/profile.mjs"); break;
+  case "provider": case "providers": run("bin/provider.mjs"); break;
+  case "models": run("bin/models.mjs"); break;
   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;
@@ -49,7 +51,9 @@ switch (cmd) {
   trantor doctor      where do I stand? hub/plugin/CLIs/auth/keys/profile, with copy-paste fixes
   trantor connect     (re)wire every installed AI CLI to the bus
   trantor profile     declare your plans:  trantor profile set claude=max codex=plus deepseek=api
-  trantor up …        spawn a crew here:   trantor up codex kimi deepseek:deepseek opencode:zai-coding-plan
+  trantor provider    bring ANY model (BYOM): list seats · add <name> --key … · remove <name>
+  trantor models      browse live models behind each seat + the router's pick per difficulty
+  trantor up …        spawn a crew here:   trantor up codex kimi deepseek:deepseek glm:zai-coding-plan
   trantor down        tear the crew down (kills processes, closes windows, no dialogs)
   trantor ui          open the live dashboard (board + flow views)
   trantor catchup     "where are we?" — the continuous board + git, with a synthesized brief

package/bin/crew-runner.mjs

@@ -78,8 +78,14 @@ const CLI = {
   claude:   { first: `claude{M} -p "$(cat {P})" --dangerously-skip-permissions`,
               next:  `claude -c{M} -p "$(cat {P})" --dangerously-skip-permissions`, mflag: " --model " },
 };
-const cli = CLI[AGENT];
-if (!cli) { console.error(`unknown agent '${AGENT}' (known: ${Object.keys(CLI).join(", ")})`); process.exit(1); }
+// BYOM: any agent label that isn't a known native CLI is treated as an opencode-driven provider
+// seat (opencode is the universal adapter). This is what lets a BROUGHT provider — `trantor up
+// <label>:<provider>` for any opencode vendor the user configured — run with no per-provider code
+// here; its model id arrives pre-qualified (`<provider>/<model>`) as CREW_MODEL.
+const NATIVE = new Set(["codex", "gemini", "kimi", "claude"]);
+const cli = CLI[AGENT] || (NATIVE.has(AGENT) ? null : CLI.opencode);
+if (!cli) { console.error(`unknown agent '${AGENT}' (native: ${[...NATIVE].join(", ")}; any other name = an opencode provider seat)`); process.exit(1); }
+if (!CLI[AGENT]) log(`'${AGENT}' is not a built-in seat — running it as an opencode provider (BYOM)`);
 
 const RULES = `Rules: you are ${SESSION} on the trantor crew. Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go (doing -> testing -> done; run the tests in 'testing', use 'failed' + a report if they break). When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message.`;
 

package/bin/crew.sh

@@ -52,8 +52,9 @@ down() {
 case "$CMD" in up|swap) ;; *) echo "usage: crew.sh up <agent...> | crew.sh swap <oldAgent> <newAgent[:provider[/model]]> | crew.sh down"; exit 1 ;; esac
 
 # --task/--difficulty drive LAZY live-model selection for provider-only specs (agent:provider).
-# An agent spec is one of: `codex` (CLI default) · `opencode:zai-coding-plan` (provider only →
-# pick the best live model now) · `opencode:zai-coding-plan/glm-5.2` (full pin, used as-is).
+# An agent spec is one of: `codex` (CLI default) · `glm:zai-coding-plan` (provider only → pick the
+# best live model now) · `glm:zai-coding-plan/glm-5.2` (full pin). The agent label is the bus
+# identity; any non-native label runs via opencode (legacy `opencode:zai-coding-plan` still works).
 TASK="code"; DIFF="medium"; _ARGS=()
 while [ $# -gt 0 ]; do
   case "$1" in
@@ -70,18 +71,18 @@ SCROOGE="$BUS_DIR/engine/bin/scrooge"
 [ -f "$SCROOGE" ] || SCROOGE="$(command -v scrooge 2>/dev/null || echo scrooge)"
 
 # resolve_model <agent> <provider> <task> <diff> -> echoes a runner-ready model id, or empty
-# (→ CLI default). Enumeration is CLI-aware and never guesses an endpoint: opencode-managed
-# agents list via `opencode models <provider>`; others self-enumerate via the provider's /models.
+# (→ CLI default). PROVIDER-AGNOSTIC: if opencode knows the provider (ANY of its vendors — built-in
+# or BROUGHT), enumerate via `opencode models <provider>`; else self-enumerate via the provider's
+# OpenAI-compatible /models. No hardcoded provider list — a newly-brought opencode provider routes
+# with zero change here. Never guesses an endpoint.
 resolve_model() {
   local agent="$1" provider="$2" task="$3" diff="$4" cands="" out=""
-  case "$agent" in
-    opencode|deepseek|openrouter)
-      cands="$(opencode models "$provider" 2>/dev/null | tr '\n' ' ')"
-      [ -n "$cands" ] || { echo "[crew] no live models via 'opencode models $provider' — CLI default" >&2; return 0; }
-      out="$(python3 "$SCROOGE" route --candidates "$cands" -t "$task" -d "$diff" --json 2>/dev/null)" ;;
-    *)
-      out="$(python3 "$SCROOGE" route --provider "$provider" -t "$task" -d "$diff" --json 2>/dev/null)" ;;
-  esac
+  cands="$(opencode models "$provider" 2>/dev/null | tr '\n' ' ')"
+  if [ -n "$cands" ]; then
+    out="$(python3 "$SCROOGE" route --candidates "$cands" -t "$task" -d "$diff" --json 2>/dev/null)"
+  else
+    out="$(python3 "$SCROOGE" route --provider "$provider" -t "$task" -d "$diff" --json 2>/dev/null)"
+  fi
   [ -n "$out" ] || { echo "[crew] live model selection failed for $agent:$provider — CLI default" >&2; return 0; }
   printf '%s' "$out" | python3 -c 'import json,sys
 try: print(json.load(sys.stdin).get("qualified") or "")

package/bin/doctor.mjs

@@ -60,7 +60,7 @@ const CLIS = [
   { name: "gemini (CLI retired 2026-06-18)", bin: "gemini",   wired: () => !!read(join(H, ".gemini", "settings.json"))?.mcpServers?.relay, auth: () => existsSync(join(H, ".gemini", "oauth_creds.json")) || !!process.env.GEMINI_API_KEY || !!process.env.GOOGLE_API_KEY, login: "Gemini CLI retired 2026-06-18 (free/Pro/Ultra). Crew seat → GLM (opencode) or Antigravity `agy`. Gemini still serves as a Scrooge cheap-model via GEMINI_API_KEY." },
   { name: "kimi",   bin: "kimi",     wired: () => !!read(join(H, ".kimi", "mcp.json"))?.mcpServers?.relay, auth: () => existsSync(join(H, ".kimi", "credentials")), login: "kimi → /login   (Kimi account or Moonshot API key)" },
   { name: "deepseek (via opencode)", bin: "opencode", wired: () => !!read(join(H, ".config", "opencode", "opencode.json"))?.mcp?.relay, auth: () => !!process.env.DEEPSEEK_API_KEY || (existsSync(join(H, ".agent-bus", ".env")) && readFileSync(join(H, ".agent-bus", ".env"), "utf8").includes("DEEPSEEK_API_KEY")) || !!read(join(H, ".local", "share", "opencode", "auth.json")), login: `get a key at platform.deepseek.com, then: echo 'DEEPSEEK_API_KEY=sk-…' >> ~/.agent-bus/.env` },
-  { name: "glm (via opencode · coding plan)", bin: "opencode", wired: () => !!read(join(H, ".config", "opencode", "opencode.json"))?.mcp?.relay, auth: () => !!read(join(H, ".config", "opencode", "opencode.json"))?.provider?.["zai-coding-plan"]?.options?.apiKey, login: `put your Z.ai coding-plan key at ~/.config/opencode/opencode.json → provider["zai-coding-plan"].options.apiKey, then seat: trantor up opencode:zai-coding-plan/glm-5.1` },
+  { name: "glm (via opencode · coding plan)", bin: "opencode", wired: () => !!read(join(H, ".config", "opencode", "opencode.json"))?.mcp?.relay, auth: () => !!read(join(H, ".config", "opencode", "opencode.json"))?.provider?.["zai-coding-plan"]?.options?.apiKey, login: `put your Z.ai coding-plan key at ~/.config/opencode/opencode.json → provider["zai-coding-plan"].options.apiKey, then seat: trantor up glm:zai-coding-plan/glm-5.1` },
   // OpenRouter — the BYOM on-ramp: ONE key fronts hundreds of models. Rides opencode; the same
   // OPENROUTER_API_KEY Scrooge already uses authenticates the crew seat (the runner sources the
   // .env files). Available the moment the key exists in env/opencode + declared `openrouter=api`.

package/bin/models.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// trantor models — browse the live models behind your crew seats (opencode is the adapter).
+//
+//   trantor models                # every opencode-driven seat + how many live models it serves
+//   trantor models <provider>     # list that provider's live models + what the router picks per
+//                                 # difficulty (so you can see hard→strong, easy→cheap at a glance)
+import { execSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { buildRoster, loadWorld } from "./advise.mjs";
+
+const H = homedir();
+const C = { dim: "\x1b[2m", grn: "\x1b[32m", gold: "\x1b[38;5;208m", off: "\x1b[0m" };
+const has = (c) => { try { execSync(`command -v ${c}`, { stdio: "ignore", shell: "/bin/sh" }); return true; } catch { return false; } };
+const SCROOGE = (() => {
+  const bundled = join(dirname(dirname(fileURLToPath(import.meta.url))), "engine", "bin", "scrooge");
+  if (existsSync(bundled)) return bundled;
+  try { return execSync("command -v scrooge", { encoding: "utf8" }).trim(); } catch { return "scrooge"; }
+})();
+
+const liveModels = (providerOc) => {
+  try { return execSync(`opencode models ${providerOc} 2>/dev/null`, { encoding: "utf8" }).split("\n").filter(Boolean); }
+  catch { return []; }
+};
+
+function routePick(candList, diff) {
+  try {
+    const out = execSync(`python3 ${SCROOGE} route --candidates ${JSON.stringify(candList.join(" "))} -t code -d ${diff} --json 2>/dev/null`, { encoding: "utf8" });
+    return JSON.parse(out).qualified || "?";
+  } catch { return "?"; }
+}
+
+function listAll() {
+  const { roster, agents } = loadWorld();
+  if (!has("opencode")) { console.log("opencode not on PATH — it's the adapter that serves crew models. Install it, then re-run."); return; }
+  console.log("CREW MODELS — opencode-driven seats (● available now)\n");
+  for (const [label, s] of Object.entries(roster)) {
+    if (s.cli !== "opencode") continue;
+    const n = liveModels(s.providerOc).length;
+    const dot = agents.includes(label) ? `${C.grn}●${C.off}` : `${C.dim}○${C.off}`;
+    console.log(`  ${dot} ${label.padEnd(14)} ${C.dim}${s.providerOc}${C.off}  ${n} live models   ${C.dim}trantor models ${label}${C.off}`);
+  }
+  console.log(`\n${C.dim}detail + routing preview:${C.off} trantor models <provider>`);
+}
+
+function detail(name) {
+  const { roster } = loadWorld();
+  const seat = roster[name] || Object.values(roster).find(s => s.providerOc === name);
+  const providerOc = seat?.providerOc || name;
+  const models = liveModels(providerOc);
+  if (!models.length) { console.log(`No live models for '${providerOc}' (opencode offline / no key / unknown provider).`); return; }
+  console.log(`${C.gold}${providerOc}${C.off} — ${models.length} live models\n`);
+  for (const m of models.slice(0, 60)) console.log(`  ${m}`);
+  if (models.length > 60) console.log(`  ${C.dim}… +${models.length - 60} more${C.off}`);
+  if (existsSync(SCROOGE) || has("scrooge")) {
+    console.log(`\n${C.gold}router picks (code task):${C.off}`);
+    for (const d of ["easy", "medium", "hard"]) console.log(`  ${d.padEnd(7)} → ${routePick(models, d)}`);
+    console.log(`${C.dim}(run scrooge-capabilities to (re)score the catalog for accurate difficulty routing)${C.off}`);
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const arg = process.argv[2];
+  if (!arg) listAll(); else detail(arg.toLowerCase());
+}

package/bin/provider.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+// trantor provider — bring ANY model to the crew (BYOM). opencode is a universal adapter, so a
+// provider you configure there (or declare here) becomes a crew seat with no code change.
+//
+//   trantor provider                 # list seats: built-in + discovered, with availability + tier
+//   trantor provider add <name> [--key sk-…] [--plan api|coding-plan|max] [--label <bus-name>]
+//                       [--base-url <url> [--models m1,m2]]   # wire a CUSTOM OpenAI-compatible endpoint
+//   trantor provider remove <name>   # drop it from your profile (leaves the key in place)
+//
+// `add` writes <NAME>_API_KEY to ~/.agent-bus/.env (if --key given), declares the plan in your
+// quota profile, verifies opencode can see the provider's models, and prints the seat spec. For a
+// provider opencode already knows (openrouter, groq, …) the key is enough; for a CUSTOM endpoint,
+// pass --base-url and it writes the opencode.json provider block for you. The Advisor then routes
+// to it automatically; run `scrooge-capabilities` so it routes well by difficulty.
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, appendFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+import { pathToFileURL } from "node:url";
+import { buildRoster, loadWorld } from "./advise.mjs";
+
+const H = homedir();
+const ENV = join(H, ".agent-bus", ".env");
+const read = (p, fb) => { try { return JSON.parse(readFileSync(p, "utf8")); } catch { return fb; } };
+const has = (c) => { try { execSync(`command -v ${c}`, { stdio: "ignore", shell: "/bin/sh" }); return true; } catch { return false; } };
+const C = { dim: "\x1b[2m", grn: "\x1b[32m", red: "\x1b[31m", yel: "\x1b[33m", gold: "\x1b[38;5;208m", off: "\x1b[0m" };
+const envKeyName = (p) => `${String(p).toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
+
+const OC_CONFIG = join(H, ".config", "opencode", "opencode.json");
+// Wire a CUSTOM OpenAI-compatible provider into opencode.json (matching opencode's schema +
+// the existing providers' `options.apiKey` style). Merges, never clobbers other providers.
+// `configPath` is injectable so it can be unit-tested against a temp file.
+export function wireOpencodeProvider(name, baseUrl, models, configPath = OC_CONFIG) {
+  const cfg = existsSync(configPath) ? read(configPath, {}) : {};
+  cfg.$schema ||= "https://opencode.ai/config.json";
+  cfg.provider ||= {};
+  const block = {
+    npm: "@ai-sdk/openai-compatible",
+    name: name.charAt(0).toUpperCase() + name.slice(1),
+    options: { baseURL: baseUrl, apiKey: `{env:${envKeyName(name)}}` },
+  };
+  if (models && models.length) block.models = Object.fromEntries(models.map(m => [m, {}]));
+  cfg.provider[name] = { ...cfg.provider[name], ...block };
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(cfg, null, 2) + "\n");
+  return configPath;
+}
+
+function opencodeModelCount(providerOc) {
+  if (!has("opencode")) return null;
+  try { return execSync(`opencode models ${providerOc} 2>/dev/null`, { encoding: "utf8" }).split("\n").filter(Boolean).length; }
+  catch { return 0; }
+}
+
+function listSeats() {
+  const world = loadWorld();
+  const { roster, agents, profile } = world;
+  console.log("CREW SEATS — built-in + brought (BYOM). ● = available now\n");
+  for (const [label, s] of Object.entries(roster)) {
+    const live = agents.includes(label);
+    const tier = profile?.providers?.[s.provider]?.tier || (s.cli === "opencode" ? "—" : "");
+    const kind = s.discovered ? "brought " : "built-in";
+    const models = s.cli === "opencode" ? opencodeModelCount(s.providerOc) : null;
+    const mtxt = models == null ? "" : `${models} models`;
+    const dot = live ? `${C.grn}●${C.off}` : `${C.dim}○${C.off}`;
+    console.log(`  ${dot} ${label.padEnd(14)} ${C.dim}${kind}${C.off}  launch: ${s.launch.padEnd(26)} ${tier ? `tier=${tier}` : ""} ${C.dim}${mtxt}${C.off}`);
+  }
+  console.log(`\n${C.dim}add one:${C.off} trantor provider add <name> --key sk-… --plan api`);
+  console.log(`${C.dim}browse models:${C.off} trantor models [<provider>]`);
+}
+
+function addProvider(name, opts) {
+  if (!name) { console.error("usage: trantor provider add <name> [--key sk-…] [--plan api] [--label <bus-name>] [--base-url <url> [--models m1,m2]]"); process.exit(1); }
+  const provider = name.toLowerCase();
+  const label = (opts.label || provider).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const plan = (opts.plan || "api").toLowerCase();
+
+  // 1) key → ~/.agent-bus/.env (the runner sources it; opencode reads <NAME>_API_KEY for known providers)
+  if (opts.key) {
+    mkdirSync(dirname(ENV), { recursive: true });
+    const k = envKeyName(provider);
+    let cur = existsSync(ENV) ? readFileSync(ENV, "utf8") : "";
+    if (new RegExp(`^${k}=`, "m").test(cur)) {
+      cur = cur.replace(new RegExp(`^${k}=.*$`, "m"), `${k}=${opts.key}`);
+      writeFileSync(ENV, cur);
+    } else {
+      appendFileSync(ENV, `${cur && !cur.endsWith("\n") ? "\n" : ""}# ${provider} — brought via 'trantor provider add'\n${k}=${opts.key}\n`);
+    }
+    try { chmodSync(ENV, 0o600); } catch {}
+    console.log(`${C.grn}✓${C.off} wrote ${envKeyName(provider)} → ~/.agent-bus/.env (chmod 600)`);
+  }
+
+  // 2) declare the plan in the quota profile (drives the Advisor's tier/cost reasoning)
+  try {
+    execSync(`node ${join(dirname(new URL(import.meta.url).pathname), "profile.mjs")} set ${provider}=${plan}`, { stdio: "ignore" });
+    console.log(`${C.grn}✓${C.off} profile: ${provider}=${plan}`);
+  } catch (e) { console.log(`${C.yel}⚠${C.off} could not set profile (run: trantor profile set ${provider}=${plan})`); }
+
+  // 3) custom endpoint → write the opencode.json provider block (known providers skip this)
+  if (opts.baseUrl) {
+    const models = (opts.models || "").split(",").map(s => s.trim()).filter(Boolean);
+    const where = wireOpencodeProvider(provider, opts.baseUrl, models);
+    console.log(`${C.grn}✓${C.off} wired custom provider '${provider}' → ${where.replace(H, "~")} (baseURL ${opts.baseUrl}${models.length ? `, ${models.length} models` : ""})`);
+  }
+
+  // 4) verify opencode can see the provider's models
+  const n = opencodeModelCount(provider);
+  if (n == null) console.log(`${C.yel}⚠${C.off} opencode not on PATH — install it to run this seat (it's the universal adapter)`);
+  else if (n === 0) console.log(`${C.yel}⚠${C.off} opencode lists 0 models for '${provider}'.${opts.baseUrl ? " Check the baseURL/key, or pass --models m1,m2 to declare them." : " If it's a known provider, the key above is enough; for a CUSTOM endpoint re-run with --base-url <url> [--models m1,m2]."} Re-check: trantor models ${provider}`);
+  else console.log(`${C.grn}✓${C.off} opencode sees ${n} models for '${provider}'`);
+
+  // 5) score it for difficulty-aware routing + show the seat
+  console.log(`\n${C.gold}Seat ready.${C.off} Launch it:`);
+  console.log(`  trantor up ${label === provider ? label : `${label}:${provider}`}            ${C.dim}# live-selects the best model for the work${C.off}`);
+  console.log(`  trantor up ${label}:${provider}/<model>     ${C.dim}# pin a specific model${C.off}`);
+  console.log(`${C.dim}For difficulty-aware routing across its catalog, score it once (weekly):${C.off} scrooge-capabilities`);
+}
+
+function removeProvider(name) {
+  if (!name) { console.error("usage: trantor provider remove <name>"); process.exit(1); }
+  const FILE = join(H, ".agent-bus", "profile.json");
+  const prof = read(FILE, { providers: {} });
+  if (prof.providers && prof.providers[name.toLowerCase()]) {
+    delete prof.providers[name.toLowerCase()];
+    writeFileSync(FILE, JSON.stringify(prof, null, 2) + "\n");
+    console.log(`${C.grn}✓${C.off} removed '${name}' from your profile (the ${envKeyName(name)} key is left in place; delete it from ~/.agent-bus/.env if you want it gone)`);
+  } else {
+    console.log(`'${name}' is not in your profile.`);
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const [, , sub, ...rest] = process.argv;
+  const opts = {}; const pos = [];
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] === "--key") opts.key = rest[++i];
+    else if (rest[i] === "--plan") opts.plan = rest[++i];
+    else if (rest[i] === "--label") opts.label = rest[++i];
+    else if (rest[i] === "--base-url" || rest[i] === "--baseurl") opts.baseUrl = rest[++i];
+    else if (rest[i] === "--models") opts.models = rest[++i];
+    else pos.push(rest[i]);
+  }
+  if (!sub || sub === "list") listSeats();
+  else if (sub === "add") addProvider(pos[0], opts);
+  else if (sub === "remove" || sub === "rm") removeProvider(pos[0]);
+  else { console.error(`unknown subcommand '${sub}' — use: list | add | remove`); process.exit(1); }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.46",
+  "version": "0.17.48",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"

package/skills/crew/SKILL.md

@@ -49,20 +49,24 @@ EXACT launch spec per provider (do not improvise these):
 | Codex | `codex` (or `codex:gpt-5.5` to pin) | OpenAI CLI |
 | Kimi | `kimi` | Moonshot coding-plan |
 | DeepSeek | `deepseek:deepseek` | runs via opencode; `deepseek` alone = CLI default |
-| **GLM (Z.ai)** | **`opencode:zai-coding-plan`** | **runs via opencode, NOT a bare `glm`/`zai` terminal command.** `opencode:zai-coding-plan/glm-5.2` pins a model; `opencode:zai-coding-plan` live-selects. |
+| **GLM (Z.ai)** | **`glm:zai-coding-plan`** | **runs via opencode, NOT a bare `glm`/`zai` terminal command.** `glm:zai-coding-plan/glm-5.2` pins a model; `glm:zai-coding-plan` live-selects. (Legacy `opencode:zai-coding-plan` still works.) |
 | **OpenRouter (BYOM)** | **`openrouter`** | **the bring-your-own-model on-ramp — one key fronts hundreds of vendors (incl. ones with no CLI).** Bare `openrouter` live-selects the best OpenRouter model for the difficulty; pin one with `openrouter:openrouter/<vendor>/<model>`. Its own bus identity `openrouter:<project>` (never collides with the GLM `opencode` seat). |
 
 `agent:provider` live-selects the best model now; `agent:provider/model` pins one. Example:
-`trantor up codex kimi deepseek:deepseek opencode:zai-coding-plan --task code --difficulty hard`.
-**Whatever the advisor's `launch` field says, run that verbatim** — the roster above is the menu,
-but the advisor already picked the right seats and specs for THIS work (a user who's only brought
-an OpenRouter key, for instance, gets `openrouter` for everything; one who brought five providers
-gets a load-balanced spread). New providers a user brings (OpenRouter today; any opencode-supported
-vendor next) appear automatically once declared via `trantor profile set <name>=api` + a key.
+`trantor up codex kimi deepseek:deepseek glm:zai-coding-plan --task code --difficulty hard`.
+**Whatever the advisor's `launch` field says, run that verbatim** — the roster above is just the
+built-in menu, but the advisor picks the right seats/specs for THIS work (a user who's only brought
+an OpenRouter key gets `openrouter` for everything; one who brought five providers gets a
+load-balanced spread). **BYOM is fully general:** the roster is DERIVED, not hardcoded — ANY
+opencode-supported provider the user configures becomes a seat with its own bus label, no code
+change. A user adds one with `trantor provider add <name> --key … --plan api` (then
+`scrooge-capabilities` to score it for difficulty routing); `trantor provider` lists all seats and
+`trantor models [<provider>]` browses the live models + the router's pick per difficulty. If the
+advisor routes to a brought provider you don't recognize, that's expected — run its `launch` spec.
 
 ⚠️ **Gemini CLI is RETIRED (Google killed the free seat 2026-06-18).** The advisor no longer
 offers it and you must NOT fire up `gemini` — `gemini --yolo` exits 1 and crash-loops on the
-bus. Its replacement seat is **GLM via `opencode:zai-coding-plan`**. (Gemini still serves as a
+bus. Its replacement seat is **GLM via `glm:zai-coding-plan`**. (Gemini still serves as a
 Scrooge cheap-model via `GEMINI_API_KEY` — that's a separate, working path, not a crew seat.)
 Only a holder of a paid Gemini enterprise key should ever `trantor up gemini`.