trantor 0.18.93 → 0.18.94

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.93",
+  "version": "0.18.94",
   "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/crew-runner.mjs

@@ -29,6 +29,7 @@ import {
 } from "../lib/turn-policy.mjs";
 import { snapshotBeforeCut } from "./cut-snapshot.mjs";
 import { ocTurnUsage, dshTurnUsage, usageTotal } from "../lib/turn-usage.mjs";
+import { ocCompactionContent } from "../lib/seat-compaction.mjs";
 import { listContainers, newContainers, recordContainers, statePathFor as dockerStatePathFor, sweep as dockerSweep } from "../lib/docker-janitor.mjs";
 import {
   auditDutyNudges, claimDutyNudges, claudeTranscriptDir, dutyEscalations, dutyNudgeDirective,
@@ -746,6 +747,21 @@ const PARK_WINDOW_MS = Math.max(0, Number(process.env.TRANTOR_PARK_WINDOW_MS ||
 // The card the CURRENT CLI session belongs to (#6134). 0 = the kickoff session, which belongs to
 // no card, so the first contract that names one starts a session of its own.
 let sessionCard = releaseState?.sessionCard || 0;
+// #11559: per-card token accounting from the runner's own ledger (stdout usage lines, or the
+// provider's session DB when the CLI prints none). A card that crosses its budget pauses — no
+// further turn is bought for THAT card — until the card changes or the seat restarts, both of
+// which reset the counter. The budget itself is an env knob, not a constant in the wall.
+const CARD_TOKEN_BUDGET = Math.max(0, Number(process.env.TRANTOR_CARD_TOKEN_BUDGET || 1_000_000));
+const BUDGET_RETRY_MS = 10 * 60 * 1000;   // a paused card's OWN redelivery pace, never other cards'
+let cardTokens = releaseState?.cardTokens || 0;
+let cardStartedAt = releaseState?.cardStartedAt || 0;
+let budgetStop = releaseState?.budgetStop || null;   // { card, tokens } once the card crossed
+let budgetRetryAt = releaseState?.budgetRetryAt || 0;   // paces the paused card's OWN redeliveries
+
+// #11559: the compaction block injected to opencode-family seats via OPENCODE_CONFIG_CONTENT.
+// "" injects nothing (the operator set TRANTOR_OC_COMPACTION=off, or its JSON is invalid — the
+// seat then behaves exactly as before, never with a half-armed config).
+const OC_COMPACTION = ocCompactionContent(process.env);
 
 let sid = releaseState?.sid || "";
 // #6206: the watchdog is DETACHED, so a runner that dies without ending it leaves an orphan
@@ -930,18 +946,23 @@ exit $turn_exit`;
     // spawned. stdin is /dev/null: a background group that reads the terminal stops on SIGTTIN.
     detached: true,
     cwd: TURN_DIR, encoding: "utf8", stdio: cli.sid ? ["ignore", "pipe", "inherit"] : ["ignore", "inherit", "inherit"],
-    env: { ...process.env, ...shadowEnv(secrets), RELAY_URL: HUB, RELAY_AGENT: AGENT, RELAY_SESSION: SESSION, RELAY_PROJECT: PROJ,
-      // #6228: marks this env as belonging to PROJ, unlike a one-off RELAY_PROJECT override; crew.mjs's
-      // `up` guard refuses to bring up another project's crew from a shell carrying this badge.
-      TRANTOR_SEAT: PROJ,
-      // A runner-managed seat must never hand itself a baton: the runner is its lifecycle manager,
-      // so a handoff spawn would only leak an unmanaged interactive window.
-      TRANTOR_NO_HANDOFF_SPAWN: "1", TRANTOR_NO_BATON_SPAWN: "1",
-      // #6206: the seat's transcript dir — a real CLI ignores it, a drill's fake CLI writes
-      // its transcript lines there so the watchdog sees the liveness a real claude shows.
-      TRANTOR_TRANSCRIPT_DIR: TRANSCRIPT_DIR },
-    maxBuffer: 16 * 1024 * 1024,
   };
+  const spawnEnv = { ...process.env, ...shadowEnv(secrets), RELAY_URL: HUB, RELAY_AGENT: AGENT, RELAY_SESSION: SESSION, RELAY_PROJECT: PROJ,
+    // #6228: marks this env as belonging to PROJ, unlike a one-off RELAY_PROJECT override; crew.mjs's
+    // `up` guard refuses to bring up another project's crew from a shell carrying this badge.
+    TRANTOR_SEAT: PROJ,
+    // A runner-managed seat must never hand itself a baton: the runner is its lifecycle manager,
+    // so a handoff spawn would only leak an unmanaged interactive window.
+    TRANTOR_NO_HANDOFF_SPAWN: "1", TRANTOR_NO_BATON_SPAWN: "1",
+    // #6206: the seat's transcript dir — a real CLI ignores it, a drill's fake CLI writes
+    // its transcript lines there so the watchdog sees the liveness a real claude shows.
+    TRANTOR_TRANSCRIPT_DIR: TRANSCRIPT_DIR };
+  // #11559: opencode only compacts when the context is FULL, which on big-limit models is far
+  // past the point a seat card should reach. The merged-content injection arms compaction per
+  // seat (schema: opencode.ai/config.json) without touching the operator's global config.
+  if (cli.pinned && OC_COMPACTION) spawnEnv.OPENCODE_CONFIG_CONTENT = OC_COMPACTION;
+  spawnOpts.env = spawnEnv;
+  spawnOpts.maxBuffer = 16 * 1024 * 1024;
   // The timeout signals the shell to snapshot before sweeping, just like the normal box.
   // Its 30s margin keeps it out of the normal cut path.
   if (TURN_MAX_MS) { spawnOpts.timeout = (TURN_EXTENSIONS_MAX ? TURN_CEILING_MS : TURN_MAX_MS) + 30000; spawnOpts.killSignal = "SIGTERM"; }
@@ -1069,14 +1090,16 @@ exit $turn_exit`;
     // 0 means "this CLI printed no usage", never "free" — so only overwrite when the envelope
     // actually carried counts.
     if (c) tokens = c.input + c.output + c.cache_read + c.cache_creation;
-  }
-  // #8234: the CLIs that print no usage on stdout keep the counts in their own session records —
+  }  // #8234: the CLIs that print no usage on stdout keep the counts in their own session records —
   // opencode's db, the session resolved for this turn exactly like the `-s` resume id. Sum this
   // turn's window there; null (unknown) leaves the stdout paths above standing — never 0 ("free").
   const usage = cli.pinned && sid ? ocTurnUsage(OC_DB, sid, t0, Date.now())
     : AGENT === "dsh" ? dshTurnUsage(join(homedir(), ".dsh", "sessions"), TURN_DIR, t0, Date.now())
     : null;
   if (usage) tokens = usageTotal(usage);
+  // #11559: every token this turn spent rides the card it served. A card-0 turn (kickoff, pulse,
+  // duty) belongs to no card and adds nothing; the counter resets when the served card changes.
+  if (sessionCard > 0 && Number.isFinite(tokens) && tokens > 0) cardTokens += tokens;
   // #9724: usage RESOLVED to all zeros means no model work happened — never success; null stays
   // unknown, never failure, and a shipped commit is real work (stale record, not the turn).
   const zeroUsage = realExit === 0 && effExit === 0 && !newCommit && usageSaysNoWork(usage);
@@ -1463,7 +1486,8 @@ async function resolveWakeCard(messages, { session }) {
       writeFileSync(PENDF, JSON.stringify({ persona: PERSONA, agent: AGENT, project: PROJ, ts: Date.now(),
         wake: pendingWake, bcast: pendingBcast, seen: seenLedger, ask: awaitingAsk?.id || 0, askTo: awaitingAsk?.to || "" }));
       const state = { cursor, turn: TURN, sid, sessionCard, retryAt, deliveryFails,
-        noDeliveryRetry, askReleased, lastTurnAt, attempted: [...attemptedVersions] };
+        noDeliveryRetry, askReleased, lastTurnAt, attempted: [...attemptedVersions],
+        cardTokens, cardStartedAt, budgetStop, budgetRetryAt };
       process.execve(process.execPath, [process.execPath, ...process.execArgv, ...process.argv.slice(1)],
         { ...process.env, CREW_RELEASE_STATE: JSON.stringify(state) });
     } catch (error) { log(`runner restart failed: ${error.message}`); }
@@ -1485,14 +1509,15 @@ async function resolveWakeCard(messages, { session }) {
       log("parked — waiting for the next message or pulse");
       continue;
     }
-    // A due REDELIVERY runs before we go back to waiting — during an outage the bus is silent by
-    // definition, so the retry timer is the only thing that will ever move these messages.
-    // #7756: a held ask is owed but NEVER redelivered — only the assigner's answer releases it.
-    if (pendingWake.length && !awaitingAsk && Date.now() >= retryAt) { await deliverWake(); continue; }
+    // A due REDELIVERY runs before we go back to waiting: during an outage the bus is silent, so
+    // the retryAt timer is the only thing that will ever move these messages. #7756: a held ask
+    // is owed but NEVER redelivered. #11559: a budget-paused card paces its own redeliveries on
+    // budgetRetryAt - a clock that never delays a poll-delivered contract for a different card.
+    if (pendingWake.length && !awaitingAsk && Date.now() >= retryAt && Date.now() >= budgetRetryAt) { await deliverWake(); continue; }
     // cap the long-poll hold so neither a due pulse nor a due redelivery waits out a silent 280s window
     const due = [];
     if (PULSE_MS) due.push(PULSE_MS - (Date.now() - lastTurnAt));
-    if (pendingWake.length && !awaitingAsk) due.push(retryAt - Date.now());
+    if (pendingWake.length && !awaitingAsk) due.push(Math.min(retryAt, budgetRetryAt || retryAt) - Date.now());
     const holdS = due.length
       ? Math.max(5, Math.min(280, Math.ceil(Math.min(...due) / 1000)))
       : 280;
@@ -1755,6 +1780,20 @@ async function resolveWakeCard(messages, { session }) {
     // and never inherits the previous contract's card (#10197's judge then reads the right card).
     const sessionCardForTurn = card || baseCard;
     const fresh = !resumedAfterAsk && sessionCardForTurn > 0 && sessionCardForTurn !== sessionCard;
+    // #11559: a pause rides the card, not the seat — a contract for a DIFFERENT card lifts it
+    // (and resets the counter with the fresh session below); the paused card itself never buys
+    // another CLI session. The wake stays owed and retries on a long clock, so the orchestrator
+    // sees the pause, not a silent seat.
+    if (budgetStop && sessionCardForTurn > 0 && sessionCardForTurn === budgetStop.card) {
+      log(`\x1b[33mqueued — #${budgetStop.card} is over its token budget (${budgetStop.tokens} ≥ ${CARD_TOKEN_BUDGET}); paused until the card moves or \`trantor up ${AGENT}\` resets the budget\x1b[0m`);
+      // Pace only the SELF-redelivery path (a non-empty queue with retryAt=0 would otherwise
+      // hot-loop this branch and starve the poll): budgetRetryAt gates that line alone. A new
+      // contract delivered by the poll never waits on it — a different card lifts the pause.
+      budgetRetryAt = Date.now() + BUDGET_RETRY_MS;
+      return;
+    }
+    if (budgetStop && fresh) { budgetStop = null; budgetRetryAt = 0; }
+    if (fresh) { cardTokens = 0; cardStartedAt = Date.now(); }
     sessionCard = card;
     const cited = [...new Set(wakeForTurn.flatMap(m => cardRefs(m.text)))];
     const freshText = fresh
@@ -1957,6 +1996,19 @@ async function resolveWakeCard(messages, { session }) {
       await notifyAssigners(assigners,
         `✅ done on ${SESSION} (exit 0, ${secs}s) · asked: "${asked}" · check the board card and the files for what changed`);
     }
+    // #11559: the pause is judged AFTER the classification so it never masks it — a failed turn
+    // (ec !== 0) stays in its own ladder, and only a clean-exit turn hands its card to the stop.
+    // The stop blocks FUTURE turns for THIS card only: a different card starts clean, and the
+    // alert names the two ways out (move the card, or restart the seat, resetting the counter).
+    if (!budgetStop && CARD_TOKEN_BUDGET > 0 && sessionCard > 0 && cardTokens >= CARD_TOKEN_BUDGET && ec === 0) {
+      budgetStop = { card: sessionCard, tokens: cardTokens };
+      const text = `⛔ #${sessionCard} hit its token budget on ${SESSION}: ${cardTokens} ≥ ${CARD_TOKEN_BUDGET} tokens this card.`
+        + ` Further turns for THIS card are paused until it moves (new contract, or testing/done) or \`trantor up ${AGENT}\` resets the budget.`;
+      log(`\x1b[33m${text}\x1b[0m`);
+      await notifyAssigners(assigners, text);
+      const orch = `${hostId()}:${PROJ}`;
+      if (!assigners.some(a => a.from === orch)) await api("/send", { from: SESSION, to: orch, text, project: PROJ, kind: "alert" }).catch(() => {});
+    }
     lastTurnAt = Date.now();
   }
 })();

package/bin/seat-tokens.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+// trantor seat-tokens (#11559) — per-provider token totals for the seat fleet from opencode's
+// session store, the 30-day shape compared week over week: sessions, assistant steps, tokens,
+// the single biggest step, and cost. Read-only; a missing or locked DB prints "no data".
+//   node bin/seat-tokens.mjs [--days 30] [--db <path>] [--json]
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { seatTokensReport } from "../lib/seat-tokens.mjs";
+
+const argv = process.argv.slice(2);
+const val = (k, d) => { const i = argv.indexOf(k); return i >= 0 && argv[i + 1] ? argv[i + 1] : d; };
+const DAYS = Math.max(1, Number(val("--days", 30)) || 30);
+const DB = val("--db", join(process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"), "opencode", "opencode.db"));
+const since = Date.now() - DAYS * 24 * 60 * 60 * 1000;
+const rows = seatTokensReport({ dbPath: DB, sinceMs: since });
+const fmt = (n) => Number(n).toLocaleString("en-US");
+
+if (val("--json", "")) { console.log(JSON.stringify({ db: DB, days: DAYS, providers: rows }, null, 1)); process.exit(0); }
+if (!rows.length) { console.log(`no session data in ${DB} for the last ${DAYS} day(s)`); process.exit(0); }
+console.log(`opencode seat usage, last ${DAYS} day(s) — ${DB}\n`);
+console.log("provider            sessions   steps  input        output     cache-read     cache-write  peak-step     cost");
+for (const r of rows) {
+  console.log(
+    String(r.provider).padEnd(18),
+    String(r.sessions).padStart(8),
+    String(r.steps).padStart(8),
+    fmt(r.input).padStart(12),
+    fmt(r.output).padStart(10),
+    fmt(r.cacheRead).padStart(14),
+    fmt(r.cacheWrite).padStart(14),
+    fmt(r.peakInput).padStart(12),
+    fmt(Math.round(r.cost)).padStart(6),
+  );
+}

package/lib/dep.mjs

@@ -0,0 +1,37 @@
+// Load an npm dependency from code that may run inside the Claude plugin snapshot, which ships
+// no node_modules: plain import first, then borrow from the globally installed trantor (as mcp.mjs does).
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const req = createRequire(import.meta.url);
+let fallbackRoots = null;
+
+function borrowRoots() {
+  if (fallbackRoots) return fallbackRoots;
+  const roots = [];
+  const add = p => { if (p && !roots.includes(p)) roots.push(p); };
+  if (process.env.npm_config_prefix) add(join(process.env.npm_config_prefix, "lib", "node_modules"));
+  add(join(dirname(process.execPath), "..", "lib", "node_modules"));
+  for (const prefix of ["/opt/homebrew", "/usr/local"]) add(join(prefix, "lib", "node_modules"));
+  if (!roots.some(r => existsSync(join(r, "trantor")))) {
+    try { add(execSync("npm root -g", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 }).trim()); } catch {}
+  }
+  fallbackRoots = roots.flatMap(r => [join(r, "trantor"), r]);
+  return fallbackRoots;
+}
+
+export async function dep(spec) {
+  try {
+    return await import(spec);
+  } catch (error) {
+    if (error?.code !== "ERR_MODULE_NOT_FOUND" && error?.code !== "ERR_PACKAGE_PATH_NOT_EXPORTED") throw error;
+  }
+  for (const path of [HERE, ...borrowRoots()]) {
+    try { return await import(pathToFileURL(req.resolve(spec, { paths: [path] })).href); } catch {}
+  }
+  throw new Error(`cannot resolve '${spec}': this plugin snapshot has no node_modules and no global trantor install to borrow from (npm i -g trantor)`);
+}

package/lib/memory-pin-write.mjs

@@ -1,9 +1,11 @@
 import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, renameSync, unlinkSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
-import { stringify } from "yaml";
+import { dep } from "./dep.mjs";
 import { checkPin, frontMatter, memoryDirectory, notePins, pinTarget, refreshPinGraph, symbolFingerprint } from "./memory-pins.mjs";
 
+const { stringify } = await dep("yaml");
+
 export function replaceNotePins(text, pins) {
   const front = frontMatter(text);
   const newline = text.includes("\r\n") ? "\r\n" : "\n";

package/lib/memory-pins.mjs

@@ -3,8 +3,10 @@ import { closeSync, existsSync, openSync, readFileSync, readdirSync, statSync, u
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
-import { isMap, parseDocument } from "yaml";
-import { z } from "zod";
+import { dep } from "./dep.mjs";
+
+const { isMap, parseDocument } = await dep("yaml");
+const { z } = await dep("zod");
 
 export function fingerprint(text) {
   const normalized = text.replace(/\r\n/g, "\n").split("\n")

package/lib/seat-compaction.mjs

@@ -0,0 +1,34 @@
+// #11559: seats run long cards in ONE opencode session (#6134's design), and opencode only
+// auto-compacts when the context is FULL - far past 100K on big-limit models. The knob is the
+// top-level `compaction` block (schema: opencode.ai/config.json), injected per seat via
+// OPENCODE_CONFIG_CONTENT (override: TRANTOR_OC_COMPACTION), which MERGES with the operator's global config.
+
+export const OC_COMPACTION_ENV = "TRANTOR_OC_COMPACTION";
+
+// The seat default: compaction on, old tool outputs pruned, a small recent window preserved.
+// `reserved` is the buffer subtracted from the model's window before opencode calls the context
+// full, so a larger value fires compaction earlier. Override the whole block with
+// TRANTOR_OC_COMPACTION=<json>, or set it to "off" to ship no config content at all.
+export const OC_COMPACTION_DEFAULT = {
+  auto: true,
+  prune: true,
+  tail_turns: 4,
+  preserve_recent_tokens: 24_000,
+  reserved: 64_000,
+};
+
+/// A JSON string for OPENCODE_CONFIG_CONTENT, or "" when nothing should be injected: "off" opts
+/// out, invalid JSON opts out loudly at the caller (never arms a half-parsed block), custom JSON
+/// is wrapped as { compaction: <the value> } so the env stays one knob.
+export function ocCompactionContent(env = process.env) {
+  const raw = String(env[OC_COMPACTION_ENV] || "").trim();
+  if (raw === "off") return "";
+  if (!raw) return JSON.stringify({ compaction: OC_COMPACTION_DEFAULT });
+  let parsed;
+  try { parsed = JSON.parse(raw); } catch { return ""; }
+  // SAFETY: the operator's raw JSON arrives here untyped — a bare number, string or null must
+  // opt OUT (no config), never arm a half-shaped compaction block at every opencode seat.
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "";
+  return JSON.stringify({ compaction: parsed });
+}

package/lib/seat-tokens.mjs

@@ -0,0 +1,72 @@
+// #11559: the seat fleet's token burn was invisible — mined by hand from opencode's DB. This
+// reader makes it a command: per-provider 30-day session/step/token totals, read-only, so a
+// week-over-week comparison is one line. No DB at all is "no data", never zero. Read path
+// mirrors lib/turn-usage.mjs (sqlite3 CLI, -readonly, fail-open).
+import { spawnSync } from "node:child_process";
+
+const num = (v) => { const n = Number(v); return Number.isInteger(n) && n >= 0 ? n : 0; };
+
+/// "provider/model" → "provider"; a bare model reads "?" so the row still groups. The 1.16.x DB
+/// also stores whole JSON blobs ({"id":…,"providerID":…,"variant":…}) in session.model — the
+/// provider then lives at $.providerID. The SQL mirrors this in CASE/WHEN form.
+export function providerOf(model) {
+  const s = String(model || "").trim();
+  if (s.startsWith("{")) {
+    try { return String(JSON.parse(s).providerID || "?"); } catch { return "?"; }
+  }
+  const at = s.indexOf("/");
+  return at > 0 ? s.slice(0, at) : "?";
+}
+
+const PROVIDER_SQL = (col) => `CASE WHEN substr(${col},1,1)='{' THEN COALESCE(json_extract(${col},'$.providerID'),'?')`
+  + ` WHEN instr(${col},'/')>1 THEN substr(${col},1,instr(${col},'/')-1) ELSE '?' END`;
+
+export const SESSIONS_SQL = (sinceMs) => `SELECT ${SESSION_COLS} FROM session`
+  + ` WHERE time_updated>=${Math.floor(sinceMs)} GROUP BY p ORDER BY total DESC;`;
+const SESSION_COLS = `${PROVIDER_SQL("model")} AS p, COUNT(*) AS sessions,`
+  + ` COALESCE(SUM(tokens_input),0), COALESCE(SUM(tokens_output),0), COALESCE(SUM(tokens_cache_read),0),`
+  + ` COALESCE(SUM(tokens_cache_write),0), COALESCE(SUM(cost),0), COALESCE(MIN(time_created),0),`
+  + ` COALESCE(MAX(time_updated),0), COALESCE(SUM(tokens_input+tokens_output+tokens_cache_read+tokens_cache_write),0) AS total`;
+
+export const STEPS_SQL = (sinceMs) => `SELECT ${PROVIDER_SQL("s.model")} AS p,`
+  + ` COUNT(m.id), COALESCE(MAX(json_extract(m.data,'$.tokens.input')),0)`
+  + ` FROM message m JOIN session s ON s.id=m.session_id`
+  + ` WHERE json_extract(m.data,'$.role')='assistant' AND m.time_created>=${Math.floor(sinceMs)} GROUP BY p;`;
+
+const pipeRows = (text, cols) => String(text || "").split("\n").filter((l) => l.trim() !== "")
+  .map((line) => {
+    const parts = line.split("|");
+    return parts.length === cols ? parts : null;
+  })
+  .filter(Boolean);
+
+/// { provider, sessions, input, output, cacheRead, cacheWrite, cost, firstAt, lastAt, tokens,
+///   steps, peakInput } per provider, tokens descending. [] when both queries return nothing —
+/// an empty fleet and an unreadable DB print the same "no data" line, never zeros that lie.
+export function seatTokensReport({ dbPath, sinceMs, run = spawnSync } = {}) {
+  if (!dbPath || !Number.isFinite(sinceMs)) return [];
+  const q = (sql) => {
+    let r;
+    try { r = run("sqlite3", ["-readonly", dbPath, sql], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15000 }); }
+    catch { return null; }
+    return !r || r.error || r.status !== 0 ? null : r.stdout;
+  };
+  const sessions = pipeRows(q(SESSIONS_SQL(sinceMs)), 10);
+  const steps = pipeRows(q(STEPS_SQL(sinceMs)), 3);
+  const byProvider = new Map(sessions.map((c) => [c[0], {
+    provider: c[0],
+    sessions: num(c[1]),
+    input: num(c[2]), output: num(c[3]), cacheRead: num(c[4]), cacheWrite: num(c[5]),
+    cost: Number(c[6]) || 0,
+    firstAt: num(c[7]), lastAt: num(c[8]),
+    tokens: num(c[9]),
+    steps: 0, peakInput: 0,
+  }]));
+  for (const [p, count, peak] of steps) {
+    const row = byProvider.get(p);
+    if (!row) continue;
+    row.steps = num(count);
+    row.peakInput = num(peak);
+  }
+  return [...byProvider.values()].sort((a, b) => b.tokens - a.tokens);
+}

package/package.json

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