trantor 0.17.42 → 0.17.44

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.42"
+    "version": "0.17.44"
   },
   "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, Gemini, 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.42",
+      "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.44",
       "author": {
         "name": "Sasha Bogojevic"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.42",
+  "version": "0.17.44",
   "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,7 +12,7 @@
 ### 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, Gemini, Kimi & DeepSeek in their own terminal windows — routed by your
+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.**
 
@@ -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 gemini kimi deepseek:deepseek-v4-pro` spawns one titled
+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
@@ -194,7 +194,7 @@ Trantor's economics engine ([Scrooge](https://github.com/sashabogi/token-scrooge
 automatically by `trantor setup`) knows model capabilities, per-1M costs, and keeps the
 ledger; Trantor turns that into decisions:
 
-- **Declare your plans once:** `trantor profile set claude=max codex=plus gemini=tier kimi=coding-plan deepseek=api`
+- **Declare your plans once:** `trantor profile set claude=max codex=plus zai=coding-plan kimi=coding-plan deepseek=api`
 - The Advisor routes by **your economics**: API-billed orchestrator → offload everything;
   $20-tier plan → the crew *is* the only way a real build fits; max-tier → context horizon
   decides. **Quota pooling**: one build spread across your separate subscription buckets —

package/bin/advise.mjs

@@ -19,12 +19,38 @@ 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.
+//
+// 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" },
+};
+
 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 has = (c) => { try { execSync(`command -v ${c}`, { stdio: "ignore", shell: "/bin/sh" }); return true; } catch { return false; } };
-  const agents = ["codex", "gemini", "kimi", "deepseek"].filter(a => has(a === "deepseek" ? "opencode" : a));
+  const opencodeKey = () => !!read(join(H, ".config", "opencode", "opencode.json"), {})?.provider?.["zai-coding-plan"]?.options?.apiKey;
+  // 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 zai key) 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();
+    return true;
+  };
+  const agents = Object.keys(ROSTER).filter(hasSeat);
   return { profile, registry, caps, agents, scrooge: has("scrooge") };
 }
 
@@ -42,8 +68,9 @@ export function scroogeModelFor(registry, caps, kind = "code", difficulty = "eas
 
 // crude per-package token forecast (input+output through the executor)
 const FORECAST = { easy: 0.3e6, medium: 1.5e6, hard: 6e6 };  // tokens
-// crew agent preference per difficulty: frontier subs take hard, cheap takes easy
-const CREW_PREF = { hard: ["codex", "gemini", "kimi", "deepseek"], medium: ["kimi", "gemini", "codex", "deepseek"], easy: ["deepseek", "kimi", "gemini", "codex"] };
+// crew agent preference per difficulty: frontier subs take hard, cheap takes easy.
+// (gemini retired → its slot goes to glm, a strong coding-plan seat on $0 marginal quota.)
+const CREW_PREF = { hard: ["codex", "glm", "kimi", "deepseek"], medium: ["kimi", "glm", "codex", "deepseek"], easy: ["deepseek", "kimi", "glm", "codex"] };
 
 export function advise(input, world = loadWorld()) {
   const { profile, registry, caps, agents, scrooge } = world;
@@ -82,9 +109,9 @@ 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 agent = pref.sort((a, b) => (used[a] || 0) - (used[b] || 0))[0] || "deepseek";
+    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, agent === "deepseek" ? "deepseek" : 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 };
@@ -120,17 +147,26 @@ export function advise(input, world = loadWorld()) {
   // creation order — the architect substitutes real ids as it creates them.)
   const selfPkgs = routing.filter(r => r.executor === "orchestrator");
   const foundationIdx = selfPkgs.length ? [1] : [];
-  const cards = routing.map((r, i) => ({
+  const cards = routing.map((r, i) => {
+    const seat = ROSTER[r.executor];
+    return {
     order: i + 1, title: r.title, difficulty: r.difficulty,
-    assignee: r.executor === "scrooge" || r.executor === "orchestrator" ? undefined : `${r.executor}:<project>`,
-    // "auto" = resolve a LIVE model at spawn (the orchestrator runs `trantor up <agent>:<provider>
-    // --task --difficulty`, which picks the best live model). Was `<cli>-default` — a stale default.
+    // 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>`.
+    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.
+    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.
     model: r.model || (["scrooge", "orchestrator"].includes(r.executor) ? undefined : "auto"),
     task: ["scrooge", "orchestrator"].includes(r.executor) ? undefined : r.kind,
     via: r.executor === "scrooge" ? "relay_scrooge" : "relay_task_add",
     deps_orders: r.executor === "orchestrator" && /integrat/i.test(r.title)
       ? routing.map((x, j) => j + 1).filter(j => j !== i + 1)
-      : (r.executor !== "orchestrator" ? foundationIdx.filter(f => f !== i + 1) : []) }));
+      : (r.executor !== "orchestrator" ? foundationIdx.filter(f => f !== i + 1) : []) };
+  });
   return { mode, why, crew, routing, routing_table_md: table, card_args: cards, est_api_cost_usd: apiCost, quota_pools: pools, summary, orchestrator_tier: orchTier, agents_available: agents };
 }
 

package/bin/cli.mjs

@@ -49,7 +49,7 @@ 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 gemini kimi deepseek:deepseek-v4-pro
+  trantor up …        spawn a crew here:   trantor up codex kimi deepseek:deepseek opencode: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/hooks/hooks.json

@@ -1,9 +1,12 @@
 {
-  "description": "trantor — auto-register each session + inject live roster (SessionStart); 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); 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)",
   "hooks": {
     "SessionStart": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/sessionstart.mjs" } ] }
     ],
+    "UserPromptSubmit": [
+      { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/prompt-focus.mjs" } ] }
+    ],
     "PreToolUse": [
       { "matcher": "Task|Agent", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/subagent-start.mjs" } ] }
     ],

package/hooks/prompt-focus.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// trantor UserPromptSubmit hook — turn each substantive user prompt into the session's live "focus" card,
+// so a REGULAR (non-crew) Claude session's OWN work shows IN PROGRESS on the board as it happens — not only
+// when it commits or dispatches a sub-agent. ONE rolling card per session (the hub re-titles it as the focus
+// shifts and closes it to "done" when the session goes offline). Trivial acks ("yes", "go ahead") don't
+// refocus. Fail-silent + fast: NO LLM call (the title is a heuristic clean of the prompt; Scrooge-summarized
+// titles are a follow-up). Never blocks or delays the turn.
+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";
+}
+// A prompt that is JUST an acknowledgement/continuation (anchored to end) — not a new focus.
+const ACK = /^(y|yes|yep|yeah|ok|okay|sure|go|go ahead|continue|proceed|do it|please|thanks|thank you|ty|next|k|cool|nice|great|perfect|sounds good|👍)[\s.!]*$/i;
+function titleFrom(prompt) {
+  let s = String(prompt || "").replace(/\s+/g, " ").trim();
+  // strip a leading politeness/imperative wrapper so the card reads as the WORK, not "can you please…"
+  s = s.replace(/^(please|can you|could you|would you|hey,?|ok,?|now,?|let's|lets|i want you to|i'd like you to|i need you to|go ahead and)\s+/i, "");
+  return s.slice(0, 120);
+}
+
+try {
+  if (process.env.TRANTOR_NO_FOCUS === "1") { process.stdout.write("{}"); process.exit(0); }   // opt-out
+  const input = JSON.parse((await readStdin()) || "{}");
+  const prompt = String(input.prompt || "");
+  const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  // don't card home-dir sessions (matches sessionstart's phantom-project guard)
+  if (!process.env.RELAY_SESSION && !process.env.RELAY_PROJECT && cwd === homedir()) { process.stdout.write("{}"); process.exit(0); }
+  const trimmed = prompt.replace(/\s+/g, " ").trim();
+  // skip empties, tiny continuations, and pure acks — they're not a new focus
+  if (!trimmed || trimmed.length < 12 || ACK.test(trimmed)) { process.stdout.write("{}"); process.exit(0); }
+  const project = resolveProject(cwd);
+  const session = process.env.RELAY_SESSION
+    || (process.env.RELAY_AGENT ? `${process.env.RELAY_AGENT}:${project}` : `${hostId()}:${project}`);
+  await fetch(`${relayUrl()}/focus`, {
+    method: "POST", headers: { "content-type": "application/json" },
+    body: JSON.stringify({ session, project, title: titleFrom(trimmed), by: session }),
+    signal: AbortSignal.timeout(1500),
+  }).catch(() => {});
+} catch (e) {
+  process.stderr.write(`[trantor] prompt-focus error: ${e?.message || e}\n`);
+}
+process.stdout.write("{}");
+process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.42",
+  "version": "0.17.44",
   "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"
+    "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"
   },
   "description": "The hub-world for AI agent crews — orchestrate Claude Code, Codex, Gemini, Kimi & DeepSeek 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

@@ -1,6 +1,6 @@
 ---
 name: crew
-description: Orchestrate a multi-agent build with Trantor — get an Advisor recommendation (solo/scrooge/crew/hybrid based on the user's plans and the work), fire up helper AI CLIs (Codex, Gemini, Kimi, DeepSeek) with pinned models in visible terminal windows, assign difficulty-tagged work over the bus, track it on the Kanban dashboard with a testing gate, delegate grunt to Scrooge, supervise actively, integrate, ship. Use when the user wants several AI agents building something together, says "fire up the crew/agents", "build it with trantor / with the crew", or asks to coordinate other coding CLIs on a task.
+description: Orchestrate a multi-agent build with Trantor — get an Advisor recommendation (solo/scrooge/crew/hybrid based on the user's plans and the work), fire up helper AI CLIs (Codex, GLM, Kimi, DeepSeek) with pinned models in visible terminal windows, assign difficulty-tagged work over the bus, track it on the Kanban dashboard with a testing gate, delegate grunt to Scrooge, supervise actively, integrate, ship. Use when the user wants several AI agents building something together, says "fire up the crew/agents", "build it with trantor / with the crew", or asks to coordinate other coding CLIs on a task.
 ---
 
 # Trantor crew — the unified playbook (brain × body)
@@ -39,12 +39,32 @@ explicit EVENT/INTERFACE CONTRACT — cross-agent bugs come from contract drift.
 3. Open the dashboard: `trantor ui` (or `open -na "Google Chrome" --args --new-window <hub-url>`)
 
 ## Phase 2 — fire up the crew (with the Advisor's models)
-`trantor up codex:gpt-5.5 gemini kimi deepseek:deepseek-v4-pro`
-— `agent:model` pins a model (omit to use that CLI's default; use what relay_advise routed).
+**Each crew card from `relay_advise` carries a `launch` spec — run it VERBATIM; never invent a
+CLI invocation or run an agent "in a terminal" yourself.** Spawn every seat in one call:
+`trantor up <launch> <launch> … --task <kind> --difficulty <diff>`. The live roster + the
+EXACT launch spec per provider (do not improvise these):
+
+| seat | launch spec | notes |
+|---|---|---|
+| 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. |
+
+`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`.
+
+⚠️ **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
+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`.
+
 (If `trantor` isn't on PATH, the same launcher is `bash <plugin-root>/bin/crew.sh up …`.)
 The launcher auto-wires configs, spawns serialized runner windows, then **VERIFIES each agent
 on the bus with one retry**. READ ITS OUTPUT: it ends "crew verified" or "✗✗ CREW INCOMPLETE"
-naming no-shows. **Never assign work to an unverified agent.** The bus is the truth.
+naming no-shows. **Never assign work to an unverified agent.** The bus is the truth. If a seat
+fails to verify, run `trantor doctor` — it shows each CLI's wired/auth state and the exact fix.
 
 ## Phase 3 — contracts over the bus
 Build the shared foundation yourself first, then `relay_send` each agent its contract