trantor 0.17.47 → 0.17.49

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.47",
+  "version": "0.17.49",
   "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>
 
@@ -65,9 +65,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 +135,14 @@ 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
-   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 one titled
+   terminal window per agent. 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
@@ -202,6 +205,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 +267,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
-(`opencode: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 +334,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/advise.mjs

@@ -36,7 +36,7 @@ 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: "opencode:zai-coding-plan", session: "opencode",  provider: "zai",        providerOc: "zai-coding-plan" },
+  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
@@ -193,12 +193,12 @@ export function advise(input, world = loadWorld()) {
     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

@@ -53,7 +53,7 @@ switch (cmd) {
   trantor profile     declare your plans:  trantor profile set claude=max codex=plus deepseek=api
   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 opencode:zai-coding-plan
+  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.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

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/provider.mjs

@@ -4,11 +4,14 @@
 //
 //   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. The
-// Advisor then routes to it automatically; run `scrooge-capabilities` so it routes well by difficulty.
+// 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";
@@ -23,6 +26,26 @@ const has = (c) => { try { execSync(`command -v ${c}`, { stdio: "ignore", shell:
 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; }
@@ -47,7 +70,7 @@ function listSeats() {
 }
 
 function addProvider(name, opts) {
-  if (!name) { console.error("usage: trantor provider add <name> [--key sk-…] [--plan api] [--label <bus-name>]"); process.exit(1); }
+  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();
@@ -73,13 +96,20 @@ function addProvider(name, opts) {
     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) verify opencode can see the provider's models
+  // 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}'. If it's a known provider, the key above is enough; for a custom endpoint, add it to ~/.config/opencode/opencode.json (provider config). Then re-check: trantor models ${provider}`);
+  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}'`);
 
-  // 4) score it for difficulty-aware routing + show the seat
+  // 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}`);
@@ -106,6 +136,8 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
     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();

package/hooks/agent-notify.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+// trantor Notification hook — surface CC's OWN background/child agents (the `claude agents` / fork / subtask
+// sessions that DON'T go through the Task-tool sub-agent path, so SubagentStart/Stop never see them) on the
+// board. CC fires a Notification with notification_type "agent_needs_input" (the agent paused, waiting on the
+// user) or "agent_completed" (it finished). We card these as source:"cc-bg-agent" — a DISTINCT population
+// from cc-subagent, so they never double-count against sub-agent notional cost.
+//
+//   • agent_needs_input → post/flip a card to "blocked" (needs input) so the board shows it's waiting.
+//   • agent_completed   → flip/close the card to "done".
+//
+// UNVERIFIED-LIVE: the Notification stdin payload's exact field names for the agent id are not documented
+// (session_id + notification_type + message are the confirmed fields). We read several candidates and let the
+// hub key/guard on whatever we send; TRANTOR_DEBUG_NOTIFY=1 dumps the raw payload to stderr so the first real
+// firing reveals the true shape. Fail-silent: a notification must never block the session.
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { resolveProject, hostId } from "../lib/project.mjs";
+
+function readStdin() {
+  return new Promise(res => { let d = ""; process.stdin.setEncoding("utf8");
+    process.stdin.on("data", c => (d += c)); process.stdin.on("end", () => res(d));
+    setTimeout(() => res(d), 100); });
+}
+function relayUrl() {
+  if (process.env.RELAY_URL) return process.env.RELAY_URL;
+  try { const c = join(homedir(), ".agent-bus", "config.json"); if (existsSync(c)) { const u = JSON.parse(readFileSync(c, "utf8")).url; if (u) return u; } } catch {}
+  return "http://127.0.0.1:4477";
+}
+
+try {
+  const input = JSON.parse((await readStdin()) || "{}");
+  if (process.env.TRANTOR_DEBUG_NOTIFY === "1") process.stderr.write(`[trantor] notify payload: ${JSON.stringify(input)}\n`);
+  const ntype = String(input.notification_type || input.notificationType || input.type || "");
+  // only the two agent-lifecycle notification types are board-relevant; ignore permission/idle/auth/elicitation
+  if (ntype !== "agent_needs_input" && ntype !== "agent_completed") { process.stdout.write("{}"); process.exit(0); }
+
+  const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const project = resolveProject(cwd);
+  // candidate id for pairing needs_input→completed and for guarding vs an already-carded cc-subagent. The
+  // agent's OWN session id is the most likely stable key for a background/child agent across both events.
+  const agentId = String(input.agent_id || input.agentId || input.session_id || input.sessionId || "").slice(0, 120);
+  const agentType = String(input.agent_type || input.agentType || "agent").slice(0, 40);
+  // parent = the session that spawned it → nest under that session's focus card (same rule as cc-subagent)
+  const parent = String(input.parent_session_id || input.parentSessionId || "").slice(0, 120);
+  // a lightly-cleaned human label; Notification carries a `message`. NOTE: Teams privacy gate applies before
+  // this reaches a shared board (it can carry prompt text) — same rule as focus-card titles.
+  const msg = String(input.message || "").replace(/\s+/g, " ").trim().slice(0, 90);
+  const title = `${agentType}${msg ? `: ${msg}` : ""}`.slice(0, 180);
+
+  await fetch(`${relayUrl()}/task`, {
+    method: "POST", headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      project, source: "cc-bg-agent", notificationType: ntype,
+      title, agentId, agentType, parent,
+      assignee: `${agentType}:${project}`, by: `${hostId()}:${project}`, phase: "sub-agents",
+    }),
+    signal: AbortSignal.timeout(1500),
+  }).catch(() => {});
+} catch (e) {
+  process.stderr.write(`[trantor] agent-notify error: ${e?.message || e}\n`);
+}
+process.stdout.write("{}");
+process.exit(0);

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "trantor — auto-register each session + inject live roster (SessionStart); turn each substantive user prompt into the session's live 'focus' card so a regular session's own work shows IN PROGRESS (UserPromptSubmit); post an in-flight 'doing' card when a sub-agent is dispatched (PreToolUse); heartbeat presence on every tool call + deliver unread bus messages to a busy session mid-turn + mirror the session's TodoWrite list onto the board as cards (PostToolUse); write a handoff before compaction (PreCompact); card each sub-agent's notional API cost when it finishes (SubagentStop)",
+  "description": "trantor — auto-register each session + inject live roster (SessionStart); turn each substantive user prompt into the session's live 'focus' card so a regular session's own work shows IN PROGRESS (UserPromptSubmit); post an in-flight 'doing' card when a sub-agent is dispatched (PreToolUse) and enrich it with the native agent_id + parent session when the sub-agent spawns (SubagentStart); heartbeat presence on every tool call + deliver unread bus messages to a busy session mid-turn + mirror the session's TodoWrite list onto the board as cards (PostToolUse); write a handoff before compaction (PreCompact); surface CC's own background/child agents (fork/--agent/subtask) on the board when they need input or complete (Notification); card each sub-agent's notional API cost when it finishes (SubagentStop)",
   "hooks": {
     "SessionStart": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/sessionstart.mjs" } ] }
@@ -10,6 +10,9 @@
     "PreToolUse": [
       { "matcher": "Task|Agent", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/subagent-start.mjs" } ] }
     ],
+    "SubagentStart": [
+      { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/subagent-start.mjs" } ] }
+    ],
     "PostToolUse": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/heartbeat.mjs" } ] },
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/inbox-deliver.mjs" } ] },
@@ -18,6 +21,9 @@
     "PreCompact": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/precompact.mjs" } ] }
     ],
+    "Notification": [
+      { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/agent-notify.mjs" } ] }
+    ],
     "SubagentStop": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/subagent-cost.mjs" } ] }
     ]

package/hooks/subagent-cost.mjs

@@ -81,6 +81,10 @@ try {
   const project = resolveProject(cwd);
   const agentType = String(input.agent_type || "subagent").slice(0, 40);
   const effort = input.effort?.level || "";
+  // agent_id pairs this completion with its SubagentStart "doing" card (robust key, replaces the fragile
+  // title match); parent nests it under the spawning session's focus card. Both native SubagentStop fields.
+  const agentId = String(input.agent_id || "").slice(0, 80);
+  const parent = String(input.parent_session_id || input.session_id || "").slice(0, 120);
 
   const file = findTranscript(input);
   if (!file) { process.stderr.write("[trantor] subagent-cost: no transcript found\n"); process.stdout.write("{}"); process.exit(0); }
@@ -104,7 +108,7 @@ try {
   await fetch(`${relayUrl()}/task`, {
     method: "POST", headers: { "content-type": "application/json" },
     body: JSON.stringify({
-      project, title, status: "done",
+      project, title, status: "done", agentType, agentId, parent,
       assignee: `${agentType}:${project}`, by: `${hostId()}:${project}`,
       source: "cc-subagent", costKind: "subagent-notional",
       costUsd: safeUsd, costNote: safeNote, model, effort, tokens: suspect ? null : tokens,

package/hooks/subagent-start.mjs

@@ -1,9 +1,22 @@
 #!/usr/bin/env node
-// trantor PreToolUse hook (Task|Agent) — when a sub-agent is DISPATCHED, post an in-flight "doing" card so
-// the board shows work IN PROGRESS while it runs. The existing SubagentStop hook (subagent-cost.mjs) flips
-// the matching card to "done" via the hub's cc-subagent title-fingerprint dedup. Without this, every auto-
-// card was born "done" (SubagentStop/git-backfill) so nothing ever showed as in progress. Fail-silent:
-// never block or delay the dispatch.
+// trantor sub-agent in-flight hook — posts/enriches a "doing" card so the board shows sub-agent work IN
+// PROGRESS while it runs. The SubagentStop hook (subagent-cost.mjs) flips it to "done" (with notional cost).
+//
+// This ONE script serves TWO hook events (dispatch on input.hook_event_name):
+//
+//   • PreToolUse (matcher Task|Agent) — fires at DISPATCH TIME and carries tool_input.prompt, so it has a
+//     good human title. It CREATES the in-flight card (source:"cc-subagent", title-fingerprinted). Works on
+//     every CC version → the universal in-flight source, no regression on older CC.
+//
+//   • SubagentStart (native, CC 2.1.x+) — fires when the sub-agent actually SPAWNS and carries the real
+//     agent_id + agent_type (+ parent session), but NO prompt. It ENRICHES the card the PreToolUse create
+//     already made: stamps agent_id (robust start↔stop pairing key, replacing the fragile title match) and
+//     parent (for nesting sub-agents under the session focus card). If no create card exists (a spawn with
+//     no matching PreToolUse — rare), it CREATES one keyed by agent_id so nothing orphans.
+//
+// Registering BOTH never double-posts: on modern CC the PreToolUse create runs first, then SubagentStart
+// finds that card by (project, agentType) and enriches in place (creates nothing). Fail-silent throughout —
+// never block or delay a dispatch.
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
@@ -19,26 +32,45 @@ function relayUrl() {
   try { const c = join(homedir(), ".agent-bus", "config.json"); if (existsSync(c)) { const u = JSON.parse(readFileSync(c, "utf8")).url; if (u) return u; } } catch {}
   return "http://127.0.0.1:4477";
 }
+const post = (url, body) => fetch(url, {
+  method: "POST", headers: { "content-type": "application/json" },
+  body: JSON.stringify(body), signal: AbortSignal.timeout(1500),
+}).catch(() => {});
 
 try {
   const input = JSON.parse((await readStdin()) || "{}");
-  const ti = input.tool_input || {};
   const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
   const project = resolveProject(cwd);
-  const agentType = String(ti.subagent_type || "subagent").slice(0, 40);
-  // MUST mirror subagent-cost.mjs's title derivation (lines 100-101) so the hub's title fingerprint pairs
-  // this start card with the SubagentStop "done" card into ONE rolling cc-subagent card.
-  const task = String(ti.prompt || ti.description || agentType).replace(/\s+/g, " ").trim().slice(0, 90);
-  const title = `${agentType}: ${task}`.slice(0, 180);
-  await fetch(`${relayUrl()}/task`, {
-    method: "POST", headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      project, title, status: "doing",
+  const url = `${relayUrl()}/task`;
+
+  if (input.hook_event_name === "SubagentStart") {
+    // ENRICH path — the sub-agent has spawned; attach its real id + parent to the in-flight card.
+    // agent_type is the native SubagentStart field (PreToolUse used tool_input.subagent_type).
+    const agentType = String(input.agent_type || input.subagent_type || "subagent").slice(0, 40);
+    const agentId = String(input.agent_id || "").slice(0, 80);
+    // parent = the session that spawned this sub-agent → nest it under that session's focus card.
+    const parent = String(input.parent_session_id || input.session_id || "").slice(0, 120);
+    if (agentId) {
+      await post(url, {
+        project, enrich: true, agentType, agentId, parent,
+        by: `${hostId()}:${project}`,
+        source: "cc-subagent", costKind: "subagent-notional", phase: "sub-agents",
+      });
+    }
+  } else {
+    // CREATE path (PreToolUse Task|Agent) — dispatch time, has the prompt → good title.
+    const ti = input.tool_input || {};
+    const agentType = String(ti.subagent_type || "subagent").slice(0, 40);
+    // MUST mirror subagent-cost.mjs's title derivation so the hub's title fingerprint pairs this start card
+    // with the SubagentStop "done" card on any client that predates agent_id pairing (legacy fallback).
+    const task = String(ti.prompt || ti.description || agentType).replace(/\s+/g, " ").trim().slice(0, 90);
+    const title = `${agentType}: ${task}`.slice(0, 180);
+    await post(url, {
+      project, title, status: "doing", agentType,
       assignee: `${agentType}:${project}`, by: `${hostId()}:${project}`,
       source: "cc-subagent", costKind: "subagent-notional", phase: "sub-agents",
-    }),
-    signal: AbortSignal.timeout(1500),
-  }).catch(() => {});
+    });
+  }
 } catch (e) {
   process.stderr.write(`[trantor] subagent-start error: ${e?.message || e}\n`);
 }

package/mcp.mjs

@@ -189,10 +189,12 @@ server.tool("relay_inbox", "Read NEW messages addressed to this session since th
   return { content: [{ type: "text", text: messages.length ? messages.map(fmt).join("\n") : "(no new messages)" }] };
 });
 
-server.tool("relay_wait", "Block up to `timeout` seconds waiting for the next message to this session (long-poll). Returns the instant a message arrives. When idle, park by calling this repeatedly. IMPORTANT: some MCP clients cap tool calls (Codex ~120s, OpenCode ~60s) — use timeout 50 and loop, unless you know your client allows more (Claude Code handles 280).",
-  { timeout: z.number().optional().describe("seconds to wait, default 25, max 280. Use 50 and call repeatedly for cross-client safety; only Claude Code reliably supports 280.") },
+server.tool("relay_wait", "Block up to `timeout` seconds waiting for the next message to this session (long-poll). Returns the instant a message arrives. When idle, park by calling this repeatedly. IMPORTANT: MCP clients cap or background long tool calls — OpenCode ~60s; Codex ~120s; Claude Code auto-backgrounds ANY MCP call at 120s (CC 2.1.212+, tunable via CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS), which breaks inline parking. Use timeout 50 and loop for cross-client safety.",
+  { timeout: z.number().optional().describe("seconds to wait, default 25. Effective wait is capped at 110s so the call always returns inline (a longer wait would be auto-backgrounded by Claude Code's 120s MCP floor or dropped by other clients). Use 50 and call repeatedly to park while idle.") },
   async ({ timeout }) => {
-    const w = Math.min(timeout ?? 25, 280);
+    // Cap below the 120s MCP auto-background floor (CC 2.1.212+) so relay_wait always
+    // resolves inline on every current client instead of being shipped to the background.
+    const w = Math.min(timeout ?? 25, 110);
     const { messages, cursor: c } = await api("GET", `/poll?session=${encodeURIComponent(SESSION)}&since=${cursor}&wait=${w}`);
     cursor = c;
     return { content: [{ type: "text", text: messages.length ? messages.map(fmt).join("\n") : "(timed out, no message)" }] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.47",
+  "version": "0.17.49",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"
@@ -10,7 +10,7 @@
     "zod": "^4.4.3"
   },
   "scripts": {
-    "test": "node test.mjs && node test-scenarios.mjs && node test-failure.mjs && node test-handoff.mjs && node test-agents.mjs && node test-update.mjs && node test-handoff-guard.mjs && node test-balances.mjs && node test-subagent-cost.mjs && node test-inbox.mjs && node test-inflight.mjs && node test-focus.mjs && python3 engine/test-routing.py"
+    "test": "node test.mjs && node test-scenarios.mjs && node test-failure.mjs && node test-handoff.mjs && node test-agents.mjs && node test-update.mjs && node test-handoff-guard.mjs && node test-balances.mjs && node test-subagent-cost.mjs && node test-inbox.mjs && node test-inflight.mjs && node test-notify.mjs && node test-focus.mjs && python3 engine/test-routing.py"
   },
   "description": "The hub-world for AI agent crews — orchestrate Claude Code, Codex, GLM, Kimi, DeepSeek & any OpenRouter model as live crews with a plan-aware Advisor, a Kanban/flow command center, a testing gate, and an economics brain (Scrooge).",
   "files": [

package/skills/crew/SKILL.md

@@ -49,11 +49,11 @@ 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`.
+`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
@@ -66,7 +66,7 @@ advisor routes to a brought provider you don't recognize, that's expected — ru
 
 ⚠️ **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`.