@crievo/omni 0.1.6 → 0.1.8

package/tools/cost.mjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/* What the agents spent on the videos: per video, stage, fork and model.
+
+     cost.mjs                     summary of every session (--days N for the last N days)
+     cost.mjs video <slug>        one video: stages, forks, turns
+     cost.mjs turns [--n 20]      the latest turns, one line each
+     cost.mjs ... --json          the same as data (what the studio reads)
+
+   Read-only: it reads .sessions/ (the studio's claude stream-json) and keeps a cache in .cost/.
+   The values are the API list price Claude Code itself reports (`total_cost_usd`), which is what
+   the usage costs even on a subscription. The logic is tools/lib/cost.mjs. */
+
+import { readTurns, summarize } from "./lib/cost.mjs";
+
+const args = process.argv.slice(2);
+const flag = name => {
+  const i = args.indexOf(name);
+  if (i < 0) return null;
+  const [v] = args.splice(i, args[i + 1]?.startsWith("--") || args[i + 1] == null ? 1 : 2).slice(1);
+  return v ?? true;
+};
+const json = !!flag("--json");
+const days = Number(flag("--days")) || null;
+const nTurns = Number(flag("--n")) || 20;
+const cmd = args[0] && !args[0].startsWith("--") ? args.shift() : "summary";
+
+const STAGE = {
+  orchestrator: "orquestrador",
+  "av-script": "roteiro",
+  "av-motion": "motion (roteiro + base)",
+  compose: "composição (1 fork por cena)",
+  wireframe: "wireframes (1 fork por cena)",
+  "av-narration": "narração",
+  "av-voice": "voz",
+  "av-render": "render",
+  "av-captions": "legendas",
+  "av-assemble": "montagem",
+  "av-editor": "editor",
+  "av-reference": "estilo visual",
+  "av-thumbnail": "thumbnail",
+  "av-preview": "prévia (aposentada)",
+  other: "outros",
+};
+const KIND = { video: "vídeos", edit: "editor", reference: "estilos visuais", analysis: "análise", omni: "Omni" };
+const usd = n => `US$ ${n.toLocaleString("pt-BR", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+const pad = (s, n) => String(s).padEnd(n);
+const lpad = (s, n) => String(s).padStart(n);
+const pct = (n, t) => (t ? `${Math.round((n / t) * 100)}%` : "—");
+const sorted = o => Object.entries(o).sort((a, b) => b[1] - a[1]);
+
+function table(title, entries, total, label = k => k) {
+  console.log(`\n${title}`);
+  for (const [k, v] of entries) console.log(`  ${pad(label(k), 34)} ${lpad(usd(v), 13)}  ${lpad(pct(v, total), 4)}`);
+}
+
+const rows = await readTurns({ since: days ? Date.now() - days * 86_400_000 : null });
+
+if (cmd === "turns") {
+  const last = rows.slice(-nTurns);
+  if (json) console.log(JSON.stringify(last, null, 2));
+  else
+    for (const r of last)
+      console.log(
+        `${r.at.slice(0, 16).replace("T", " ")}  ${pad(r.type, 9)} ${pad(r.target.slice(0, 38), 38)} t${r.n} ${lpad(r.total == null ? "sem custo (Codex)" : usd(r.total) + (r.partial ? " (parcial)" : ""), 22)}  ${r.subagents} forks`,
+      );
+} else if (cmd === "video") {
+  const slug = args[0];
+  if (!slug) {
+    console.error("erro: diga o vídeo — cost.mjs video <slug>");
+    process.exit(2);
+  }
+  const mine = rows.filter(r => r.target === slug || r.target === slug.replace(/^videos\//, "").replace(/\/$/, ""));
+  if (!mine.length) {
+    console.error(`erro: nenhuma sessão registrada para ${slug}`);
+    process.exit(1);
+  }
+  const s = summarize(mine);
+  if (json) console.log(JSON.stringify({ ...s, turns_list: mine.map(({ groups, ...r }) => r) }, null, 2));
+  else {
+    console.log(
+      `${slug}: ${usd(s.total)} em ${s.turns} turnos${s.partial ? ` (${s.partial} em andamento ou interrompido, estimado)` : ""}`,
+    );
+    table("por etapa", sorted(s.by_stage), s.total, k => STAGE[k] ?? k);
+    table("por modelo", sorted(s.by_model), s.total);
+    console.log("\nmaiores forks");
+    for (const f of s.top_forks.slice(0, 8))
+      console.log(`  ${pad(f.label.slice(0, 34), 34)} ${lpad(usd(f.cost), 13)}  ${f.messages} mensagens`);
+    console.log("\nturnos");
+    for (const r of mine)
+      console.log(
+        `  t${r.n} ${r.at.slice(0, 16).replace("T", " ")}  ${pad(r.origin ?? "", 8)} ${lpad(r.total == null ? "—" : usd(r.total), 13)}  ${r.subagents} forks`,
+      );
+  }
+} else {
+  const s = summarize(rows);
+  if (json) console.log(JSON.stringify(s, null, 2));
+  else {
+    console.log(
+      `${usd(s.total)} em ${s.turns} turnos de ${s.sessions} sessões${days ? ` (últimos ${days} dias)` : ""}`,
+    );
+    if (s.partial) console.log(`aviso: ${s.partial} turno(s) sem fechamento, valor estimado`);
+    if (s.unmeasured) console.log(`aviso: ${s.unmeasured} turno(s) do Codex sem custo em dólar`);
+    table("por tipo de sessão", sorted(s.by_kind), s.total, k => KIND[k] ?? k);
+    table("por etapa", sorted(s.by_stage), s.total, k => STAGE[k] ?? k);
+    table("por modelo", sorted(s.by_model), s.total);
+    console.log("\npor vídeo");
+    for (const v of s.by_video.slice(0, 15))
+      console.log(
+        `  ${pad(v.video.slice(0, 44), 44)} ${lpad(usd(v.total), 13)}  ${lpad(v.turns, 3)} turnos  ${pad(v.type, 9)}`,
+      );
+    console.log("\npor dia");
+    for (const d of s.by_day.slice(-10)) console.log(`  ${d.day}  ${lpad(usd(d.cost), 13)}`);
+  }
+}

package/tools/lib/agents.mjs

@@ -54,7 +54,12 @@ export const expandHome = p =>
       .trim()
       .replace(/^~(?=\/|$)/, homedir()),
   );
-export const tildify = p => (p.startsWith(homedir()) ? `~${p.slice(homedir().length)}` : p);
+/* on Windows the folder is written `~/…` too (expandHome only expands `~/`), so it reads back the same */
+export const tildify = p => {
+  if (!p.startsWith(homedir())) return p;
+  const rest = p.slice(homedir().length);
+  return `~${process.platform === "win32" ? rest.replace(/\\/g, "/") : rest}`;
+};
 
 function readJson(file) {
   try {
@@ -155,7 +160,8 @@ const jwtPayload = token => {
 
 /**
  * Who is logged in to an account, read from its own files (no process, no network).
- * @returns {{ email: string|null, detail: string|null } | null}
+ * @returns {{ email: string|null, detail: string|null, name?: string|null } | null} `name` is the account's own
+ *   display name, when its files carry one (Claude's)
  */
 export function loginOf(a) {
   if (a.provider === "claude") {
@@ -164,7 +170,7 @@ export function loginOf(a) {
     if (!o) return null;
     const org =
       o.organizationName && o.organizationName !== `${o.emailAddress}'s Organization` ? o.organizationName : null;
-    return { email: o.emailAddress ?? null, detail: org };
+    return { email: o.emailAddress ?? null, detail: org, name: o.displayName ?? null };
   }
   const auth = readJson(join(a.dir, "auth.json"));
   if (!auth) return null;

package/tools/lib/channel.mjs

@@ -122,7 +122,7 @@ export class Peer {
         this.waiting.delete(id);
         this.outbound.get(`q${id}`)?.cancel();
         this.frame({ t: "abort", id });
-        reject(new ChannelError("o Mac não respondeu a tempo", "timeout"));
+        reject(new ChannelError("a máquina não respondeu a tempo", "timeout"));
       }, timeoutMs);
       this.waiting.set(id, { resolve, reject, timer });
       this.frame({

package/tools/lib/cloud-user.mjs

@@ -0,0 +1,58 @@
+/* ============================================================================
+   The machine's side of the user's own cloud (docs/specs/phase-3-per-user-cloud.md, step 3).
+
+   The CLIs (omnichat.mjs, metrics.mjs) talk to "the cloud" through cloudApi (tools/platforms.mjs) with the paths
+   and bodies of the omnichat Worker they were written against. With `cloud.user` on, the calls of the omnichat,
+   the Instagram account and the metrics go to the user's own cloud instead (the studio's UserCloud, signed in with
+   the Omni login): this file is the one place that knows both vocabularies, so the callers don't change.
+
+   What still goes to the omnichat Worker (`userRoute` answers null): the schedule, the media published now and
+   the YouTube/TikTok credentials. Publishing is the last step of the migration (the Worker keeps doing it).
+
+   Pure: no network, no disk. The tests are in cloud-user.test.mjs.
+   ============================================================================ */
+
+/**
+ * @typedef {{ method: string, path: string, body?: unknown }} Call
+ */
+
+/** a config key that holds a flag (the jobs' on/off switches are config keys of the user's cloud) */
+const flag = (/** @type {string} */ key, /** @type {unknown} */ on) => ({
+  method: "PUT",
+  path: "/api/cloud/config",
+  body: { [key]: on === true },
+});
+
+/**
+ * The call in the user's cloud that does what an old Worker call did, or null when the old call is not one the
+ * user's cloud takes yet.
+ * @param {string} method @param {string} path with its query, as the old Worker had it @param {unknown} [body]
+ * @returns {Call | null}
+ */
+export function userRoute(method, path, body) {
+  const [pathname, query] = path.split("?");
+  const q = query ? `?${query}` : "";
+  const is = (/** @type {string} */ m, /** @type {string} */ p) => method === m && pathname === p;
+
+  /* what only the user's own cloud has (its status with the webhook address, the secrets): as they are */
+  if (pathname.startsWith("/api/cloud/")) return { method, path, body };
+
+  /* the switches and the omnichat config: config keys */
+  if (is("PUT", "/api/active")) return flag("omnichat.active", /** @type {any} */ (body)?.active);
+  if (is("PUT", "/api/metrics/active")) return flag("metrics.active", /** @type {any} */ (body)?.active);
+  if (is("PUT", "/api/config")) return { method, path: "/api/cloud/config", body: { "omnichat.config": body } };
+
+  if (is("GET", "/api/status")) return { method, path: "/api/cloud/omnichat/status" };
+  if (is("PUT", "/api/account")) return { method, path: "/api/cloud/instagram/account", body };
+
+  /* a post's rule and record, and the passes on it */
+  const post = /^\/api\/posts\/(\d+)(\/(?:record|retry|run|send))?$/.exec(pathname);
+  if (post) return { method, path: `/api/cloud/omnichat/posts/${post[1]}${post[2] ?? ""}${q}`, body };
+
+  /* the metrics */
+  if (is("GET", "/api/metrics")) return { method, path: "/api/cloud/metrics" };
+  const metrics = /^\/api\/metrics\/(videos\/\d+|account|run)$/.exec(pathname);
+  if (metrics) return { method, path: `/api/cloud/metrics/${metrics[1]}`, body };
+
+  return null;
+}

package/tools/lib/cost.mjs

@@ -0,0 +1,357 @@
+/* What the agents spent: the cost of every Claude turn, split by video, stage, fork and model.
+
+   The source is what the studio already writes: .sessions/<id>/turn-<n>.jsonl, claude's
+   stream-json. Each turn ends with a `result` that carries `total_cost_usd` and, per model, the
+   `costUSD` of everything the session ran so far, forks included. That total is the truth, and
+   it is CUMULATIVE: a resumed session keeps adding to it, so a turn costs the difference to the
+   previous result. The per-message `usage` lines are only used to SPLIT that cost (which fork
+   spent what): they come with the output tokens undercounted, so the split is scaled per model
+   to what the result says (the price table only gives the weights between token kinds, never the
+   final value). A turn without `result` (running, interrupted) is the uncalibrated estimate,
+   marked `partial`.
+
+   A fork is a message whose `parent_tool_use_id` points at a Skill or Agent tool_use. A stage
+   skill (`context: fork`) shows up as a Skill, a fan-out scene as an Agent ("compose c01").
+   Codex reports tokens, never dollars: its turns count as turns, with no cost.
+
+   Everything here is read-only. The only thing written is a cache per finished turn file
+   (.cost/turns/), which never goes stale: a turn with `result` does not change. */
+
+import {
+  createReadStream,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { createInterface } from "node:readline";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+export const SESSIONS_DIR = join(ROOT, ".sessions");
+export const CACHE_DIR = join(ROOT, ".cost", "turns");
+const CACHE_VERSION = 1;
+
+/* USD per million tokens: input, output, cache read, cache write. Only the proportion between
+   the four matters (calibration fixes the scale); a model missing here is priced as Opus. */
+const PRICES = {
+  opus: [4, 20, 0.2, 5],
+  sonnet: [2, 10, 0.2, 2.5],
+  haiku: [1, 5, 0.1, 1.25],
+};
+const priceOf = model => PRICES[Object.keys(PRICES).find(k => String(model).includes(k)) ?? "opus"];
+
+export const shortModel = m =>
+  String(m ?? "?")
+    .replace(/^claude-/, "")
+    .replace(/-\d{8}$/, "");
+
+/* the skills before the English migration, under the name they have today */
+const LEGACY_SKILLS = {
+  "av-roteiro": "av-script",
+  "av-narracao": "av-narration",
+  "av-voz": "av-voice",
+  "av-legenda": "av-captions",
+  "av-montar": "av-assemble",
+  "av-previa": "av-preview",
+};
+
+/* fork description → stage. The Skill forks carry their own name (av-motion…). */
+const AGENT_STAGES = {
+  wireframe: "wireframe",
+  compose: "compose",
+  compor: "compose",
+  narration: "av-narration",
+  narrar: "av-narration",
+};
+export function stageOf(name, input = {}) {
+  if (name === "Skill") {
+    const skill = String(input.skill ?? "skill").replace(/^.*:/, "");
+    return LEGACY_SKILLS[skill] ?? skill;
+  }
+  const word = String(input.description ?? "")
+    .split(/\s+/)[0]
+    .toLowerCase();
+  return AGENT_STAGES[word] ?? `agent:${input.subagent_type ?? "general-purpose"}`;
+}
+
+const costOf = (u, model) => {
+  const [pi, po, pr, pw] = priceOf(model);
+  return (
+    ((u.input_tokens ?? 0) * pi +
+      (u.output_tokens ?? 0) * po +
+      (u.cache_read_input_tokens ?? 0) * pr +
+      (u.cache_creation_input_tokens ?? 0) * pw) /
+    1e6
+  );
+};
+
+const round = (n, d = 4) => +n.toFixed(d);
+
+/* One turn file → what it says, still uncalibrated. Streams the file and only parses the lines
+   that matter: an image Read puts megabytes of base64 on one `user` line.
+   `cum` is the `result` (the session's running total up to the end of this turn), `groups` the
+   split of this turn's own messages in raw dollars. `settle` turns the two into the turn's cost. */
+export async function readTurnCost(file) {
+  const messages = new Map(); // message.id → { model, parent, usage }: the last usage wins, it only grows
+  const forks = new Map(); // tool_use id → { stage, label }
+  let result = null;
+  const rl = createInterface({ input: createReadStream(file, { encoding: "utf8" }), crlfDelay: Infinity });
+  for await (const line of rl) {
+    /* `result` does not open with "type" (it starts at duration_api_ms), so it is found by its field */
+    const assistant = line.startsWith('{"type":"assistant"');
+    if (!assistant && !line.includes('"total_cost_usd"')) continue;
+    let o;
+    try {
+      o = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!assistant) {
+      if (o.type === "result" && o.total_cost_usd != null) result = o;
+      continue;
+    }
+    const m = o.message;
+    if (!m?.id || m.model === "<synthetic>") continue;
+    for (const b of m.content ?? []) {
+      if (b.type === "tool_use" && (b.name === "Skill" || b.name === "Agent")) {
+        forks.set(b.id, { stage: stageOf(b.name, b.input), label: b.input?.description || b.input?.skill || b.name });
+      }
+    }
+    const prev = messages.get(m.id);
+    const u = m.usage ?? {};
+    const keep = prev ? { ...prev.usage } : {};
+    for (const k of ["input_tokens", "output_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"]) {
+      keep[k] = Math.max(keep[k] ?? 0, u[k] ?? 0);
+    }
+    messages.set(m.id, {
+      model: shortModel(m.model ?? prev?.model),
+      parent: o.parent_tool_use_id ?? null,
+      usage: keep,
+    });
+  }
+
+  const raw = {};
+  const groups = new Map();
+  const group = key => {
+    if (!groups.has(key)) {
+      const f =
+        key === "root"
+          ? { stage: "orchestrator", label: "orquestrador" }
+          : (forks.get(key) ?? { stage: "other", label: "?" });
+      groups.set(key, {
+        ...f,
+        fork: key !== "root",
+        cost: 0,
+        messages: 0,
+        models: {},
+        tokens: { in: 0, out: 0, cacheRead: 0, cacheWrite: 0 },
+      });
+    }
+    return groups.get(key);
+  };
+  for (const { model, parent, usage } of messages.values()) {
+    const cost = costOf(usage, model);
+    raw[model] = (raw[model] ?? 0) + cost;
+    const g = group(parent ?? "root");
+    g.cost += cost;
+    g.messages += 1;
+    g.models[model] = (g.models[model] ?? 0) + cost;
+    g.tokens.in += usage.input_tokens ?? 0;
+    g.tokens.out += usage.output_tokens ?? 0;
+    g.tokens.cacheRead += usage.cache_read_input_tokens ?? 0;
+    g.tokens.cacheWrite += usage.cache_creation_input_tokens ?? 0;
+  }
+  return {
+    v: CACHE_VERSION,
+    session_id: result?.session_id ?? null,
+    cum: result
+      ? {
+          total: result.total_cost_usd,
+          models: Object.fromEntries(
+            Object.entries(result.modelUsage ?? {}).map(([m, u]) => [shortModel(m), u.costUSD ?? 0]),
+          ),
+        }
+      : null,
+    raw_models: raw,
+    groups: [...groups.values()].sort((a, b) => b.cost - a.cost),
+  };
+}
+
+/* the cached reading of a turn; a finished turn never changes, an open one is read again */
+export async function turnCost(file) {
+  const st = statSync(file);
+  const cache = join(CACHE_DIR, `${file.split("/").slice(-2).join("-")}.json`);
+  try {
+    const c = JSON.parse(readFileSync(cache, "utf8"));
+    if (c.v === CACHE_VERSION && c.cum && c.size === st.size) return c;
+  } catch {}
+  const c = { ...(await readTurnCost(file)), size: st.size };
+  try {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    const tmp = `${cache}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(c));
+    renameSync(tmp, cache);
+  } catch {}
+  return c;
+}
+
+const sum = o => Object.values(o).reduce((a, b) => a + b, 0);
+
+/* The `result` of a resumed session is CUMULATIVE (cost and models grow turn after turn, same
+   session_id), so a turn's own cost is the difference to the previous result of its session.
+   A turn without `result` (running or interrupted) is the uncalibrated estimate of its
+   messages, marked `partial`; the next result also holds what that turn spent, so the estimate
+   is taken out of it and the session still adds up to its last total.
+   `chain` is the running state of one session: { key, total, models, pending: { total, models } }. */
+export function settle(reading, chain) {
+  if (!reading.cum) {
+    const total = sum(reading.raw_models);
+    chain.pending.total += total;
+    for (const [m, c] of Object.entries(reading.raw_models))
+      chain.pending.models[m] = (chain.pending.models[m] ?? 0) + c;
+    return {
+      partial: true,
+      total: round(total),
+      models: roundAll(reading.raw_models),
+      groups: reading.groups.map(g => roundGroup(g, () => 1)),
+    };
+  }
+  if (reading.session_id !== chain.key) Object.assign(chain, { key: reading.session_id, total: 0, models: {} }); // another conversation: starts from zero
+  const delta = (cum, before, pending) => Math.max(0, cum - before - pending);
+  const total = delta(reading.cum.total, chain.total, chain.pending.total);
+  const models = {};
+  for (const [m, cum] of Object.entries(reading.cum.models)) {
+    const d = delta(cum, chain.models[m] ?? 0, chain.pending.models[m] ?? 0);
+    if (d > 0) models[m] = d;
+  }
+  /* each model's messages are scaled to what the result says that model spent in this turn */
+  const factor = m => (reading.raw_models[m] > 0 && models[m] != null ? models[m] / reading.raw_models[m] : 1);
+  const groups = reading.groups.map(g => roundGroup(g, factor));
+  Object.assign(chain, {
+    total: reading.cum.total,
+    models: { ...reading.cum.models },
+    pending: { total: 0, models: {} },
+  });
+  return { partial: false, total: round(total), models: roundAll(models), groups };
+}
+
+const roundAll = o => Object.fromEntries(Object.entries(o).map(([k, v]) => [k, round(v)]));
+const roundGroup = (g, factor) => {
+  const models = Object.fromEntries(Object.entries(g.models).map(([m, c]) => [m, c * factor(m)]));
+  return { ...g, cost: round(sum(models)), models: roundAll(models) };
+};
+
+/** every turn of every session, one row each: who it belongs to, when, what it cost
+   @param {{ sessionsDir?: string, since?: number | null }} [opts] `since`: epoch ms, earlier turns are not listed */
+export async function readTurns({ sessionsDir = SESSIONS_DIR, since = null } = {}) {
+  if (!existsSync(sessionsDir)) return [];
+  const rows = [];
+  for (const id of readdirSync(sessionsDir)) {
+    let rec;
+    try {
+      rec = JSON.parse(readFileSync(join(sessionsDir, id, "session.json"), "utf8"));
+    } catch {
+      continue;
+    }
+    const chain = { key: null, total: 0, models: {}, pending: { total: 0, models: {} } };
+    for (const t of rec.turns ?? []) {
+      const base = {
+        session: rec.id,
+        type: rec.type,
+        target: rec.target,
+        n: t.n,
+        at: t.started_at,
+        provider: t.provider ?? "claude",
+        account: t.account ?? null,
+        origin: t.origin,
+      };
+      const file = join(sessionsDir, id, t.file);
+      if (base.provider !== "claude" || !existsSync(file)) {
+        rows.push({ ...base, total: null, partial: false, models: {}, subagents: 0, groups: [] });
+        continue;
+      }
+      /* a turn out of the window is still settled (the chain needs it), only not listed */
+      const s = settle(await turnCost(file), chain);
+      if (since && Date.parse(t.started_at) < since) continue;
+      rows.push({ ...base, ...s, subagents: s.groups.filter(g => g.fork).length });
+    }
+  }
+  return rows.sort((a, b) => a.at.localeCompare(b.at));
+}
+
+const add = (o, k, v) => {
+  o[k] = round((o[k] ?? 0) + v);
+};
+
+/* turns → the numbers the CLI and the studio show */
+export function summarize(rows) {
+  const out = {
+    total: 0,
+    turns: rows.length,
+    sessions: new Set(rows.map(r => r.session)).size,
+    partial: 0,
+    unmeasured: 0,
+    by_kind: {},
+    by_stage: {},
+    by_model: {},
+    by_day: {},
+    by_video: {},
+    top_forks: [],
+  };
+  const forks = [];
+  for (const r of rows) {
+    if (r.total == null) {
+      out.unmeasured += 1;
+      continue;
+    }
+    if (r.partial) out.partial += 1;
+    out.total += r.total;
+    add(out.by_kind, r.type, r.total);
+    add(out.by_day, r.at.slice(0, 10), r.total);
+    for (const [m, c] of Object.entries(r.models)) add(out.by_model, m, c);
+    const v = out.by_video[r.target] ?? {
+      video: r.target,
+      type: r.type,
+      total: 0,
+      turns: 0,
+      first: r.at,
+      last: r.at,
+      stages: {},
+      models: {},
+    };
+    out.by_video[r.target] = v;
+    v.total += r.total;
+    v.turns += 1;
+    v.last = r.at;
+    for (const [m, c] of Object.entries(r.models)) add(v.models, m, c);
+    /* the groups are the turn's estimate calibrated per model, so they add up to its total */
+    for (const g of r.groups) {
+      add(out.by_stage, g.stage, g.cost);
+      add(v.stages, g.stage, g.cost);
+      if (g.fork)
+        forks.push({
+          video: r.target,
+          session: r.session,
+          turn: r.n,
+          stage: g.stage,
+          label: g.label,
+          cost: g.cost,
+          messages: g.messages,
+        });
+    }
+  }
+  out.total = round(out.total);
+  out.by_video = Object.values(out.by_video)
+    .map(v => ({ ...v, total: round(v.total) }))
+    .sort((a, b) => b.total - a.total);
+  out.top_forks = forks.sort((a, b) => b.cost - a.cost).slice(0, 15);
+  out.by_day = Object.entries(out.by_day)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([day, cost]) => ({ day, cost }));
+  return out;
+}

package/tools/lib/deps.mjs

@@ -241,26 +241,41 @@ export function checkDeps(codeRoot) {
   };
 }
 
+/** the setup steps that are one of these programs (tools/lib/setup-progress.mjs names them for the user) */
+export const DEP_STEPS = /** @type {const} */ (["video", "render", "voice", "style"]);
+
+/** Fetches one program, by the id of the setup step it belongs to; throws when it can't (a retry from the page).
+ *  @param {string} id @param {string} codeRoot */
+export async function ensureDep(id, codeRoot) {
+  if (id === "video") return ensureFfmpeg();
+  if (id === "render") return ensureChrome();
+  if (id === "voice") return ensurePython(codeRoot);
+  if (id === "style") return ensureYtdlp();
+  throw new Error(`etapa desconhecida: ${id}`);
+}
+
 /**
- * Fetches whatever doesn't answer, one piece at a time, and says how it went.
- * @param {string} codeRoot @param {{ log?: (line: string) => void }} [o]
+ * Fetches whatever doesn't answer, one piece at a time, and says how it went. `onStep` hears each piece by the
+ * id of the setup step it belongs to (tools/lib/setup-progress.mjs): running, then done or error.
+ * @param {string} codeRoot
+ * @param {{ log?: (line: string) => void, onStep?: (id: string, state: "running" | "done" | "error", error?: string) => void }} [o]
  * @returns {Promise<{ ok: boolean, missing: string[], errors: string[] }>}
  */
-export async function ensureDeps(codeRoot, { log = () => {} } = {}) {
+export async function ensureDeps(codeRoot, { log = () => {}, onStep = () => {} } = {}) {
   /** @type {string[]} */
   const errors = [];
-  const steps = /** @type {const} */ ([
-    ["ffmpeg", () => ensureFfmpeg()],
-    ["Chrome sem janela", () => ensureChrome()],
-    ["Python", () => ensurePython(codeRoot)],
-    ["yt-dlp", () => ensureYtdlp()],
-  ]);
-  for (const [name, run] of steps) {
+  const names = { video: "ffmpeg", render: "Chrome sem janela", voice: "Python", style: "yt-dlp" };
+  for (const id of DEP_STEPS) {
+    const name = names[id];
     try {
       log(`preparando ${name}…`);
-      await run();
+      onStep(id, "running");
+      await ensureDep(id, codeRoot);
+      onStep(id, "done");
     } catch (e) {
-      errors.push(`${name}: ${/** @type {Error} */ (e).message}`);
+      const message = /** @type {Error} */ (e).message;
+      errors.push(`${name}: ${message}`);
+      onStep(id, "error", message);
     }
   }
   const c = checkDeps(codeRoot);