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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.48",
+  "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
@@ -135,11 +136,13 @@ project takes over with a full window (and a PreCompact hook does this automatic
    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.
+   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
-(`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 +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/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.48",
+  "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": [