trantor 0.17.20 → 0.17.22

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

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.20",
+  "version": "0.17.22",
   "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/baton-close.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// trantor baton-close — the second half of the baton pass. Runs DETACHED, armed by the handoff hook.
+// Waits until the FRESH session has consumed the handoff (consumed:true on the handoff file = it
+// started and loaded the context), THEN closes the ORIGINAL session's Terminal window — so you're never
+// left with two live sessions on one project, and never a gap where neither is alive. Defensive: aborts
+// if the fresh session never shows (timeout), and re-validates the window's tty before closing so it can
+// NEVER close the wrong window. Args: <handoffFile> <originalWindowId> <originalTty>
+import { readFileSync, existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+
+const [, , handoffFile, windowId, originalTty] = process.argv;
+const POLL_MS = 1500, TIMEOUT_MS = 120_000;
+
+const consumed = () => { try { return JSON.parse(readFileSync(handoffFile, "utf8")).consumed === true; } catch { return false; } };
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+function ttyOfWindow(id) {
+  try {
+    return execSync(`osascript -e ${JSON.stringify(`tell application "Terminal" to get tty of selected tab of (first window whose id is ${id})`)}`,
+      { encoding: "utf8", timeout: 3000 }).trim();
+  } catch { return ""; }
+}
+function closeWindow(id, tty) {
+  // re-validate: only close if the window is STILL on the original tty (never close a re-used/wrong window)
+  const cur = ttyOfWindow(id);
+  if (!cur || (originalTty && cur !== originalTty)) {
+    process.stderr.write(`[trantor] baton-close: window ${id} tty changed (${cur} != ${originalTty}) — NOT closing\n`);
+    return false;
+  }
+  try {
+    // SIGKILL the processes on that tty first (claude traps SIGTERM; a live login makes close() pop a dialog)
+    const dev = (tty || cur).replace(/^\/dev\//, "");
+    for (const pid of execSync(`ps -t ${dev} -o pid= 2>/dev/null || true`, { encoding: "utf8" }).trim().split("\n").filter(Boolean)) {
+      try { execSync(`kill -9 ${pid.trim()} 2>/dev/null || true`); } catch {}
+    }
+  } catch {}
+  try { execSync(`osascript -e ${JSON.stringify(`tell application "Terminal" to close (first window whose id is ${id})`)}`, { timeout: 3000 }); return true; } catch { return false; }
+}
+
+(async () => {
+  if (!handoffFile || !windowId) process.exit(0);
+  const deadline = Date.now() + TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (consumed()) {
+      await sleep(2500); // let the fresh session settle (register, inject) before we pull the original
+      const ok = closeWindow(windowId, originalTty);
+      process.stderr.write(`[trantor] baton-close: fresh session took over → original window ${windowId} ${ok ? "closed" : "left (validation/close failed)"}\n`);
+      process.exit(0);
+    }
+    await sleep(POLL_MS);
+  }
+  process.stderr.write(`[trantor] baton-close: fresh session never confirmed within ${TIMEOUT_MS / 1000}s — leaving the original alive (safe)\n`);
+  process.exit(0);
+})();

package/bin/handoff-prompt.sh

@@ -7,15 +7,17 @@
 # Agent to spawn = $AGENT_CMD (default "claude") — same agent, fresh window.
 DIR="${1:-$HOME}"
 TIMEOUT="${2:-25}"
-AGENT_CMD="${AGENT_CMD:-claude}"
+# The fresh session SELF-ANNOUNCES: it opens already recapping the handoff it took over, so it's never
+# a confusing empty prompt. Single-quoted so it survives osascript->shell with no escaping (no apostrophes).
+AGENT_CMD="${AGENT_CMD:-claude 'Recap the handoff you just took over — what was the previous session doing, and where do we continue? Then wait for me.'}"
 HERE="$(cd "$(dirname "$0")" && pwd)"
 NAME="$(basename "$DIR")"
 
-MSG="trantor — this session's context window is full ($NAME). Open a FRESH session to take over with a full window? It loads a handoff of this session. (The current session keeps compacting either way.)"
+MSG="trantor — context is at ~90% on $NAME. Hand off to a FRESH full-window session now? It loads this session's handoff and continues; this window then closes (baton pass). Cancel to keep working here."
 
 # Best-effort timed dialog. On timeout, error, or no UI session -> empty -> we spawn (the default).
-CHOICE="$(osascript -e "button returned of (display dialog \"${MSG//\"/\\\"}\" buttons {\"Keep compacting\", \"Open fresh session\"} default button \"Open fresh session\" giving up after $TIMEOUT with title \"trantor\")" 2>/dev/null)"
+CHOICE="$(osascript -e "button returned of (display dialog \"${MSG//\"/\\\"}\" buttons {\"Keep working here\", \"Hand off\"} default button \"Hand off\" giving up after $TIMEOUT with title \"trantor\")" 2>/dev/null)"
 
-if [ "$CHOICE" != "Keep compacting" ]; then
+if [ "$CHOICE" != "Keep working here" ]; then
   "$HERE/open-session.sh" "$DIR" "$AGENT_CMD"
 fi

package/hooks/handoff-now.mjs

@@ -1,20 +1,24 @@
 #!/usr/bin/env node
-// trantor — detached EARLY-WARNING handoff worker. The PostToolUse heartbeat spawns this when a
-// session crosses its context warn threshold (~85% of a known window). Its job is to PREPARE a
-// safety-net handoff and NOTIFY — NOT to open a window. Spawning a fresh session while the original
-// is still perfectly usable created a surprise pop-up + an orphaned duplicate session; the actual
-// fresh-window spawn now happens only AT THE WALL (PreCompact). The (~60s) scrooge summary runs here,
-// detached, so it never blocks a tool call. Args: <projectDir> <sessionId> <transcriptPath> [trigger]
-import { readConfig, writeHandoff, pingBus, contextUsage } from "./lib/handoff.mjs";
+// trantor — detached BATON-PASS worker. The PostToolUse heartbeat spawns this when a session crosses
+// its context warn threshold (~90% of a known window). It writes a whole-session handoff (narrative +
+// verbatim in-flight tail), spawns a FRESH session to take over, and arms the baton-close watcher which
+// — once the fresh session has consumed the handoff — closes THIS (original) session's Terminal window.
+// The heavy scrooge summary runs here, detached, so it never blocks a tool call. The original's window
+// id + tty are detected by the heartbeat (which has the controlling tty) and passed in as args.
+// Args: <projectDir> <sessionId> <transcriptPath> [trigger] [originalWindowId] [originalTty]
+import { readConfig, writeHandoff, pingBus, maybeSpawn, armBatonClose } from "./lib/handoff.mjs";
 import { basename } from "node:path";
 
-const [, , projectDir = process.cwd(), sessionId = "", transcript = "", trigger = "context-warn"] = process.argv;
+const [, , projectDir = process.cwd(), sessionId = "", transcript = "", trigger = "context-warn", windowId = "", tty = ""] = process.argv;
 try {
   const conf = readConfig();
   const { file, record } = writeHandoff({ projectDir, sessionId, transcript, trigger });
-  process.stderr.write(`[trantor] early handoff written (safety net, no spawn): ${file}\n`);
-  // notify the bus so a watcher knows a handoff is ready — but do NOT spawn a window here.
+  process.stderr.write(`[trantor] baton handoff written: ${file}\n`);
   await pingBus(basename(projectDir), record.id, conf);
+  if (maybeSpawn(projectDir, conf)) {                 // open the fresh session that takes over
+    const armed = windowId ? armBatonClose(file, windowId, tty, conf) : false;  // close the original once fresh confirms
+    process.stderr.write(`[trantor] fresh session spawned${armed ? ` · baton-close armed for window ${windowId}` : " · no original-window close (none detected / disabled)"}\n`);
+  }
 } catch (e) {
   process.stderr.write(`[trantor] handoff-now error: ${e?.message || e}\n`);
 }

package/hooks/heartbeat.mjs

@@ -18,7 +18,7 @@ import { join, basename, dirname } from "node:path";
 import { homedir, hostname } from "node:os";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { readConfig, contextUsage, warnFrac, alreadyHandedOff } from "./lib/handoff.mjs";
+import { readConfig, contextUsage, warnFrac, alreadyHandedOff, controllingTty, terminalWindowForTty } from "./lib/handoff.mjs";
 import { resolveProject, hostId } from "../lib/project.mjs";
 
 const HEARTBEAT_MS = Number(process.env.RELAY_HEARTBEAT_MS || 60 * 1000);
@@ -56,8 +56,12 @@ async function maybeEarlyWarn(stdinRaw, session) {
     try { writeFileSync(inflight, String(Date.now())); } catch {}
 
     const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-    process.stderr.write(`[trantor] context ${Math.round(usage.frac * 100)}% of ${usage.window} — launching early handoff\n`);
-    const child = spawn(process.execPath, [join(HERE, "handoff-now.mjs"), projectDir, sessionId, transcript, "context-warn"],
+    // Detect THIS session's Terminal window NOW (the hook has the controlling tty; the detached worker
+    // won't) so the baton-close can replace this exact window once the fresh session takes over.
+    const tty = controllingTty();
+    const windowId = tty ? terminalWindowForTty(tty) : "";
+    process.stderr.write(`[trantor] context ${Math.round(usage.frac * 100)}% of ${usage.window} — baton pass (window ${windowId || "?"})\n`);
+    const child = spawn(process.execPath, [join(HERE, "handoff-now.mjs"), projectDir, sessionId, transcript, "context-warn", windowId, tty],
       { detached: true, stdio: "ignore" });
     child.unref();
   } catch {}

package/hooks/lib/handoff.mjs

@@ -75,8 +75,8 @@ export function resolveWindow(model = "", conf = readConfig()) {
 }
 
 export function warnFrac(conf = readConfig()) {
-  const f = Number(process.env.RELAY_CONTEXT_WARN_FRAC || conf.contextWarnFrac || 0.85);
-  return f > 0 && f < 1 ? f : 0.85;
+  const f = Number(process.env.RELAY_CONTEXT_WARN_FRAC || conf.contextWarnFrac || 0.90);
+  return f > 0 && f < 1 ? f : 0.90;   // baton pass fires at 90% — runway to summarize + hand off before the wall
 }
 
 // ---- per-session guard (shared by both paths) -------------------------------
@@ -176,6 +176,13 @@ export function buildSummary(transcriptPath) {
   return `*(no summarizer available — representative transcript digest)*\n\n${convo.slice(-12000)}`;
 }
 
+// The exact recent exchange, VERBATIM (not summarized/sampled) — so a baton-pass handoff carries the
+// precise in-flight state (e.g. the live cs_live_… URL, the exact decision point) even if the scrooge
+// narrative times out on a huge transcript. This is what lets the fresh session truly continue, not guess.
+export function verbatimRecentTail(transcript, chars = 7000) {
+  try { return collectTurns(transcript).join("\n\n").slice(-chars); } catch { return ""; }
+}
+
 // ---- write + announce + spawn ----------------------------------------------
 export function writeHandoff({ projectDir, sessionId, transcript, trigger, summary }) {
   const projectName = basename(projectDir);
@@ -183,12 +190,15 @@ export function writeHandoff({ projectDir, sessionId, transcript, trigger, summa
   const stamp = nowSec() || Date.now();
   let gitStatus = "";
   try { gitStatus = execSync("git -C " + JSON.stringify(projectDir) + " status --short 2>/dev/null | head -30", { encoding: "utf8" }).trim(); } catch {}
+  const narrative = summary ?? buildSummary(transcript);
+  const tail = verbatimRecentTail(transcript);
   const record = {
     id: `${projectName}-${stamp}`,
     project: projectDir, projectName, machine: hostname(),
     session_id: sessionId || "", trigger: trigger || "auto",
     transcript_path: transcript || "", stamp: Number(stamp) || 0,
-    summary: summary ?? buildSummary(transcript),
+    // narrative + a verbatim recent-exchange block so exact in-flight state always survives
+    summary: narrative + (tail ? `\n\n---\n## Verbatim recent exchange (exact in-flight state — continue from here)\n${tail}` : ""),
     gitStatus, consumed: false,
   };
   const file = join(HANDOFF_DIR, `${record.id}.json`);
@@ -196,6 +206,47 @@ export function writeHandoff({ projectDir, sessionId, transcript, trigger, summa
   return { file, record };
 }
 
+// --- baton pass: the original session's Terminal window (macOS), so the fresh session can replace it ---
+// Walk the process tree to the controlling tty (the hook itself may show "??" but its parent claude
+// owns the Terminal's tty). Returns "/dev/ttysNNN" or "".
+export function controllingTty() {
+  for (const pid of [process.pid, process.ppid, getPpid(process.ppid)]) {
+    if (!pid) continue;
+    try { const t = execSync(`ps -o tty= -p ${pid}`, { encoding: "utf8" }).trim(); if (t && t !== "??" && t !== "?") return "/dev/" + t; } catch {}
+  }
+  return "";
+}
+function getPpid(pid) { if (!pid) return 0; try { return Number(execSync(`ps -o ppid= -p ${pid}`, { encoding: "utf8" }).trim()) || 0; } catch { return 0; } }
+
+// Find the Terminal.app window id whose selected tab is on `tty` — the window to close on takeover.
+export function terminalWindowForTty(tty) {
+  if (process.platform !== "darwin" || !tty) return "";
+  const osa = `tell application "Terminal"
+    repeat with w in windows
+      try
+        if (tty of selected tab of w) is "${tty}" then return (id of w) as string
+      end try
+    end repeat
+    return ""
+  end tell`;
+  try { return execSync(`osascript -e ${JSON.stringify(osa)}`, { encoding: "utf8", timeout: 3000 }).trim(); } catch { return ""; }
+}
+
+// Arm the baton-close watcher: a DETACHED process that waits until the fresh session consumes the
+// handoff (consumed:true), then closes the original Terminal window. Never closes blind: aborts on
+// timeout (fresh never showed) and re-validates the window's tty before closing.
+export function armBatonClose(handoffFile, originalWindowId, originalTty, conf = readConfig()) {
+  try {
+    if (process.platform !== "darwin" || !originalWindowId) return false;
+    if (process.env.TRANTOR_NO_BATON_CLOSE === "1" || conf.batonClose === false) return false;
+    const closer = join(HERE, "..", "..", "bin", "baton-close.mjs");
+    if (!existsSync(closer)) return false;
+    const child = spawn(process.execPath, [closer, handoffFile, String(originalWindowId), originalTty || ""], { detached: true, stdio: "ignore" });
+    child.unref();
+    return true;
+  } catch { return false; }
+}
+
 export async function pingBus(projectName, id, conf = readConfig()) {
   try {
     await fetch(`${relayUrl(conf)}/send`, {

package/hooks/precompact.mjs

@@ -6,8 +6,8 @@
 // full window. The new session's SessionStart hook loads the handoff. This is the
 // at-the-wall backstop; the heartbeat hook can also fire this earlier when the
 // context window size is known (see hooks/lib/handoff.mjs).
-import { readConfig, writeHandoff, pingBus, maybeSpawn,
-         contextUsage, alreadyHandedOff, markHandedOff } from "./lib/handoff.mjs";
+import { readConfig, writeHandoff, pingBus, maybeSpawn, armBatonClose,
+         contextUsage, alreadyHandedOff, markHandedOff, controllingTty, terminalWindowForTty } from "./lib/handoff.mjs";
 import { basename } from "node:path";
 
 function readStdin() {
@@ -37,7 +37,11 @@ try {
     process.stderr.write(`[trantor] fresh session already spawned for this window — handoff refreshed only\n`);
   } else if (maybeSpawn(projectDir, conf)) {
     markHandedOff(sessionId, cur);
-    process.stderr.write(`[trantor] fresh-session prompt launched (PreCompact)\n`);
+    // baton pass: arm the close of THIS window once the fresh session takes over (we have the tty here)
+    const tty = controllingTty();
+    const windowId = tty ? terminalWindowForTty(tty) : "";
+    const armed = windowId ? armBatonClose(file, windowId, tty, conf) : false;
+    process.stderr.write(`[trantor] fresh-session spawned (PreCompact)${armed ? ` · baton-close armed for window ${windowId}` : ""}\n`);
   }
 } catch (err) {
   process.stderr.write(`[trantor] precompact error: ${err?.message || err}\n`);

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 {
@@ -526,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.20",
+  "version": "0.17.22",
   "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, '');