trantor 0.18.100 → 0.18.102

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.18.100",
+  "version": "0.18.102",
   "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/open.mjs

@@ -60,16 +60,35 @@ function unconsumedHandoffs(ctx) {
   return out;
 }
 
-// The handoff written BY the recorded session `id` whose transcript has since grown past it, or null.
+// A person's prompt (origin.kind "human") in a transcript, at or after `afterSecs`, or null. The app's
+// own recap kickoff is not one: a resumed-by-mistake session would otherwise vouch for itself.
+function humanPromptAfter(transcriptPath, afterSecs) {
+  let text;
+  try { text = readFileSync(transcriptPath, "utf8"); } catch { return null; }
+  for (const line of text.split("\n")) {
+    if (!line.includes('"human"')) continue;
+    let e; try { e = JSON.parse(line); } catch { continue; }
+    if (e?.type !== "user" || e?.origin?.kind !== "human") continue;
+    const at = Date.parse(e.timestamp || "") / 1000;
+    if (!(at >= afterSecs)) continue;
+    const c = e.message?.content;
+    const body = typeof c === "string" ? c : Array.isArray(c) ? c.map(x => x?.text || "").join("") : "";
+    if (body.startsWith("You have just taken over via handoff")) continue;
+    return at;
+  }
+  return null;
+}
+
+// The handoff written BY the recorded session `id` that a person kept talking past, or null. Machine
+// traffic after the handoff (the dying turn, wake nudges, task notices) never supersedes it: 10-14 the
+// mtime check resumed crebral-legal's 90%-full session over its own fresh handoff.
 export function supersededHandoff(ctx, id) {
   for (const { file, rec } of unconsumedHandoffs(ctx)) {
     if (!id || rec.session_id !== id || !(Number(rec.stamp) > 0)) continue;
     const slug = String(rec.project || ctx.dir || "").replace(/[/.]/g, "-");
     const transcript = rec.transcript_path || join(ctx.home, ".claude", "projects", slug, `${id}.jsonl`);
-    try {
-      const workedAt = statSync(transcript).mtimeMs / 1000;
-      if (workedAt > Number(rec.stamp) + HANDOFF_SUPERSEDE_GRACE_SECS) return { file, handoffAt: Number(rec.stamp), workedAt };
-    } catch {}
+    const workedAt = humanPromptAfter(transcript, Number(rec.stamp) + HANDOFF_SUPERSEDE_GRACE_SECS);
+    if (workedAt !== null) return { file, handoffAt: Number(rec.stamp), workedAt };
   }
   return null;
 }

package/bin/crew-runner.mjs

@@ -28,7 +28,8 @@ import {
   CUT_CHAIN_PARK_MIN, cutChainEvidence, isBoundedPark, askDuringTurn, askedVerdict,
 } from "../lib/turn-policy.mjs";
 import { snapshotBeforeCut } from "./cut-snapshot.mjs";
-import { ocTurnUsage, dshTurnUsage, usageTotal } from "../lib/turn-usage.mjs";
+import { ocTurnUsage, dshTurnUsage, usageTotal, processedInput, codexStepInput, kimiStepInput, claudeStepInput } from "../lib/turn-usage.mjs";
+import { capConfig, capDecision, capHandoffPrompt, capPointerLine, capExhaustedNote } from "../lib/context-cap.mjs";
 import { ocCompactionContent, ocCompactionLogLine } from "../lib/seat-compaction.mjs";
 import { seatSignalPrefix } from "../lib/seat-signal-guard.mjs";
 import { listContainers, newContainers, recordContainers, statePathFor as dockerStatePathFor, sweep as dockerSweep } from "../lib/docker-janitor.mjs";
@@ -759,6 +760,24 @@ 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
 
+// #11855: card context cap (decision in lib/context-cap.mjs). codex/kimi/claude resume one session
+// per card with no compaction knob; a clean turn whose last step passed the cap earns one handoff
+// note, and the card's next wake starts a fresh session pointed at it. opencode and dsh are exempt.
+const CAPCFG = capConfig();
+let capHandoffs = releaseState?.capHandoffs || {};   // { cardId: handoffs so far }
+let capLogged = releaseState?.capLogged || {};       // { cardId: true } the exhausted note was posted
+let capArmed = releaseState?.capArmed || null;       // { card, tokens }: that card's next wake goes fresh
+let capFreshTurn = releaseState?.capFreshTurn || 0;  // TURN of the last fresh session start
+
+// Last step's processed input from the harness's own record; null = unreadable, never trips.
+function capStepProcessed(sinceMs) {
+  const u = DRIVER === "codex" ? codexStepInput(join(homedir(), ".codex", "sessions"), sinceMs, TURN_DIR)
+    : DRIVER === "kimi" ? kimiStepInput(join(homedir(), ".kimi-code", "sessions"), sid, sinceMs)
+    : DRIVER === "claude" ? claudeStepInput(TRANSCRIPT_DIR, sinceMs)
+    : null;
+  return u ? processedInput(u) : null;
+}
+
 // #11559: the compaction block injected to opencode-family seats via OPENCODE_CONFIG_CONTENT (""
 // injects nothing: TRANTOR_OC_COMPACTION=off or invalid JSON). opencode has no absolute-threshold
 // knob — auto-compact fires at window − reserved (opencode.ai/config.json; calculateCeiling in
@@ -785,7 +804,8 @@ async function runTurn(prompt, isFirst, trigger = "kickoff", opts = {}) {
   const t0 = Date.now();
   // A fresh session must not resume the old one's id: `first` is chosen by isFirst OR a missing
   // sid, so a stale sid would quietly resume the session this turn exists to leave behind.
-  if (isFirst) sid = "";
+  // #11855: the min-steps guard counts from the last fresh start; a state step never resets it.
+  if (isFirst) { sid = ""; if (!opts.state) capFreshTurn = TURN; }
   // #5965 — TURN START. The hub peer row is where the app reads activity from, and the runner is
   // the only one who knows a turn is starting, so say so before the CLI spawn (awaited: the spawn
   // below blocks the loop, an unawaited fetch would not leave the machine until the turn ended).
@@ -1195,6 +1215,26 @@ exit $turn_exit`;
     try { return await runTurn(TIME_BOX_PROMPT, false, "time-box follow-up"); }
     finally { inFollowUp = false; }
   }
+  // #11855: a clean card turn only; a cut turn belongs to the box follow-up chain, and the handoff
+  // follow-up's own end must not arm another.
+  if (CAPCFG.cap > 0 && !cut && !inFollowUp && !opts.state && effExit === 0 && sessionCard > 0) {
+    const step = capStepProcessed(t0);
+    const doneHandoffs = capHandoffs[sessionCard] || 0;
+    const act = capDecision({ ...CAPCFG, step, turn: TURN, freshTurn: capFreshTurn, handoffs: doneHandoffs, logged: !!capLogged[sessionCard] });
+    if (act === "log-exhausted") {
+      capLogged[sessionCard] = true;
+      const text = capExhaustedNote(sessionCard, CAPCFG.cap, step, doneHandoffs, CAPCFG.maxHandoffs);
+      log(`\x1b[33m${text}\x1b[0m`);
+      await api("/task/update", { id: sessionCard, note: text, by: SESSION }).catch(() => {});
+    } else if (act === "handoff") {
+      log(`\x1b[33mcontext cap: the last step processed ${step} > ${CAPCFG.cap}; #${sessionCard} hands off to a fresh session (${doneHandoffs + 1}/${CAPCFG.maxHandoffs})\x1b[0m`);
+      capHandoffs[sessionCard] = doneHandoffs + 1;
+      capArmed = { card: sessionCard, tokens: step };
+      inFollowUp = true;
+      try { await runTurn(capHandoffPrompt(sessionCard), false, "context-cap handoff"); }
+      finally { inFollowUp = false; }
+    }
+  }
   return effExit;
 }
 
@@ -1492,7 +1532,8 @@ async function resolveWakeCard(messages, { session }) {
         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],
-        cardTokens, cardStartedAt, budgetStop, budgetRetryAt };
+        cardTokens, cardStartedAt, budgetStop, budgetRetryAt,
+        capHandoffs, capLogged, capArmed, capFreshTurn };
       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}`); }
@@ -1784,7 +1825,10 @@ async function resolveWakeCard(messages, { session }) {
     // #10824: the LABEL is the binding, 0 included — a wake that binds nothing labels its turn 0
     // 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;
+    const newCard = !resumedAfterAsk && sessionCardForTurn > 0 && sessionCardForTurn !== sessionCard;
+    // #11855: the armed card's next wake starts a fresh session that reads the handoff note.
+    const capFresh = !resumedAfterAsk && !!capArmed && capArmed.card === sessionCardForTurn;
+    const fresh = newCard || capFresh;
     // #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
@@ -1797,17 +1841,19 @@ async function resolveWakeCard(messages, { session }) {
       budgetRetryAt = Date.now() + BUDGET_RETRY_MS;
       return;
     }
-    if (budgetStop && fresh) { budgetStop = null; budgetRetryAt = 0; }
-    if (fresh) { cardTokens = 0; cardStartedAt = Date.now(); }
+    if (budgetStop && newCard) { budgetStop = null; budgetRetryAt = 0; }
+    if (newCard) { cardTokens = 0; cardStartedAt = Date.now(); }
     sessionCard = card;
     const cited = [...new Set(wakeForTurn.flatMap(m => cardRefs(m.text)))];
-    const freshText = fresh
+    const capPointer = capFresh ? capPointerLine(sessionCardForTurn) : "";
+    if (capFresh) capArmed = null;
+    const freshText = capPointer + (newCard
       ? `\n(FRESH SESSION for card #${card} — you are not the session that worked earlier cards and you remember none of them. Read your card first: relay_board with card:${card}.)\n`
       // A wake naming several cards used to leave the seat guessing which one the machine believed
       // — the prompt named two and committed to neither. Say it, even when the session continues.
       : (card && cited.length > 1
         ? `\n(This turn is card #${card} — the wake cites ${cited.length} cards; the rest are context.)\n`
-        : "");
+        : ""));
     const prompt = composedTurn({
       wakeText, ctxText, againText: againText + freshText + baseText + dutyNudgeDirective(dutyPlan),
       tailText: "\nAct on what's addressed to you, then end your turn.\n\n",
@@ -1996,6 +2042,14 @@ async function resolveWakeCard(messages, { session }) {
         try {
           const { task } = await api(`/card?project=${encodeURIComponent(PROJ)}&id=${sessionCard}`);
           if (task && (task.status === "testing" || task.status === "done")) await janitorStop(`#${sessionCard} → ${task.status}`, sessionCard);
+          // #11855: a handoff was written and no wake is queued, so the card would idle; wake it
+          // ourselves into the fresh session unless the seat already moved it to testing/done.
+          else if (task && capArmed?.card === sessionCard && !pendingWake.length) {
+            pendingWake.push({ id: `cap-${sessionCard}-${capHandoffs[sessionCard] || 0}`, from: SESSION, to: SESSION, card: sessionCard, kind: "status", ts: Date.now(),
+              text: `#${sessionCard}: the context cap handoff note is written; continue the card in this fresh session.` });
+            savePending(pendingWake, pendingBcast);
+            log(`context cap: #${sessionCard} re-queued itself into a fresh session`);
+          }
         } catch {}
       }
       await notifyAssigners(assigners,

package/bin/drill-surface.mjs

@@ -219,6 +219,8 @@ const cleanup = () => {
   try { if (ws) herdr(["workspace", "close", ws.workspace_id], { json: true }); } catch {}
   if (fail > 0) { console.log(`failed-run evidence retained at ${world}`); return; }
   try { rmSync(world, { recursive: true, force: true }); } catch {}
+  // the pane's real claude wrote its transcript under ~/.claude/projects; it is the drill's too
+  try { rmSync(tDir, { recursive: true, force: true }); } catch {}
 };
 process.on("exit", cleanup);
 for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => {

package/hooks/sessionstart.mjs

@@ -300,10 +300,20 @@ try {
   // SAME project where it stands instead of starting blind. Cheap + LLM-free.
   try {
     const cu = await jget(`${url}/catchup?project=${encodeURIComponent(project)}`, session).catch(() => null);
-    sessionTitle = sessionTitleFrom(project, cu);   // "<project> · <current work>" for the picker/--resume/mobile
+    sessionTitle = sessionTitleFrom(project, cu);   // "<project> · <current work>" — computed on EVERY source; the picker/--resume/mobile read it
+    // #11853: only a FRESH start pays for the full board dump. A resumed session still carries the copy
+    // it got at startup and a compacted one carries the summary, so each `claude -c` was welding another
+    // 2-4K-token board snapshot into the transcript for good. Empty/unknown source fails open to the
+    // full block (a launcher that omits it is starting fresh); the pointer keeps the model staleness-honest.
+    const freshStart = !source || source === "startup" || source === "clear";   // /clear empties the context, so it needs the board too
     let gitlog = "";
-    try { gitlog = execSync(`git -C ${JSON.stringify(projectDir)} log --oneline -5 2>/dev/null`, { encoding: "utf8", timeout: 2500 }).trim(); } catch {}
-    if ((cu && cu.total > 0) || gitlog) {
+    if (freshStart) {
+      try { gitlog = execSync(`git -C ${JSON.stringify(projectDir)} log --oneline -5 2>/dev/null`, { encoding: "utf8", timeout: 2500 }).trim(); } catch {}
+    }
+    if (!freshStart && cu && cu.total > 0) {
+      additionalContext += `<trantor-board-pointer project="${sanitize(project)}" source="${sanitize(source)}">Board may have moved since this session last ran — one \`relay_board\` call gets the current board before you act on remembered cards.</trantor-board-pointer>\n`;
+      process.stderr.write(`[trantor] ${source}: board pointer only for ${project} — full catch-up skipped (#11853)\n`);
+    } else if (freshStart && ((cu && cu.total > 0) || gitlog)) {
       const line = (arr) => (arr || []).map(t => `#${t.id} ${String(t.title).slice(0, 72)}${t.assignee ? ` @${t.assignee}` : ""}`).join("\n  ");
       additionalContext += `<trantor-project-state project="${sanitize(project)}">\n`;
       additionalContext += `📋 **Catching up on the continuous "${sanitize(project)}" board** (this project's living record across all sessions — read it before starting; don't duplicate done work).\n`;

package/lib/context-cap.mjs

@@ -0,0 +1,23 @@
+// #11855: the card context cap. The runner reads the last step's processed input after a clean
+// card turn; this decides what to do with it. Pure: no I/O, no clock, no env.
+
+export const capConfig = (env = process.env) => ({
+  cap: Math.max(0, Number(env.TRANTOR_CARD_CONTEXT_CAP || 120_000)),
+  minSteps: Math.max(1, Number(env.TRANTOR_CARD_CAP_MIN_STEPS || 5)),
+  maxHandoffs: Math.max(1, Number(env.TRANTOR_CARD_CAP_MAX_HANDOFFS || 3)),
+});
+
+// -> "none" | "handoff" | "log-exhausted" (post the one card note) | "exhausted" (already posted)
+export function capDecision({ cap, minSteps, maxHandoffs, step, turn, freshTurn, handoffs = 0, logged = false }) {
+  if (!(cap > 0) || !Number.isFinite(step) || step <= cap) return "none";
+  if (handoffs >= maxHandoffs) return logged ? "exhausted" : "log-exhausted";
+  if (turn - freshTurn < minSteps) return "none";
+  return "handoff";
+}
+
+export const capHandoffPrompt = (card) => `this session's context passed the card context cap and a fresh session takes over card #${card} next. Add ONE note to card #${card} (relay_task_move keeping its current status) prefixed "HANDOFF (context cap):" holding: the goal in one line, the current state with the sha you verified at, the key decisions, the next steps, and the key files (paths). Then end your turn: the fresh session continues from your note.`;
+
+export const capPointerLine = (card) => `\n(FRESH SESSION for card #${card}: the previous session hit the context cap and left a card note prefixed "HANDOFF (context cap):". Read it with relay_board card:${card} and continue from it.)\n`;
+
+export const capExhaustedNote = (card, cap, step, handoffs, maxHandoffs) =>
+  `context cap: #${card} is past ${cap} processed tokens/step again after ${handoffs} handoffs (max ${maxHandoffs}); carrying on, CARD_TOKEN_BUDGET stays the backstop (last step ${step})`;

package/lib/turn-usage.mjs

@@ -3,7 +3,7 @@
 // in each provider's OWN session record; read them there, never from stdout.
 // Usage shape: { input, output, cacheRead, cacheWrite } — null means "could not read", never 0.
 import { spawnSync } from "node:child_process";
-import { readdirSync, statSync } from "node:fs";
+import { closeSync, openSync, readdirSync, readSync, realpathSync, statSync } from "node:fs";
 import { join } from "node:path";
 
 export function usageTotal(u) {
@@ -114,3 +114,131 @@ export function dshTurnUsage(sessionsRoot, cwd, sinceMs, untilMs, run = spawnSyn
   }
   return found ? sum : null;
 }
+
+// ---- #11855: the LAST step's processed input, read from each harness's own session record ----
+// null = no readable record; the card context cap never trips blind.
+
+// Processed input a step re-read: fresh input + cache read + cache write.
+export const processedInput = (u) => (u ? (u.input || 0) + (u.cacheRead || 0) + (u.cacheWrite || 0) : 0);
+
+const readdirMaybe = (d) => { try { return readdirSync(d); } catch { return []; } };
+const inWindow = (t, sinceMs) => Number.isFinite(t) && t >= sinceMs;
+const realOr = (p) => { try { return realpathSync(p); } catch { return String(p || ""); } };
+
+// Last `maxBytes` of a file as lines (a cut first line dropped): usage rows sit at the end.
+function tailLines(path, maxBytes = 262144) {
+  let fd;
+  try { fd = openSync(path, "r"); } catch { return []; }
+  try {
+    const size = statSync(path).size;
+    const off = Math.max(0, size - maxBytes);
+    const buf = Buffer.alloc(Math.min(size, maxBytes));
+    readSync(fd, buf, 0, buf.length, off);
+    const lines = buf.toString("utf8").split("\n");
+    if (off > 0) lines.shift();
+    return lines;
+  } catch { return []; }
+  finally { try { closeSync(fd); } catch {} }
+}
+
+// codex: ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl, local-date dirs. A resumed session keeps
+// appending to its ORIGINAL file, so the last `lookbackDays` of dirs are scanned, and the file is
+// matched to the seat by the session_meta record's cwd. input_tokens already includes the cached
+// part, so it is split to keep processedInput from counting the cache twice.
+export function codexRolloutCwd(file) {
+  let fd;
+  try { fd = openSync(file, "r"); } catch { return null; }
+  try {
+    const buf = Buffer.alloc(8192);
+    const m = buf.toString("utf8", 0, readSync(fd, buf, 0, 8192, 0)).match(/^\{"timestamp":"[^"]*"[^\n]*?"type":"session_meta"[^\n]*?"cwd":("(?:[^"\\]|\\.)*")/);
+    return m ? JSON.parse(m[1]) : null;
+  } catch { return null; }
+  finally { try { closeSync(fd); } catch {} }
+}
+export function codexStepInput(sessionsRoot, sinceMs, cwd, { nowMs = Date.now(), lookbackDays = 14 } = {}) {
+  if (!sessionsRoot || !cwd || !Number.isFinite(sinceMs)) return null;
+  const want = realOr(cwd), pad = (n) => String(n).padStart(2, "0");
+  let newest = null;
+  for (let i = -1; i < lookbackDays; i++) {
+    const day = new Date(nowMs - i * 86400000);
+    const dir = join(sessionsRoot, String(day.getFullYear()), pad(day.getMonth() + 1), pad(day.getDate()));
+    for (const n of readdirMaybe(dir)) {
+      if (!n.startsWith("rollout-") || !n.endsWith(".jsonl")) continue;
+      const f = join(dir, n);
+      let mt; try { mt = statSync(f).mtimeMs; } catch { continue; }
+      if (mt < sinceMs || (newest && mt <= newest.mt)) continue;
+      const c = codexRolloutCwd(f);
+      if (c && realOr(c) === want) newest = { f, mt };
+    }
+  }
+  if (!newest) return null;
+  let last = null;
+  for (const line of tailLines(newest.f)) {
+    const s = line.trim(); if (!s) continue;
+    let ev; try { ev = JSON.parse(s); } catch { continue; }
+    if (ev?.payload?.type !== "token_count") continue;
+    if (!inWindow(Date.parse(ev.timestamp || ""), sinceMs)) continue;
+    const u = ev.payload?.info?.last_token_usage;
+    if (u) last = u;
+  }
+  if (!last) return null;
+  const inp = field(last.input_tokens), cached = field(last.cached_input_tokens), out = field(last.output_tokens);
+  if (inp === null || cached === null || out === null) return null;
+  return { input: Math.max(0, inp - cached), output: out, cacheRead: cached, cacheWrite: 0 };
+}
+
+// kimi: ~/.kimi-code/sessions/<wd>/<sid>/agents/main/wire.jsonl, found by the runner's sid (the
+// printed `kimi -r <sid>` id) so a sibling seat's wire is never read. One usage.record per step.
+export function kimiStepInput(sessionsRoot, sid, sinceMs) {
+  if (!sessionsRoot || !sid || !Number.isFinite(sinceMs)) return null;
+  let file = null;
+  for (const wd of readdirMaybe(sessionsRoot)) {
+    const f = join(sessionsRoot, wd, String(sid), "agents", "main", "wire.jsonl");
+    try { if (statSync(f).isFile()) { file = f; break; } } catch {}
+  }
+  if (!file) return null;
+  let last = null;
+  for (const line of tailLines(file)) {
+    const s = line.trim(); if (!s) continue;
+    let ev; try { ev = JSON.parse(s); } catch { continue; }
+    if (ev?.type !== "usage.record" || !ev.usage) continue;
+    if (!inWindow(Number(ev.time), sinceMs)) continue;
+    last = ev.usage;
+  }
+  if (!last) return null;
+  const inp = field(last.inputOther), cr = field(last.inputCacheRead),
+    cw = field(last.inputCacheCreation), out = field(last.output);
+  if ([inp, cr, cw, out].some(v => v === null)) return null;
+  return { input: inp, output: out, cacheRead: cr, cacheWrite: cw };
+}
+
+// claude: ~/.claude/projects/<cwd-slug>/*.jsonl (claudeTranscriptDir names the seat's dir), the
+// newest transcript touched in the window; assistant rows carry message.usage. Subagent rows
+// (isSidechain) are skipped. A 1MB tail, since an assistant line can carry long text.
+export function claudeStepInput(transcriptDir, sinceMs) {
+  if (!transcriptDir || !Number.isFinite(sinceMs)) return null;
+  let newest = null;
+  for (const n of readdirMaybe(transcriptDir)) {
+    if (!n.endsWith(".jsonl")) continue;
+    const f = join(transcriptDir, n);
+    let mt; try { mt = statSync(f).mtimeMs; } catch { continue; }
+    if (mt < sinceMs) continue;
+    if (!newest || mt > newest.mt) newest = { f, mt };
+  }
+  if (!newest) return null;
+  let last = null;
+  for (const line of tailLines(newest.f, 1048576)) {
+    const s = line.trim(); if (!s) continue;
+    let ev; try { ev = JSON.parse(s); } catch { continue; }
+    if (ev?.type !== "assistant" || ev.isSidechain) continue;
+    const u = ev.message?.usage;
+    if (!u) continue;
+    if (!inWindow(Date.parse(ev.timestamp || ""), sinceMs)) continue;
+    last = u;
+  }
+  if (!last) return null;
+  const inp = field(last.input_tokens), cr = field(last.cache_read_input_tokens),
+    cw = field(last.cache_creation_input_tokens), out = field(last.output_tokens);
+  if ([inp, cr, cw, out].some(v => v === null)) return null;
+  return { input: inp, output: out, cacheRead: cr, cacheWrite: cw };
+}

package/package.json

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