crewforth 3.1.1 → 3.2.0-rc.10

package/kit/studio/server/lib/remote.js

@@ -0,0 +1,185 @@
+// remote.js — read-only viewers.
+//
+// The panel's own token can start a session and answer a tool call. Handing that token to a phone hands the phone
+// all of it. A viewer token is the smaller thing: it reads what the panel reads and can change nothing. The server
+// decides that, not the page — a viewer's request is refused here before any handler sees it.
+//
+// THE WAY IN FROM ANOTHER DEVICE IS THE SAME WI-FI. While at least one viewer is live, the server also listens on
+// this machine's Wi-Fi address (index.js), and there it answers a viewer's token and nothing else: the panel's own
+// token is not accepted from the network at all. With no viewer, nothing listens beyond 127.0.0.1.
+//
+// A viewer lasts EIGHT HOURS, or until it is revoked, or until the server stops — whichever comes first. Kept in
+// memory, like the owner's token: a link that survived a restart would be a credential nobody remembers handing out.
+// An expired token is remembered as expired (not as unknown) so the phone can say "Session expired" rather than
+// "no access", and only for as long as the server runs.
+//
+// TRANSCRIPTS ARE HIDDEN by default: a viewer made without `transcripts` is answered with no text that came from a
+// transcript (lib/redact.js does that on the server; the page hiding it would not be enough).
+import { randomUUID } from 'node:crypto';
+
+export const MAX_VIEWERS = 8;
+export const VIEWER_TTL_MS = 8 * 60 * 60 * 1000;
+const LABEL_MAX = 40;
+const LOG_MAX = 200;
+
+const viewers = new Map();          // id -> viewer
+const byToken = new Map();          // token -> viewer
+const expired = new Map();          // token -> label, for "Session expired"
+const log = [];                     // what happened to viewers' links, newest last
+
+let clock = () => Date.now();
+let onChange = () => {};
+let note = () => {};
+
+/** For the self-check: a clock it can move (eight hours are not waited for). */
+export function _setClock(fn) { clock = fn ?? (() => Date.now()); }
+/** index.js opens and closes the Wi-Fi listener when the number of live viewers changes. */
+export function onViewersChange(fn) { onChange = fn ?? (() => {}); }
+/** Where a log line also goes (the server's own output). */
+export function onLog(fn) { note = fn ?? (() => {}); }
+
+function record(entry) {
+  const e = { at: clock(), ...entry };
+  log.push(e);
+  if (log.length > LOG_MAX) log.splice(0, log.length - LOG_MAX);
+  note(e);
+}
+
+const publicOf = (v) => ({
+  id: v.id,
+  label: v.label,
+  createdAt: v.createdAt,
+  expiresAt: v.expiresAt,
+  transcripts: v.transcripts,
+  lastSeenAt: v.lastSeenAt,
+  requests: v.requests,
+  agent: v.agent,
+  open: v.conns.size,
+  addresses: [...v.addresses],
+});
+
+/** Make a viewer. The token is in this answer and in no later one. */
+export function addViewer(label, { transcripts = false } = {}) {
+  sweep();
+  if (viewers.size >= MAX_VIEWERS) {
+    return { ok: false, reason: `${MAX_VIEWERS} viewers already; revoke one first` };
+  }
+  const named = typeof label === 'string' ? label.replace(/\s+/g, ' ').trim().slice(0, LABEL_MAX) : '';
+  const now = clock();
+  const v = {
+    id: randomUUID().slice(0, 8),
+    label: named || `Viewer ${viewers.size + 1}`,
+    token: randomUUID(),
+    createdAt: now,
+    expiresAt: now + VIEWER_TTL_MS,
+    transcripts: transcripts === true,
+    lastSeenAt: null,
+    requests: 0,
+    agent: null,
+    conns: new Set(),
+    addresses: new Set(),
+  };
+  viewers.set(v.id, v);
+  byToken.set(v.token, v);
+  record({ event: 'added', viewer: v.label, transcripts: v.transcripts });
+  onChange(viewers.size);
+  return { ok: true, viewer: { ...publicOf(v), token: v.token } };
+}
+
+export function listViewers() {
+  sweep();
+  return [...viewers.values()].map(publicOf);
+}
+
+export function liveCount() {
+  sweep();
+  return viewers.size;
+}
+
+export function remoteLog(n = 50) {
+  return log.slice(-n);
+}
+
+/** The viewer this token belongs to, if it is live; `{ expired: label }` if it was one and its eight hours are up. */
+export function viewerByToken(token) {
+  if (typeof token !== 'string') return null;
+  const v = byToken.get(token);
+  if (v && clock() >= v.expiresAt) { end(v, 'expired'); return { expired: v.label }; }
+  if (v) return v;
+  if (expired.has(token)) return { expired: expired.get(token) };
+  return null;
+}
+
+function end(v, why) {
+  viewers.delete(v.id);
+  byToken.delete(v.token);
+  if (why === 'expired') expired.set(v.token, v.label);
+  for (const res of v.conns) { try { res.destroy(); } catch { /* already gone */ } }
+  v.conns.clear();
+  record({ event: why, viewer: v.label });
+  onChange(viewers.size);
+}
+
+/** End every viewer whose eight hours are up. Called on every read of the list and by index.js's timer. */
+export function sweep() {
+  const now = clock();
+  for (const v of [...viewers.values()]) if (now >= v.expiresAt) end(v, 'expired');
+}
+
+/**
+ * Take a viewer's access back. Its token stops working with this call, and a stream it holds open is closed:
+ * a revoke that left the live graph running on the phone would be a revoke in name only.
+ */
+export function revokeViewer(id) {
+  const v = viewers.get(id);
+  if (!v) return { ok: true, revoked: false };
+  end(v, 'revoked');
+  return { ok: true, revoked: true };
+}
+
+/** Count a viewer's request and remember its response for as long as it is open. A new address is logged once. */
+export function noteRequest(v, req, res) {
+  v.requests += 1;
+  v.lastSeenAt = clock();
+  const ua = req.headers['user-agent'];
+  v.agent = typeof ua === 'string' ? ua.slice(0, 160) : null;
+  const ip = req.socket?.remoteAddress ?? null;
+  if (ip && !v.addresses.has(ip)) {
+    v.addresses.add(ip);
+    record({ event: 'connected', viewer: v.label, ip, over: req.crewLan ? 'wifi' : 'loopback', result: 'ok' });
+  }
+  v.conns.add(res);
+  res.on('close', () => v.conns.delete(res));
+}
+
+/**
+ * A request that was turned away: logged with who it claimed to be, from where, and why. The same refusal again
+ * (same viewer, address, path and answer) is counted on its entry rather than written again, so a page that keeps
+ * asking cannot push everything else out of the log.
+ */
+export function noteRefusal(req, { viewer = null, status, reason }) {
+  const e = { event: 'refused', viewer, ip: req.socket?.remoteAddress ?? null, over: req.crewLan ? 'wifi' : 'loopback',
+    result: `${status} ${reason}`, path: String(req.url ?? '').split('?')[0].slice(0, 120) };
+  const same = log.findLast((x) => x.event === 'refused' && x.viewer === e.viewer && x.ip === e.ip && x.path === e.path && x.result === e.result);
+  if (same) { same.count = (same.count ?? 1) + 1; same.lastAt = clock(); return; }
+  record(e);
+}
+
+/**
+ * What a viewer may ask for: a GET of anything the panel reads, and nothing about viewers themselves.
+ * The list of viewers is the owner's; a viewer that could read it could count who else is watching.
+ */
+export function viewerMay(method, pathname) {
+  if (method !== 'GET') return { ok: false, reason: 'read-only token: GET only' };
+  if (pathname === '/api/remote' || pathname.startsWith('/api/remote/')) {
+    return { ok: false, reason: 'read-only token: viewers are managed from the machine itself' };
+  }
+  return { ok: true };
+}
+
+/** For the self-check: start from nothing. */
+export function _reset() {
+  for (const v of [...viewers.values()]) end(v, 'revoked');
+  expired.clear();
+  log.length = 0;
+}

package/kit/studio/server/lib/session.js

@@ -290,7 +290,7 @@ class OwnedSession {
  * answer is "yes": an unreadable fleet must not be the reason two processes
  * end up writing one transcript.
  */
-async function isHeldOpen(id) {
+export async function isHeldOpen(id) {
   try {
     const fleet = await getFleet();
     const rows = fleet?.sessions ?? fleet ?? [];

package/kit/studio/server/lib/terminal.js

@@ -17,21 +17,60 @@ function q(s) {
   return `'${String(s).replace(/'/g, `'\\''`)}'`;
 }
 
+/** PowerShell literal string: a quote is doubled, nothing else is special inside one. */
+function psq(s) {
+  return `'${String(s).replace(/'/g, "''")}'`;
+}
+
+/**
+ * A session id is a UUID. It comes from the URL, and on Windows it ends up in a line cmd.exe interprets, where a
+ * quote is not a quote (cmd hands `'` to the program as part of the id) and `&` starts a second command. So
+ * nothing is built for anything else, and an id that passes needs no quoting in any shell.
+ */
+const SESSION_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function isSessionId(s) {
+  return typeof s === 'string' && SESSION_ID.test(s);
+}
+
 /** AppleScript string literal: backslashes and quotes, nothing else. */
 function osaQuote(s) {
   return `"${String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
 }
 
+/**
+ * The command that opens the session in the Claude Desktop app again (`claude --desktop`, CLI 2.1.299), from its
+ * own directory: `--resume <id>` looks for the session among that directory's. On Windows it is a PowerShell line
+ * (5.1 and 7; Windows Terminal opens PowerShell): cmd needs `&&` and does not take single quotes, PowerShell 5.1
+ * rejects `&&`, and no one line works in both. `shell` says which, so the panel can say so.
+ */
+export function desktopLine({ cwd, sessionId, platform = process.platform }) {
+  if (!isSessionId(sessionId)) return null;
+  if (platform === 'win32') {
+    return { shell: 'PowerShell', line: `Set-Location -LiteralPath ${psq(cwd)}; claude --desktop --resume ${sessionId}` };
+  }
+  return { shell: 'sh', line: `cd ${q(cwd)} && claude --desktop --resume ${q(sessionId)}` };
+}
+
 /**
  * Build the launch for this platform.
  * Returns null when nothing here knows how to open a terminal, so the caller
  * can say so rather than fail silently.
  */
-export function plan({ cwd, sessionId, command }) {
-  const inner = command ?? `claude --resume ${q(sessionId)}`;
+export function plan({ cwd, sessionId, platform = process.platform }) {
+  if (!isSessionId(sessionId)) return null;
+
+  if (platform === 'win32') {
+    // Windows Terminal when present, the console host otherwise. wt sets the directory itself; what runs inside is
+    // cmd.exe, so the line shown is a cmd line: double quotes, `cd /d` for another drive, and the id bare (a UUID).
+    const inner = `claude --resume ${sessionId}`;
+    const wt = ['wt.exe', '-d', cwd, 'cmd.exe', '/k', inner];
+    return { platform: 'win32', via: 'wt.exe', shell: 'cmd', line: `cd /d "${cwd}" && ${inner}`, argv: wt };
+  }
+
+  const inner = `claude --resume ${q(sessionId)}`;
   const line = `cd ${q(cwd)} && ${inner}`;
 
-  if (process.platform === 'darwin') {
+  if (platform === 'darwin') {
     return {
       platform: 'darwin',
       via: 'Terminal.app',
@@ -41,12 +80,6 @@ export function plan({ cwd, sessionId, command }) {
     };
   }
 
-  if (process.platform === 'win32') {
-    // Windows Terminal when present, the console host otherwise.
-    const wt = ['wt.exe', '-d', cwd, 'cmd.exe', '/k', inner];
-    return { platform: 'win32', via: 'wt.exe', line, argv: wt };
-  }
-
   // Linux and the rest: whichever emulator is actually installed. Names are
   // tried by running them, not by resolving them — a name on PATH that fails
   // to start is the failure mode this ordering exists for.
@@ -57,14 +90,19 @@ export function plan({ cwd, sessionId, command }) {
     ['xfce4-terminal', ['--working-directory', cwd, '-e', `bash -lc ${q(line)}`]],
     ['xterm', ['-e', 'bash', '-lc', line]],
   ];
-  return { platform: process.platform, via: 'candidates', line, candidates };
+  return { platform, via: 'candidates', line, candidates };
 }
 
-/** Launch it, detached, and report what was run. */
-export function open({ cwd, sessionId, command }) {
+/**
+ * Launch it, detached, and report what was run. What runs is always `claude --resume <id>`: the route used to take a
+ * `command` from the request body and run it in place of that, with no id check, and the panel never sent one. An
+ * unused way to run anything in a terminal, behind a token that remote access puts on the network, was removed.
+ */
+export function open({ cwd, sessionId }) {
   if (!cwd || !fs.existsSync(cwd)) return { ok: false, reason: `no such directory: ${cwd}` };
 
-  const p = plan({ cwd, sessionId, command });
+  if (!isSessionId(sessionId)) return { ok: false, reason: `not a session id: ${sessionId}` };
+  const p = plan({ cwd, sessionId });
   if (!p) return { ok: false, reason: `no terminal launcher known for ${process.platform}` };
 
   const attempts = p.argv ? [p.argv] : p.candidates.map(([bin, args]) => [bin, ...args]);

package/kit/studio/server/lib/transcript.js

@@ -98,3 +98,35 @@ export function contextFill(records) {
   }
   return total;
 }
+
+/**
+ * What the context is made of since the last compaction: the share of its text that is tool output, and how many
+ * times the session was compacted, with the last one's tokens before and after. Measured in characters of the main
+ * session's records (text, a tool call's input, a tool's result), not tokens: the transcript keeps no per-block
+ * token count. A compaction is the transcript's own `compact_boundary` record.
+ */
+export function contextMix(records) {
+  let start = 0; let compactions = 0; let last = null;
+  records.forEach((r, i) => {
+    if (r?.isSidechain !== true && r?.type === 'system' && r?.subtype === 'compact_boundary') { start = i + 1; compactions += 1; last = r.compactMetadata ?? null; }
+  });
+  const size = (b) => {
+    if (typeof b === 'string') return b.length;
+    if (b?.type === 'text') return String(b.text ?? '').length;
+    if (b?.type === 'tool_use') return JSON.stringify(b.input ?? {}).length;
+    if (b?.type === 'tool_result') return typeof b.content === 'string' ? b.content.length : (Array.isArray(b.content) ? b.content.reduce((n, x) => n + (x?.type === 'text' ? String(x.text ?? '').length : 0), 0) : 0);
+    return 0;
+  };
+  let tool = 0; let all = 0;
+  for (let i = start; i < records.length; i += 1) {
+    const r = records[i];
+    if (r?.isSidechain === true || (r?.type !== 'user' && r?.type !== 'assistant')) continue;
+    const c = r?.message?.content;
+    for (const b of Array.isArray(c) ? c : [c]) { const n = size(b); all += n; if (b?.type === 'tool_result') tool += n; }
+  }
+  return {
+    toolShare: all ? Math.round((100 * tool) / all) : null,
+    compactions,
+    lastCompact: last ? { trigger: last.trigger ?? null, before: last.preTokens ?? null, after: last.postTokens ?? null } : null,
+  };
+}

package/kit/studio/server/lib/usage.js

@@ -4,25 +4,41 @@
 // usage. Measured on one machine before this was written: 23,867 assistant records carried usage, for 11,245
 // responses, and every repeat carried the same numbers. So a response is counted once, by its message id — and
 // once across the session's files too, which is what keeps an agent's tokens from being added twice.
+//
+// An advisor call (the advisor tool: the model consults a second one mid-response) is not in that usage. The API
+// keeps it out of the top-level fields, which are the executor's, and lists it in `usage.iterations[]` as an
+// `advisor_message` entry with its own `model`. It is billed at that model's rates, so it is priced on its own.
+// Measured on a real advisor session: the entry is written to the transcript, and repeated, like the rest of the
+// usage, on every record of the response; the message id above counts it once.
 
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 
 import { readAll } from './transcript.js';
 import { agentMetaFiles } from './projects.js';
-import { costOf, SOURCE } from './pricing.js';
+import { costOf, SOURCE, NORMAL_TIER_MODEL } from './pricing.js';
 
 const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : 0);
 
+/**
+ * A usage's cache writes by kind. A write the split does not account for is the 5-minute kind: that is the default,
+ * and the cheaper of the two. The split can fall short of the total: measured on a real response, the split said
+ * 12,400 one-hour and 0 five-minute against a total of 12,670, and the 270 missing were billed as five-minute
+ * writes (its iterations listed them so, and Claude Code's own cost for the session matched only with them in).
+ */
+function writesOf(u) {
+  const split = u.cache_creation && typeof u.cache_creation === 'object' ? u.cache_creation : null;
+  const w1h = num(split?.ephemeral_1h_input_tokens);
+  const w5m = num(split?.ephemeral_5m_input_tokens);
+  return { cacheWrite5m: w5m + Math.max(0, num(u.cache_creation_input_tokens) - w5m - w1h), cacheWrite1h: w1h };
+}
+
 /** One response's usage, in the shape pricing.js prices. Null when the record carries none. */
 export function usageOfRecord(r) {
   const m = r?.type === 'assistant' ? r.message : null;
   const u = m?.usage;
   if (!u || typeof u !== 'object') return null;
-  const split = u.cache_creation && typeof u.cache_creation === 'object' ? u.cache_creation : null;
-  const w1h = num(split?.ephemeral_1h_input_tokens);
-  // With no split recorded, a cache write is the 5-minute kind: that is the default, and the cheaper of the two.
-  const w5m = split ? num(split.ephemeral_5m_input_tokens) : num(u.cache_creation_input_tokens);
+  const { cacheWrite5m: w5m, cacheWrite1h: w1h } = writesOf(u);
   return {
     id: typeof m.id === 'string' ? m.id : null,
     model: typeof m.model === 'string' ? m.model : null,
@@ -33,9 +49,28 @@ export function usageOfRecord(r) {
     cacheRead: num(u.cache_read_input_tokens),
     fast: u.speed === 'fast',
     usOnly: u.inference_geo === 'us',
+    advisor: advisorCallsOf(u),
   };
 }
 
+/** The advisor calls one response's usage lists, each in the shape pricing.js prices: [] when it made none. */
+export function advisorCallsOf(u) {
+  const out = [];
+  for (const it of Array.isArray(u?.iterations) ? u.iterations : []) {
+    if (it?.type !== 'advisor_message') continue;
+    out.push({
+      model: typeof it.model === 'string' ? it.model : null,
+      input: num(it.input_tokens),
+      output: num(it.output_tokens),
+      ...writesOf(it),
+      cacheRead: num(it.cache_read_input_tokens),
+      fast: false,
+      usOnly: u.inference_geo === 'us',
+    });
+  }
+  return out;
+}
+
 const KINDS = ['input', 'output', 'cacheWrite', 'cacheRead'];
 
 /** One running sum: tokens by kind, what they cost, and which models had no price. */
@@ -43,25 +78,29 @@ class Tally {
   constructor() {
     this.tokens = { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 };
     this.usd = 0;
+    this.usdAtNormal = 0;     // the same tokens at NORMAL_TIER_MODEL's price
     this.responses = 0;
     this.unpriced = new Set();
   }
 
-  take(u, usd) {
-    this.responses += 1;
+  /** @param response  false for an advisor call: its tokens and cost are added, but it is part of a response, not one. */
+  take(u, usd, atNormal = null, response = true) {
+    if (response) this.responses += 1;
     this.tokens.input += u.input;
     this.tokens.output += u.output;
     this.tokens.cacheWrite += u.cacheWrite5m + u.cacheWrite1h;
     this.tokens.cacheRead += u.cacheRead;
     if (usd === null) this.unpriced.add(u.model ?? 'unknown model');
     else this.usd += usd;
+    if (atNormal !== null) this.usdAtNormal += atNormal;
   }
 
   /**
    * `fresh` is what was sent and written for the first time: input, output and cache writes. `cacheRead` is the
    * same context read back from the cache on every later response, which is why it dwarfs the rest in a long
    * session and is kept out of the headline. `cost` is null when any of the tokens came from a model the price
-   * table has no row for — a sum that leaves some of them out would read as the whole.
+   * table has no row for — a sum that leaves some of them out would read as the whole. `costAtNormal` is the same
+   * tokens at NORMAL_TIER_MODEL's list price, null under the same rule.
    */
   result() {
     const t = this.tokens;
@@ -69,6 +108,7 @@ class Tally {
       tokens: { ...t, fresh: t.input + t.output + t.cacheWrite, total: KINDS.reduce((a, k) => a + t[k], 0) },
       responses: this.responses,
       cost: this.unpriced.size ? null : this.usd,
+      costAtNormal: this.unpriced.size ? null : this.usdAtNormal,
       unpriced: [...this.unpriced].sort(),
     };
   }
@@ -80,6 +120,9 @@ export class Usage {
     this.all = new Tally();
     this.who = new Map();      // 'session', or an agent's id -> Tally
     this.model = new Map();    // model id -> Tally
+    this.advisor = new Tally(); // the advisor calls alone, one take per call
+    this.advisorModels = new Map(); // advisor model id -> Tally
+    this.advisorWho = new Map();    // 'session' or an agent's id -> Tally of its advisor calls alone
     this.first = null;         // the earliest and the latest record of any file added
     this.last = null;
   }
@@ -104,11 +147,22 @@ export class Usage {
       const u = usageOfRecord(r);
       if (!u) continue;
       if (u.id) { if (this.seen.has(u.id)) continue; this.seen.add(u.id); }
-      if (!(u.input + u.output + u.cacheWrite5m + u.cacheWrite1h + u.cacheRead)) continue;   // a record the harness made up carries no tokens
-      const usd = costOf(u);
-      this.all.take(u, usd);
-      this.#tally(this.who, who === 'session' && r.isSidechain === true ? 'agents:inline' : who).take(u, usd);
-      this.#tally(this.model, u.model ?? 'unknown model').take(u, usd);
+      if (!(u.input + u.output + u.cacheWrite5m + u.cacheWrite1h + u.cacheRead) && !u.advisor.length) continue;   // a record the harness made up carries no tokens
+      const mine = this.#tally(this.who, who === 'session' && r.isSidechain === true ? 'agents:inline' : who);
+      // The response, then each advisor call it made, priced at the advisor's own model.
+      for (const x of [u, ...u.advisor]) {
+        const usd = costOf(x);
+        const atNormal = costOf({ ...x, model: NORMAL_TIER_MODEL });
+        const own = x === u;
+        this.all.take(x, usd, atNormal, own);
+        mine.take(x, usd, atNormal, own);
+        this.#tally(this.model, x.model ?? 'unknown model').take(x, usd, atNormal, own);
+        if (!own) {   // here each call is one
+          this.advisor.take(x, usd, atNormal);
+          this.#tally(this.advisorWho, who === 'session' && r.isSidechain === true ? 'agents:inline' : who).take(x, usd, atNormal);
+          this.#tally(this.advisorModels, x.model ?? 'unknown model').take(x, usd, atNormal);
+        }
+      }
     }
     return this;
   }
@@ -134,6 +188,9 @@ export class Usage {
       ...all,
       models: [...this.model.keys()].filter((m) => !all.unpriced.includes(m)).sort(),
       parts: { session: (this.who.get('session') ?? new Tally()).result(), agents: agents.result() },
+      // Null when no advisor call is recorded: a session without one has no advisor line, not a zero.
+      advisor: this.advisor.responses ? { ...this.advisor.result(), calls: this.advisor.responses } : null,
+      advisorModels: Object.fromEntries([...this.advisorModels].map(([m, t]) => [m, { ...t.result(), calls: t.responses }])),
       byModel: Object.fromEntries([...this.model].map(([m, t]) => [m, t.result()]).sort((a, b) => b[1].tokens.total - a[1].tokens.total)),
       startedAt: this.first,
       lastAt: this.last,
@@ -192,7 +249,10 @@ export async function sessionUsage(session) {
   for (const [who, t] of usage.who) {
     if (who === 'session' || who.startsWith('agents:')) continue;
     const r = t.result();
-    agents[who] = { fresh: r.tokens.fresh, cacheRead: r.tokens.cacheRead, cost: r.cost };
+    // What of it was the advisor: its calls and their cost, already in `cost`. Zero calls when it consulted none.
+    const adv = usage.advisorWho.get(who)?.result() ?? null;
+    agents[who] = { fresh: r.tokens.fresh, cacheRead: r.tokens.cacheRead, cost: r.cost, costAtNormal: r.costAtNormal,
+      advisorCalls: adv?.responses ?? 0, advisorCost: adv?.cost ?? null };
   }
   return { ...withTimes(usage, records), agents };
 }