trantor 0.17.18 → 0.17.20

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.18",
+  "version": "0.17.20",
   "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/bin/git-backfill.mjs

@@ -27,6 +27,7 @@ const me = `${hostId()}:${project}`;
 
 const themeOf = (s) => {
   let m;
+  if ((m = s.match(/^release:\s*v?(\d+\.\d+\.\d+)/i))) return "v" + m[1];     // release: v0.17.15 → v0.17.15 (one card per version)
   if ((m = s.match(/^[a-z]+\(([^)]+)\)\s*:/i))) return m[1].trim();           // feat(engine): → engine
   if ((m = s.match(/^([A-Za-z][\w &+/.]*?)\s*:/))) return m[1].trim();        // "Landing: …" → Landing
   if ((m = s.match(/^([A-Za-z][\w.+-]*)/))) return m[1];                      // first word
@@ -57,7 +58,11 @@ const ents = [...groups.entries()].sort((a, b) => a[1].latest - b[1].latest);
 let posted = 0, skipped = 0;
 for (const [theme, g] of ents) {
   const latest = g.commits.sort((a, b) => b.ts - a.ts)[0];
-  const subj = latest.subject.replace(/^[a-z]+\([^)]*\)\s*:\s*/i, "").replace(/^[A-Za-z][\w &+/.]*?:\s*/, "").slice(0, 70);
+  const subj = latest.subject
+    .replace(/^[a-z]+\([^)]*\)\s*:\s*/i, "")          // strip feat(scope):
+    .replace(/^[A-Za-z][\w &+/.]*?:\s*/, "")           // strip "release:" / "Landing:"
+    .replace(/^v?\d+\.\d+\.\d+\s*[—–-]\s*/, "")        // strip a leading "v0.17.15 — " (release version dup)
+    .slice(0, 70);
   const title = `${theme}: ${subj}${g.commits.length > 1 ? ` (+${g.commits.length - 1} more)` : ""}`.slice(0, 190);
   if (existing.has(title)) { skipped++; continue; }
   if (dry) { console.log(`+ [${new Date(g.latest).toISOString().slice(0, 10)}] ${theme.padEnd(20)} ${g.commits.length}c  ${title.slice(0, 64)}`); posted++; continue; }

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "trantor — auto-register each session + inject live roster (SessionStart); heartbeat presence on every tool call + mirror the session's TodoWrite list onto the board as cards (PostToolUse); write a handoff before compaction (PreCompact)",
+  "description": "trantor — auto-register each session + inject live roster (SessionStart); heartbeat presence on every tool call + 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" } ] }
@@ -10,6 +10,9 @@
     ],
     "PreCompact": [
       { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/precompact.mjs" } ] }
+    ],
+    "SubagentStop": [
+      { "matcher": "", "hooks": [ { "type": "command", "command": "node ${CLAUDE_PLUGIN_ROOT}/hooks/subagent-cost.mjs" } ] }
     ]
   }
 }

package/hooks/pricing.mjs

@@ -0,0 +1,46 @@
+// trantor — Anthropic API pricing, the single source of truth for the NOTIONAL dollar cost of a
+// Claude Code sub-agent's token usage (it's "notional" because on a Pro/Max plan those tokens are
+// plan-covered, not billed — we still want the number). $/MTok. Re-confirm before trusting old reports.
+export const PRICING_AS_OF = "2026-06";
+
+// in/out = input/output; cw5m/cw1h = cache-WRITE at the 5-minute / 1-hour TTL; cr = cache-READ.
+// (cache write 5m = 1.25× input, 1h = 2× input, read = 0.1× input — encoded directly here.)
+export const ANTHROPIC_PRICING = {
+  opus:        { in: 5,  out: 25, cw5m: 6.25,  cw1h: 10, cr: 0.5 },
+  sonnet:      { in: 3,  out: 15, cw5m: 3.75,  cw1h: 6,  cr: 0.3 },
+  haiku:       { in: 1,  out: 5,  cw5m: 1.25,  cw1h: 2,  cr: 0.1 },
+  "opus-4-1":  { in: 15, out: 75, cw5m: 18.75, cw1h: 30, cr: 1.5 }, // legacy numbering — far pricier
+};
+
+// Map a transcript model id ("claude-opus-4-8", "claude-sonnet-4-6", …) to a price tier, or null.
+export function tierFor(model) {
+  const m = String(model || "").toLowerCase();
+  if (/opus-4-1\b|opus-4\.1/.test(m)) return "opus-4-1";
+  if (m.includes("opus")) return "opus";
+  if (m.includes("sonnet")) return "sonnet";
+  if (m.includes("haiku")) return "haiku";
+  return null; // unknown → caller emits costUsd:null + a costNote rather than guessing
+}
+
+// Notional USD for one turn's usage. Sub-agents always start a COLD cache (5m TTL) even on a
+// subscription, so cache writes default to the 5m rate. Returns null when the model isn't priced.
+export function costOfTurn({ model, input = 0, output = 0, cacheWrite = 0, cacheRead = 0 }, ttl = "5m") {
+  const p = ANTHROPIC_PRICING[tierFor(model)];
+  if (!p) return null;
+  const cw = ttl === "1h" ? p.cw1h : p.cw5m;
+  return (input * p.in + output * p.out + cacheWrite * cw + cacheRead * p.cr) / 1e6;
+}
+
+// Sum a list of usage rows → { usd, tokens, unpriced, model }. usd is null only if NOTHING was priced.
+export function notionalCost(rows, ttl = "5m") {
+  const tokens = { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 };
+  let usd = 0, priced = 0, unpriced = 0, model = "";
+  for (const r of rows) {
+    tokens.input += r.input || 0; tokens.output += r.output || 0;
+    tokens.cacheWrite += r.cacheWrite || 0; tokens.cacheRead += r.cacheRead || 0;
+    if (r.model) model = r.model;
+    const c = costOfTurn(r, ttl);
+    if (c == null) unpriced++; else { usd += c; priced++; }
+  }
+  return { usd: priced ? usd : null, tokens, unpriced, priced, model };
+}

package/hooks/subagent-cost.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// trantor SubagentStop hook — when a Claude Code sub-agent (Agent/Task tool, Workflow swarm, ultracode,
+// agent-team teammate) finishes, read ITS OWN transcript's token usage and post a board card tagged with
+// the NOTIONAL API cost (what those tokens would cost at API rates — plan-covered, not billed, on a sub).
+// No hook carries cost, so we parse the sub-agent transcript (confirmed to carry per-turn message.usage +
+// message.model). This is the orchestrator's-own-work blind spot that crew (external CLIs) + Scrooge
+// (real $) don't cover. Fail-silent: never break the parent session.
+import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { resolveProject, hostId } from "../lib/project.mjs";
+import { notionalCost } from "./pricing.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";
+}
+
+// Resolve the sub-agent's transcript: the payload path, else reconstruct, else newest agent-*.jsonl.
+function findTranscript(input) {
+  const direct = input.transcript_path;
+  if (direct && existsSync(direct)) return direct;
+  const sid = input.session_id, aid = input.agent_id;
+  // search the session's subagents tree (plain Task → subagents/agent-<id>.jsonl; Workflow → subagents/workflows/<wf>/agent-<id>.jsonl)
+  const roots = [];
+  try {
+    const base = join(homedir(), ".claude", "projects");
+    for (const proj of readdirSync(base)) {
+      const sdir = join(base, proj, sid || "", "subagents");
+      if (sid && existsSync(sdir)) roots.push(sdir);
+    }
+  } catch {}
+  let best = "", bestM = 0;
+  const walk = dir => { let ents = []; try { ents = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of ents) {
+      const p = join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.isFile() && /^agent-.*\.jsonl$/.test(e.name)) {
+        if (aid && e.name.includes(aid)) return (best = p, bestM = Infinity); // exact id wins
+        try { const m = statSync(p).mtimeMs; if (m > bestM) { best = p; bestM = m; } } catch {}
+      }
+    }
+  };
+  for (const r of roots) walk(r);
+  return best || "";
+}
+
+function usageRows(file) {
+  const rows = [];
+  let firstUserText = "";
+  try {
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+      if (!line) continue;
+      let r; try { r = JSON.parse(line); } catch { continue; }
+      if (!firstUserText && r.type === "user" && r.message) {
+        const c = r.message.content;
+        firstUserText = (typeof c === "string" ? c : Array.isArray(c) ? c.filter(b => b?.type === "text").map(b => b.text).join(" ") : "").trim();
+      }
+      const u = r?.message?.usage;
+      if (r.type === "assistant" && u) rows.push({
+        model: r.message.model || "",
+        input: u.input_tokens || 0, output: u.output_tokens || 0,
+        cacheWrite: u.cache_creation_input_tokens || 0, cacheRead: u.cache_read_input_tokens || 0,
+      });
+    }
+  } catch {}
+  return { rows, firstUserText };
+}
+
+try {
+  const input = JSON.parse((await readStdin()) || "{}");
+  const cwd = input.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const project = resolveProject(cwd);
+  const agentType = String(input.agent_type || "subagent").slice(0, 40);
+  const effort = input.effort?.level || "";
+
+  const file = findTranscript(input);
+  if (!file) { process.stderr.write("[trantor] subagent-cost: no transcript found\n"); process.stdout.write("{}"); process.exit(0); }
+  const { rows, firstUserText } = usageRows(file);
+  const ttl = process.env.TRANTOR_CACHE_TTL === "1h" ? "1h" : "5m";
+  const { usd, tokens, unpriced, model } = notionalCost(rows, ttl);
+
+  const task = (firstUserText || agentType).replace(/\s+/g, " ").slice(0, 90);
+  const title = `${agentType}: ${task}`.slice(0, 180);
+  const costNote = usd == null ? "usage-unavailable-or-unpriced" : (unpriced ? `${unpriced} turn(s) unpriced` : "");
+
+  await fetch(`${relayUrl()}/task`, {
+    method: "POST", headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      project, title, status: "done",
+      assignee: `${agentType}:${project}`, by: `${hostId()}:${project}`,
+      source: "cc-subagent", costKind: "subagent-notional",
+      costUsd: usd, costNote, model, effort, tokens,
+      phase: "sub-agents",
+    }),
+    signal: AbortSignal.timeout(2500),
+  }).catch(() => {});
+  process.stderr.write(`[trantor] subagent-cost: ${agentType} ${model} ~$${usd == null ? "?" : usd.toFixed(4)} (${tokens.input + tokens.output + tokens.cacheWrite + tokens.cacheRead} tok) → ${project}\n`);
+  // surface it back to the parent's Claude inline
+  process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "SubagentStop", additionalContext: `[trantor] logged sub-agent ${agentType} — notional $${usd == null ? "?" : usd.toFixed(4)}` } }));
+} catch (e) {
+  process.stderr.write(`[trantor] subagent-cost error: ${e?.message || e}\n`);
+  process.stdout.write("{}");
+}
+process.exit(0);

package/hub.mjs

@@ -262,7 +262,17 @@ const server = http.createServer(async (req, res) => {
       const t = { id: ++state.taskSeq, project: canon(String(b.project || "").slice(0,80)), title: String(b.title||"").slice(0,200),
         assignee: b.assignee || "", status: st0,
         phase: String(b.phase || "").slice(0, 40),   // explicit phase tag (FLOW v2) — wins over title-prefix inference
-        source: String(b.source || "").slice(0, 20), // e.g. "git" (backfill), "todo" — provenance
+        source: String(b.source || "").slice(0, 20), // e.g. "git" (backfill), "todo", "cc-subagent" — provenance
+        // economics: how this card's cost should be counted. costKind discriminates the source so the
+        // dashboard can show notional (plan-covered) vs real spend inline-but-differentiated.
+        costKind: String(b.costKind || "").slice(0, 24),         // subagent-notional|orchestrator-notional|crew-subscription|scrooge-real
+        costUsd: (typeof b.costUsd === "number" && isFinite(b.costUsd)) ? b.costUsd : null,
+        costNote: String(b.costNote || "").slice(0, 80),
+        effort: String(b.effort || "").slice(0, 12),
+        tokens: (b.tokens && typeof b.tokens === "object") ? {
+          input: Number(b.tokens.input) || 0, output: Number(b.tokens.output) || 0,
+          cacheWrite: Number(b.tokens.cacheWrite) || 0, cacheRead: Number(b.tokens.cacheRead) || 0,
+        } : null,
         difficulty: ["easy","medium","hard"].includes(b.difficulty) ? b.difficulty : "",
         model: String(b.model || "").slice(0, 60),
         deps: Array.isArray(b.deps) ? [...new Set(b.deps.map(Number).filter(n => Number.isInteger(n) && n > 0))].slice(0, 20) : [],

package/package.json

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