trantor 0.17.19 → 0.17.21

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.19",
+  "version": "0.17.21",
   "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/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

@@ -228,7 +228,7 @@ function derivePhases(tasks) {
   const phases = [...byPhase.entries()].map(([key, cards]) => {
     const counts = { todo:0, doing:0, testing:0, failed:0, done:0, blocked:0 };
     for (const c of cards) counts[c.status] = (counts[c.status] || 0) + 1;
-    const node = (c) => ({ id: c.id, title: c.title, assignee: c.assignee || "", agent: agentBrand(c.assignee), model: c.model || "", status: c.status, difficulty: c.difficulty || "", ts: c.ts || 0, updated: c.updated || c.ts || 0, deps: Array.isArray(c.deps) ? c.deps : [] });
+    const node = (c) => ({ id: c.id, title: c.title, assignee: c.assignee || "", agent: agentBrand(c.assignee), model: c.model || "", status: c.status, difficulty: c.difficulty || "", ts: c.ts || 0, updated: c.updated || c.ts || 0, deps: Array.isArray(c.deps) ? c.deps : [], costKind: c.costKind || "", costUsd: (typeof c.costUsd === "number") ? c.costUsd : null, source: c.source || "" });
     const crew = cards.filter(c => !isOrchAssignee(c.assignee)).map(node);
     const orchestrators = cards.filter(c => isOrchAssignee(c.assignee)).map(node);
     return {
@@ -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) : [],
@@ -516,6 +526,39 @@ const server = http.createServer(async (req, res) => {
         // back-compat: `scrooge` is the window older dashboards read (honor ?hours= if passed)
         out.scrooge = q.hours ? rollup(rows.filter(c => c.ts >= nowS - Number(q.hours) * 3600)) : out.windows["24h"];
       } catch {}
+      // --- card-based costs (FLOW v2): the orchestrator's OWN work, by costKind ---
+      // NOTIONAL (Claude sub-agents/orchestrator — plan-covered) is kept STRICTLY SEPARATE from REAL
+      // spend (Scrooge). We never sum them into one headline — that would imply we paid for plan-covered
+      // tokens. Crew is subscription (no per-task $). Card ts is in ms (the scrooge ledger is in seconds).
+      try {
+        const WINDOWS_MS = { "24h": 864e5, week: 7 * 864e5, month: 30 * 864e5, quarter: 90 * 864e5, year: 365 * 864e5 };
+        const costCards = state.tasks.filter(t => t.costKind || t.costUsd != null);
+        const rollupCards = cards => {
+          const byKind = {};
+          for (const t of cards) {
+            const k = t.costKind || "other";
+            const e = byKind[k] ||= { count: 0, usd: 0, tokens_in: 0, tokens_out: 0, cache_read: 0, cache_write: 0, by_model: {}, hasUsd: false };
+            e.count++;
+            if (typeof t.costUsd === "number") { e.usd += t.costUsd; e.hasUsd = true; }
+            if (t.tokens) { e.tokens_in += t.tokens.input || 0; e.tokens_out += t.tokens.output || 0; e.cache_read += t.tokens.cacheRead || 0; e.cache_write += t.tokens.cacheWrite || 0; }
+            if (t.model) { const m = e.by_model[t.model] ||= { count: 0, usd: 0 }; m.count++; m.usd += t.costUsd || 0; }
+          }
+          for (const e of Object.values(byKind)) { e.usd = +e.usd.toFixed(4); e.usd = e.hasUsd ? e.usd : null; }
+          return byKind;
+        };
+        out.costKinds = {};
+        const nowMs = now();
+        for (const [k, ms] of Object.entries(WINDOWS_MS)) out.costKinds[k] = rollupCards(costCards.filter(t => (t.ts || 0) >= nowMs - ms));
+        out.costKinds.lifetime = rollupCards(costCards);
+        // per-project notional totals (subagent+orchestrator) so the dashboard can scope it like reliability
+        const perProject = {};
+        for (const t of costCards) {
+          if (typeof t.costUsd !== "number") continue;
+          if (t.costKind !== "subagent-notional" && t.costKind !== "orchestrator-notional") continue;
+          perProject[canon(t.project)] = +((perProject[canon(t.project)] || 0) + t.costUsd).toFixed(4);
+        }
+        out.notionalByProject = perProject;
+      } catch {}
       return json(res, 200, out);
     }
     if (req.method === "GET" && P === "/lessons") {

package/package.json

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

package/ui.html

@@ -189,6 +189,7 @@ main:not(.learn-open) .learn-body{display:none}
 .gnode.failed .gnbox,.gnode.blocked .gnbox{stroke:var(--red)}
 .gntext{fill:#eaf1fa;font-size:11px;font-family:ui-sans-serif,system-ui;pointer-events:none}
 .gnsub{fill:var(--mut);font-size:9.5px;font-family:ui-sans-serif,system-ui;pointer-events:none}
+.gncost{fill:var(--blu);font-size:9px;font-family:ui-sans-serif,system-ui;text-anchor:end;pointer-events:none}
 .pfband{fill:#0c1320;opacity:.45}
 .pfband.alt{fill:#0e1626;opacity:.55}
 .pfbandtop{opacity:.12}
@@ -318,8 +319,16 @@ let ECON=null;
 const ECON_WINS=[['24h','last 24h'],['week','last week'],['month','last month'],['quarter','last quarter'],['year','last year']];
 let econWin=localStorage.getItem('abEconWin')||'24h';
 const econSaved=x=>x?(x.saved_usd!=null?(+x.saved_usd):Math.max(0,(x.opus_equiv_usd||0)-(x.cost_usd||0))):0;
+// notional (plan-covered) cost of the orchestrator's OWN Claude work for a window — subagent +
+// orchestrator costKinds, summed ONLY with each other (never with real Scrooge spend).
+function econNotional(win){
+  const ck=ECON&&ECON.costKinds&&ECON.costKinds[win]; if(!ck)return 0;
+  return ((ck['subagent-notional']&&ck['subagent-notional'].usd)||0)+((ck['orchestrator-notional']&&ck['orchestrator-notional'].usd)||0);
+}
 function renderEcon(){
-  if(!ECON||!ECON.lifetime||!ECON.lifetime.calls)return;
+  const lifeCalls=(ECON&&ECON.lifetime&&ECON.lifetime.calls)||0;
+  const notionalLife=ECON?econNotional('lifetime'):0;
+  if(!ECON||(!lifeCalls&&!(notionalLife>0)))return;     // show once we have EITHER real savings OR notional CC cost
   const el=$('#econ'); el.style.display='';
   // lifetime running total is the fixed headline; the dropdown picks the comparison window.
   if(!el.dataset.built){
@@ -327,7 +336,8 @@ function renderEcon(){
       `<span style="opacity:.55"> · lifetime · </span>`+
       `<select id="econsel" title="comparison window" style="background:#1a2030;color:inherit;border:1px solid rgba(255,255,255,.18);border-radius:4px;font:inherit;font-size:11px;padding:1px 3px;cursor:pointer;outline:none">`+
         ECON_WINS.map(([k,l])=>`<option value="${k}">${l}</option>`).join('')+`</select>`+
-      `<span style="opacity:.85" id="econwinval"></span>`;
+      `<span style="opacity:.85" id="econwinval"></span>`+
+      `<span id="econnotional" title="Claude's OWN sub-agent work (Agent/Workflow/ultracode) at API rates — plan-covered on a subscription, NOT real spend. Shown separately so it's never confused with the real Scrooge \$ saved." style="opacity:.9;margin-left:2px"></span>`;
     const sel=$('#econsel'); sel.value=econWin;
     sel.onchange=()=>{econWin=sel.value; localStorage.setItem('abEconWin',econWin); renderEcon();};
     el.dataset.built='1';
@@ -335,6 +345,11 @@ function renderEcon(){
   const w=(ECON.windows&&ECON.windows[econWin])||ECON.scrooge, wc=w?w.calls:0;
   $('#econlife').textContent='$'+econSaved(ECON.lifetime).toFixed(2);
   $('#econwinval').textContent=' $'+econSaved(w).toFixed(2)+' ('+wc+' call'+(wc===1?'':'s')+')';
+  // separate notional line — distinct icon + "notional" wording, never added to the savings number
+  const nEl=$('#econnotional');
+  if(nEl) nEl.innerHTML = notionalLife>0
+    ? `<span style="opacity:.5"> · </span>🤖 CC sub-agents <b style="color:var(--blu)">$${notionalLife.toFixed(2)}</b> <span style="opacity:.7">notional</span>`
+    : '';
   const sel=$('#econsel'); if(sel)sel.value=econWin;
 }
 async function econ(){
@@ -395,14 +410,16 @@ function flowHTML(pt, proj){
   const maxColCount = Math.max(1, ...layouts.flatMap(L => L.cols.map(c => c.length)));
   const Y0 = MT + stackH(maxColCount)/2;               // shared horizontal spine midline
   const totalH = MT + stackH(maxColCount) + MB;
-  const gnode = (x, y, title, status, id, orch, agent) => {
+  const gnode = (x, y, title, status, id, orch, agent, cost) => {
     const stripe = SCOL[status] || '#3a4458';
+    const c = (typeof cost === 'number') ? (cost < 0.005 ? '$' + cost.toFixed(4) : '$' + cost.toFixed(2)) : '';
     return `<g class="gnode ${status}${orch?' orch':''}"${id?` data-id="${id}"`:''}>`
       + `<rect class="gnbox" x="${x}" y="${y}" width="${NW}" height="${NH}" rx="8"/>`
       + `<rect x="${x}" y="${y}" width="4" height="${NH}" rx="2" fill="${stripe}"/>`
       + `<text class="gntext" x="${x+11}" y="${y+(agent?15:23)}">${esc(title.slice(0,24))}${title.length>24?'…':''}</text>`
       + (agent?`<text class="gnsub" x="${x+11}" y="${y+29}">@${esc(agent)}</text>`:'')
-      + `<title>${esc(title)}${agent?' · @'+esc(agent):''} — ${status}</title></g>`;
+      + (c?`<text class="gncost" x="${x+NW-8}" y="${y+(agent?15:23)}">${c}</text>`:'')
+      + `<title>${esc(title)}${agent?' · @'+esc(agent):''}${c?` · ${c} notional`:''} — ${status}</title></g>`;
   };
   const gedge = (x1,y1,x2,y2,done) => { const mx=(x1+x2)/2;
     return `<path class="gedge${done?' done':''}" d="M${x1},${y1} C${mx},${y1} ${mx},${y2} ${x2},${y2}"/>`; };
@@ -435,7 +452,7 @@ function flowHTML(pt, proj){
       const p = pos[c.id], parents = parentsOf(c);
       if (parents.length) for (const pid of parents){ const pp = pos[pid]; if (pp) svg += gedge(pp.x+NW, pp.y+NH/2, p.x, p.y+NH/2, byId[pid].status==='done'); }
       else svg += gedge(planX+NW, planY+NH/2, p.x, p.y+NH/2, ph.status==='done');   // root → plan
-      svg += gnode(p.x, p.y, (c.id?'#'+c.id+' ':'')+c.title, c.status, c.synthetic?null:c.id, !!c._orch, c.agent||'');
+      svg += gnode(p.x, p.y, (c.id?'#'+c.id+' ':'')+c.title, c.status, c.synthetic?null:c.id, !!c._orch, c.agent||'', c.costUsd);
       if (!hasChild(c)) svg += gedge(p.x+NW, p.y+NH/2, intX, intY+NH/2, c.status==='done');   // leaf → integrate
     }
     svg += gnode(intX, intY, '◆ integrate', ph.status, null, true, '');