agy-insights 0.7.2 → 0.8.0

package/README.es.md

@@ -36,7 +36,7 @@ npx agy-insights
 npx agy-insights@latest --text
 ```
 
-`@latest` hace que npx compruebe cada vez si hay una versión nueva. Sin él, una copia instalada globalmente (`npm install -g`) o en el proyecto actual tiene prioridad y no se actualiza nunca. Para fijar una versión concreta: `npx agy-insights@0.7.2`.
+`@latest` hace que npx compruebe cada vez si hay una versión nueva. Sin él, una copia instalada globalmente (`npm install -g`) o en el proyecto actual tiene prioridad y no se actualiza nunca. Para fijar una versión concreta: `npx agy-insights@0.8.0`.
 
 **Instalándolo globalmente:**
 
@@ -61,7 +61,7 @@ Y ejecútalo con `node agy-insights/agy-insights.js` en lugar de `npx agy-insigh
 npx agy-insights
 ```
 
-Analiza todo tu historial (todas las conversaciones que guarde agy, sin límite de fecha), guarda un informe HTML en la carpeta temporal y lo abre en el navegador. En el informe puedes cambiar entre todo el historial y los últimos 90, 30 o 7 días: los totales, la gráfica, los hallazgos y las tablas siguen el periodo elegido.
+Analiza todo tu historial (todas las conversaciones que guarde agy, sin límite de fecha), guarda un informe HTML en la carpeta temporal y lo abre en el navegador. En el informe puedes cambiar entre todo el historial y los últimos 90 o 30 días, o esta semana (desde el lunes): los totales, la gráfica, los hallazgos y las tablas siguen el periodo elegido.
 
 | Para… | Ejecuta |
 |---|---|
@@ -82,7 +82,7 @@ El informe da dos cifras:
 
 ## Leer el informe
 
-Arriba están el selector de periodo y los totales. Después, una gráfica de **consumo de tokens por día** (por semana si el historial pasa de ~4 meses) para ver la evolución; pasa el ratón por una columna para ver sus cifras, o abre «Ver como tabla». Después, **Modelos y esfuerzo**: llamadas y tokens reales por modelo y nivel de esfuerzo (por ejemplo Gemini 3.8 Flash · Alto), con los tokens por llamada, para ver cuánto cuesta un esfuerzo mayor. Debajo, **Qué está pasando** reúne los hallazgos; al final, el detalle por proyecto, tipo de fichero, carpeta, fichero, herramienta y comando. El proyecto de cada fichero se detecta por su carpeta `.git`.
+Arriba están el selector de periodo y los totales. Después, una gráfica de **consumo de tokens por día** (por semana si el historial pasa de ~4 meses) para ver la evolución. Cámbiala a **Por llamada** para ver los tokens medios de cada llamada al modelo: el total sube y baja según cuánto hayas trabajado, mientras que por llamada solo baja si cada llamada lleva menos contexto, así que es la que muestra si un cambio ha servido. Pasa el ratón por una columna para ver sus cifras, o abre «Ver como tabla». Después, **Modelos y esfuerzo**: llamadas y tokens reales por modelo y nivel de esfuerzo (por ejemplo Gemini 3.8 Flash · Alto), con los tokens por llamada, para ver cuánto cuesta un esfuerzo mayor. Debajo, **Qué está pasando** reúne los hallazgos; al final, el detalle por proyecto, tipo de fichero, carpeta, fichero, herramienta y comando. El proyecto de cada fichero se detecta por su carpeta `.git`.
 
 | Hallazgo | Qué significa | Qué hacer |
 |---|---|---|
@@ -161,6 +161,8 @@ Copia `agy-insights.example.json` a `~/.agy-insights.json` (o pásalo con `--con
 
 **Uso la app o el IDE de Antigravity, no el CLI**. Por ahora solo se lee el historial del CLI.
 
+**Muchas llamadas con modelo «desconocido»**. agy no anotó su modelo. Ejecuta `npx agy-insights@latest --debug-models` y pega el resultado en una [incidencia](https://github.com/migohe14/agy-insights/issues): solo contiene recuentos y nombres de modelo.
+
 **El navegador no se abre**. La ruta del informe aparece en la terminal; ábrela a mano.
 
 ## Estado

package/README.md

@@ -36,7 +36,7 @@ npx agy-insights
 npx agy-insights@latest --text
 ```
 
-`@latest` makes npx check for the newest version every time. Without it, a copy installed globally (`npm install -g`) or in the current project takes precedence and is never updated. To pin a version instead: `npx agy-insights@0.7.2`.
+`@latest` makes npx check for the newest version every time. Without it, a copy installed globally (`npm install -g`) or in the current project takes precedence and is never updated. To pin a version instead: `npx agy-insights@0.8.0`.
 
 **Globally:**
 
@@ -61,7 +61,7 @@ Then run it with `node agy-insights/agy-insights.js` instead of `npx agy-insight
 npx agy-insights
 ```
 
-Analyzes your whole history (every conversation agy has kept, with no date limit), saves an HTML report in the temp folder and opens it in the browser. In the report you can switch between the whole history and the last 90, 30 or 7 days: totals, chart, findings and tables all follow the selected period.
+Analyzes your whole history (every conversation agy has kept, with no date limit), saves an HTML report in the temp folder and opens it in the browser. In the report you can switch between the whole history and the last 90 or 30 days, or this week (since Monday): totals, chart, findings and tables all follow the selected period.
 
 | To… | Run |
 |---|---|
@@ -82,7 +82,7 @@ The report gives two figures:
 
 ## Reading the report
 
-At the top, the period selector and the totals. Then a chart of **token usage per day** (per week when the history spans more than ~4 months), to see how usage evolves; hover a column for its figures, or open "View as table". Next, **Models and effort**: calls and real tokens per model and effort level (for example Gemini 3.8 Flash · High), including tokens per call, so you can see what a higher effort costs. Below, **What's happening** lists the findings; at the end, the details by project, file type, folder, file, tool and command. The project of each file is detected through its `.git` folder.
+At the top, the period selector and the totals. Then a chart of **token usage per day** (per week when the history spans more than ~4 months), to see how usage evolves. Switch it to **Per call** to see mean tokens per model call: the total follows how much you worked, while per call drops only when each call carries less context, so it is the one that shows whether a change paid off. Hover a column for its figures, or open "View as table". Next, **Models and effort**: calls and real tokens per model and effort level (for example Gemini 3.8 Flash · High), including tokens per call, so you can see what a higher effort costs. Below, **What's happening** lists the findings; at the end, the details by project, file type, folder, file, tool and command. The project of each file is detected through its `.git` folder.
 
 | Finding | What it means | What to do |
 |---|---|---|
@@ -161,6 +161,8 @@ Copy `agy-insights.example.json` to `~/.agy-insights.json` (or pass it with `--c
 
 **I use the Antigravity app or IDE, not the CLI**. For now only the CLI history is read.
 
+**Many calls under model "unknown"**. agy recorded no model for them. Run `npx agy-insights@latest --debug-models` and paste the output into an [issue](https://github.com/migohe14/agy-insights/issues): it only has counts and model names.
+
 **The browser doesn't open**. The report path is printed in the terminal; open it manually.
 
 ## Status

package/agy-insights.js

@@ -32,6 +32,7 @@ function parseArgs(argv) {
     else if (a === '--lang') opts.lang = value();
     else if (a === '--since') opts.since = value();
     else if (a === '--days') opts.days = value();
+    else if (a === '--debug-models') opts.debugModels = true;
     else fail(t.unknownOption(a));
   }
   return opts;
@@ -82,8 +83,30 @@ function sinceTime({ since, days }) {
   return null;
 }
 
+// Tab-separated table of where each conversation's call models came from, for bug reports.
+function debugModels(r) {
+  const d = t.debugModels;
+  const sum = { rows: 0, rowsWithModel: 0, calls: 0, fromTranscript: 0, unknown: 0 };
+  const lines = [d.header.join('\t')];
+  for (const s of r.sessions) {
+    const m = s.modelSources;
+    for (const k of Object.keys(sum)) sum[k] += m[k];
+    lines.push([s.id.slice(0, 8), m.calls, m.rows, m.rowsWithModel, m.fromTranscript, m.unknown, s.model ? `${s.model.model} (${s.model.effort})` : '', m.unknown ? m.candidates.join(' | ') : ''].join('\t'));
+  }
+  lines.push([d.total, sum.calls, sum.rows, sum.rowsWithModel, sum.fromTranscript, sum.unknown, '', ''].join('\t'), '', d.note, '');
+  return lines.join('\n');
+}
+
 // Periods the HTML report can switch to, besides the whole history.
-const PRESET_DAYS = [90, 30, 7];
+const PRESET_DAYS = [90, 30];
+
+// This Monday at local midnight.
+function weekStart() {
+  const d = new Date();
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() - ((d.getDay() + 6) % 7));
+  return d.getTime();
+}
 
 async function main() {
   const argv = process.argv.slice(2);
@@ -104,6 +127,7 @@ async function main() {
     customKinds: cfg.customKinds || {},
   });
   const r = await run(since);
+  if (opts.debugModels) return process.stdout.write(debugModels(r));
   if (opts.map) {
     const m = buildMap(opts.project, { ...cfg.map, history: r.files });
     console.log(m.block);
@@ -128,6 +152,8 @@ async function main() {
       const x = await run(Date.now() - days * 24 * 60 * 60 * 1000);
       views.push({ key: `d${days}`, label: t.report.rangeDays(days), r: x, found: find(x) });
     }
+    const week = await run(weekStart());
+    views.push({ key: 'week', label: t.report.rangeWeek, r: week, found: find(week) });
   }
   fs.writeFileSync(out, report.htmlViews(views, { scope: opts.project }));
   console.log(t.done(r.conversations, found.length, out));

package/docs/how-it-works.md

@@ -34,12 +34,12 @@ It is undocumented; this is what has been observed in `agy` 1.4.x.
 - One SQLite database per conversation: `~/.gemini/antigravity-cli/conversations/<uuid>.db`, in WAL mode.
 - Table `steps`: one row per step. `step_payload` is a protobuf message. Tool calls store the name (`view_file`, `run_command`, `grep_search`…) followed by their JSON arguments, for example `{"AbsolutePath":"C:\\dev\\...\\X.cs","StartLine":301,"EndLine":380}`, preceded by a `call_NNN` id.
 - Each call takes two steps with the same id: the model response that requests it (`step_type` 15) and the result (`step_type` 132), which repeats name and arguments and adds the file content or command output. `lib/history.js` counts the call once per id and adds the size of both steps, which approximates what entered the context.
-- Table `gen_metadata`: one row per model call, in the same order as the transcript's `PLANNER_RESPONSE` lines. Each row holds the model's display name with the effort level in brackets (`Gemini 3.8 Flash (High)`) and its id (`gemini-3.8-flash-high`). `modelOf()` takes the model and effort from whole strings only, so prose in the system prompt that mentions a model is ignored, and the n-th row is matched to the n-th call to get tokens per model and effort.
+- Table `gen_metadata`: one row per model call, in the same order as the transcript's `PLANNER_RESPONSE` lines. Each row holds the model's display name with the effort level in brackets (`Gemini 3.8 Flash (High)`) and its id (`gemini-3.8-flash-high`). `modelOf()` takes the model and effort from whole strings only, so prose in the system prompt that mentions a model is ignored, and the n-th row is matched to the n-th call to get tokens per model and effort. That pairing is only trusted when the counts match. Otherwise each call takes the model selected in the transcript (`USER_INPUT` lines carry "changed setting `Model Selection` from X to Y"), or the conversation's only model; what is left is "unknown". `modelKey()` merges the two spellings (`Gemini 3.8 Flash` / `gemini-3.8-flash`, `High` / `high`). `--debug-models` prints, per conversation, how many calls got their model from each source: counts only, safe to paste into an issue.
 - Next to the history, `../brain/<id>/.system_generated/logs/transcript.jsonl`: one JSON line per step. `PLANNER_RESPONSE` lines are model calls and carry `input_tokens`, `cache_read_tokens` and `output_tokens`; failed steps have `status: "ERROR"`. Subagents have their own conversation and transcript. `realUsage()` in `lib/history.js` adds those figures up (it only reads the file). The total printed by `agy -p --output-format json` does not include subagents; this one does.
 
-Each `transcript.jsonl` line also has `created_at` (ISO time). A conversation is dated by the first and last of those; without a transcript, by the `.db` file's last write. `--since` / `--days` keep a conversation when its last activity falls inside the period, and skip the rest before opening them. `../conversation_summaries.db` also has `last_modified_time` per conversation, but it is not used. Each model call's `created_at` also puts its tokens on a local day (`r.daily`), which feeds the usage chart.
+Each `transcript.jsonl` line also has `created_at` (ISO time). A conversation is dated by the first and last of those; without a transcript, by the `.db` file's last write. `--since` / `--days` keep a conversation when its last activity falls inside the period, and skip the rest before opening them. `../conversation_summaries.db` has one row per conversation: its short `title` (or `preview` in older ones) names each session in the report instead of its id; `last_modified_time` is not used. If the file is missing, sessions are shown by id. Each model call's `created_at` also puts its tokens on a local day (`r.daily`), which feeds the usage chart.
 
-The HTML report holds one view per period (whole history, last 90, 30 and 7 days): `agy-insights.js` runs `analyze()` and `findings()` once per period and `report.htmlViews()` renders them all, so switching in the browser needs no analysis code in the page and every number agrees with its period. The chart is inline SVG; its color (`--series`) is checked for contrast, chroma and lightness against both surfaces.
+The HTML report holds one view per period (whole history, last 90 and 30 days, this week since Monday): `agy-insights.js` runs `analyze()` and `findings()` once per period and `report.htmlViews()` renders them all, so switching in the browser needs no analysis code in the page and every number agrees with its period. The chart is inline SVG; its color (`--series`) is checked for contrast, chroma and lightness against both surfaces.
 
 `lib/history.js` does not depend on a protobuf schema. It walks the message, collects every string, and treats as a tool call any JSON preceded (within 3 strings) by a `snake_case` name. That way it survives minor format changes. If there are more than 50 steps and no recognized call, it sets `formatUnrecognized` and the report warns about it.
 

package/lib/findings.js

@@ -131,7 +131,7 @@ function findings(r, opts = {}) {
       why: f.longWhy(long.length, num(o.longSessionTokens)), suggestion: f.longSuggestion,
       items: long.slice(0, 5).map((s) => ({
         // Real tokens when agy logged them (`exact`: shown without "~"), else the size estimate.
-        label: f.conversation(s.id.slice(0, 8), when(s.start, s.end)), fixes: [],
+        label: f.conversation(s.id.slice(0, 8), when(s.start, s.end), s.title), fixes: [],
         tokens: s.usage ? s.usage.input + s.usage.output : s.tokens, exact: Boolean(s.usage),
         detail: f.steps(s.steps) + (s.usage
           ? f.longUsage(s.usage.calls, num(s.usage.input + s.usage.cache + s.usage.output))

package/lib/history.js

@@ -29,6 +29,23 @@ function modelOf(strs) {
   return { model: null, effort: null };
 }
 
+// agy notes model switches in the user's message: "changed setting `Model Selection` from None to
+// Gemini 3.8 Flash (High)." The model in force for every call that follows.
+const MODEL_SETTING_RE = /changed setting `Model Selection` from .+? to (.+?)\.(?:\s|$)/g;
+function selectedModel(text) {
+  let last = null;
+  for (const m of String(text).matchAll(MODEL_SETTING_RE)) last = m[1].trim();
+  return last && modelOf([last]).model ? modelOf([last]) : null;
+}
+
+// A short string that may name a model in a format modelOf() does not know yet: mentions a model family,
+// or is an enum-like id ("MODEL_PLACEHOLDER_M26"). Only used for --debug-models.
+const looksLikeModel = (s) => s.length <= 60 && !/[\\/:]/.test(s)
+  && (/\b(gemini|claude|gpt|model|flash|pro|argon)\b/i.test(s) || /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)+$/.test(s));
+
+// "Gemini 3.8 Flash" and "gemini-3.8-flash", "High" and "high": the same model and effort.
+const modelKey = (m) => `${(m.model || '').toLowerCase().replace(/[\s_]+/g, '-')}|${(m.effort || '').toLowerCase()}`;
+
 // --- SQLite access: node:sqlite when the runtime has it (Node >= 22.13), sql.js (WASM) otherwise. ---
 
 let nodeSqlite = null;
@@ -203,20 +220,27 @@ function realUsage(dir, id) {
   let text;
   try { text = fs.readFileSync(file, 'utf8'); } catch { return null; }
   // `days`: the same figures per local day of each model call (calls without a time go under null).
-  // `perCall`: each call's figures, in order (they match gen_metadata's rows one to one).
+  // `perCall`: each call's figures, in order, and the model selected in the transcript when it was made.
   const u = { calls: 0, input: 0, cache: 0, output: 0, errors: 0, start: null, end: null, days: new Map(), perCall: [] };
+  let selected = null;
+  u.unrecognized = new Set();
   for (const line of text.split('\n')) {
     let e;
     try { e = JSON.parse(line); } catch { continue; }
     const at = Date.parse(e.created_at);
     if (at) { u.start = Math.min(u.start ?? at, at); u.end = Math.max(u.end ?? at, at); }
     if (e.status === 'ERROR') u.errors++;
+    if (e.type === 'USER_INPUT') {
+      selected = selectedModel(e.content) || selected;
+      // Model names agy selected that modelOf() does not understand, for --debug-models.
+      for (const m of String(e.content).matchAll(MODEL_SETTING_RE)) if (!modelOf([m[1].trim()]).model) u.unrecognized.add(m[1].trim().slice(0, 60));
+    }
     if (e.type !== 'PLANNER_RESPONSE') continue;
     u.calls++;
     u.input += Number(e.input_tokens) || 0;
     u.cache += Number(e.cache_read_tokens) || 0;
     u.output += Number(e.output_tokens) || 0;
-    u.perCall.push({ input: Number(e.input_tokens) || 0, cache: Number(e.cache_read_tokens) || 0, output: Number(e.output_tokens) || 0 });
+    u.perCall.push({ input: Number(e.input_tokens) || 0, cache: Number(e.cache_read_tokens) || 0, output: Number(e.output_tokens) || 0, model: selected });
     const k = at ? dayKey(at) : null;
     const d = u.days.get(k) || { calls: 0, input: 0, cache: 0, output: 0 };
     d.calls++;
@@ -228,6 +252,26 @@ function realUsage(dir, id) {
   return u;
 }
 
+// --- Titles ---
+
+// The short title agy gives each conversation ("Analyzing Package Lock Dependencies"), from
+// <conversations>/../conversation_summaries.db; older ones only have it as `preview`. Empty map when
+// the file is missing or unreadable: the report then falls back to the conversation id.
+async function conversationTitles(dir, tmp) {
+  const titles = new Map();
+  const file = path.join(dir, '..', 'conversation_summaries.db');
+  if (!fs.existsSync(file)) return titles;
+  let db;
+  try {
+    db = await openDb(file, tmp);
+    for (const [id, title, preview] of db.all('select conversation_id, title, preview from conversation_summaries')) {
+      const name = String(title || preview || '').trim().slice(0, 80);
+      if (name) titles.set(String(id), name);
+    }
+  } catch { /* no titles */ } finally { db?.close(); }
+  return titles;
+}
+
 // --- Aggregation ---
 
 class Counter {
@@ -269,6 +313,7 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
 
   try {
     const dbs = fs.existsSync(dir) ? fs.readdirSync(dir).filter((f) => /^[0-9a-f-]{36}\.db$/i.test(f)) : [];
+    const titles = await conversationTitles(dir, tmp);
     for (const f of dbs) {
       // When it happened: the transcript's step times, else the database's last write.
       const id = f.replace(/\.db$/, '');
@@ -345,26 +390,45 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
             daily.set(day, d);
           }
         }
-        // One gen_metadata row per model call, in the transcript's order: the n-th row's model made the n-th call.
-        const callModels = db.all('select data from gen_metadata order by idx').map(([blob]) => modelOf(collect(blob)));
-        const n = Math.max(callModels.length, usage ? usage.perCall.length : 0);
-        const seenModels = new Set();
-        for (let i = 0; i < n; i++) {
-          const { model, effort } = callModels[i] || { model: null, effort: null };
-          const k = `${model}|${effort}`;
-          const e = models.get(k) || { model, effort, calls: 0, convs: 0, input: 0, cache: 0, output: 0, known: 0 };
+        // Model of each call. gen_metadata usually has one row per call, in the transcript's order; when the
+        // counts match, the n-th row is the n-th call. When they don't, pairing by position would mislabel
+        // calls, so the model selected in the transcript is used instead, or the conversation's only model.
+        const metaStrs = db.all('select data from gen_metadata order by idx').map(([blob]) => collect(blob));
+        const metaRows = metaStrs.map(modelOf);
+        const calls = usage ? usage.perCall : metaRows.map(() => null);
+        const aligned = metaRows.length === calls.length;
+        const rowModels = new Set(metaRows.filter((m) => m.model).map(modelKey));
+        const onlyModel = rowModels.size === 1 ? metaRows.find((m) => m.model) : null;
+        const callModels = calls.map((c, i) => {
+          if (aligned && metaRows[i].model) return metaRows[i];
+          return c?.model || onlyModel || { model: null, effort: null };
+        });
+        const seenModels = new Set(), counts = new Map();
+        callModels.forEach((m, i) => {
+          const k = modelKey(m);
+          const e = models.get(k) || { model: m.model, effort: m.effort, calls: 0, convs: 0, input: 0, cache: 0, output: 0, known: 0 };
+          // Prefer the display name ("Gemini 3.8 Flash", "High") over the id spelling.
+          if (m.model && /[A-Z ]/.test(m.model) && !/[A-Z ]/.test(e.model || '')) { e.model = m.model; e.effort = m.effort; }
           e.calls++;
           if (!seenModels.has(k)) { seenModels.add(k); e.convs++; }
-          const c = usage?.perCall[i];
+          const c = calls[i];
           if (c) { e.known++; e.input += c.input; e.cache += c.cache; e.output += c.output; }
           models.set(k, e);
-        }
+          if (m.model) counts.set(k, (counts.get(k) || 0) + 1);
+        });
         // The session's model: the one that made most of its calls.
-        const counts = new Map();
-        for (const m of callModels) counts.set(`${m.model}|${m.effort}`, (counts.get(`${m.model}|${m.effort}`) || 0) + 1);
         const main = [...counts].sort((a, b) => b[1] - a[1])[0];
-        const model = main ? callModels.find((m) => `${m.model}|${m.effort}` === main[0]) : null;
-        r.sessions.push({ id, start, end, steps: steps.length, tokens: convBytes / BYTES_PER_TOKEN, usage, model: model?.model ? model : null, models: counts.size });
+        const model = main ? models.get(main[0]) : null;
+        r.sessions.push({
+          id, title: titles.get(id) || null, start, end, steps: steps.length, tokens: convBytes / BYTES_PER_TOKEN, usage,
+          model: model ? { model: model.model, effort: model.effort } : null, models: counts.size,
+          // For --debug-models: where each call's model came from, and for rows where no model was recognized,
+          // the short strings that look like a model id (to spot a new format). Never prompts, paths or code.
+          modelSources: { rows: metaRows.length, rowsWithModel: metaRows.filter((m) => m.model).length, calls: calls.length,
+            fromTranscript: calls.filter((c) => c?.model).length, unknown: callModels.filter((m) => !m.model).length,
+            candidates: [...new Set([...(usage?.unrecognized || []),
+              ...metaStrs.filter((_, i) => !metaRows[i].model).flat().filter(looksLikeModel)])].slice(0, 10) },
+        });
         r.tokens += convBytes / BYTES_PER_TOKEN;
       } catch { r.unreadable++; } finally { db.close(); }
     }
@@ -386,4 +450,4 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
   };
 }
 
-module.exports = { analyze, DEFAULT_DIR, kind, NON_SOURCE, realUsage, dayKey, modelOf, repoFiles };
+module.exports = { analyze, DEFAULT_DIR, kind, NON_SOURCE, realUsage, dayKey, modelOf, selectedModel, repoFiles };

package/lib/i18n.js

@@ -20,6 +20,7 @@ Options:
   --since <YYYY-MM-DD>  Only conversations active since that date
   --days <n>            Only conversations active in the last n days
   --lang <en|es>        Language of the output (default: the system's)
+  --debug-models        Per conversation, where each call's model came from (counts only, to report issues)
   --dir <folder>        Another history folder (default ${dir})
   --config <file>       Configuration (default ~/.agy-insights.json if it exists)
   --help                This help
@@ -33,6 +34,11 @@ Options:
   cannotRead: (f, msg) => `Cannot read ${f}: ${msg}`,
   mapDone: (tokens, file) => `\n~${tokens} tokens on every request. Paste it into ${file} if you like it; agy-insights does not write it.`,
   reportName: 'report',
+  debugModels: {
+    header: ['conversation', 'calls', 'gen_metadata rows', 'rows with model', 'calls with model in transcript', 'unknown', 'main model', 'unrecognized model ids'],
+    total: 'total',
+    note: 'Only counts and model names or ids: no paths, prompts or code. Paste it into an issue if models show up as unknown.',
+  },
   done: (convs, found, out) => `${plural(convs, 'conversation', 'conversations')} analyzed, ${plural(found, 'finding', 'findings')}.\nReport: ${out}`,
 
   kinds: {
@@ -81,7 +87,7 @@ Options:
     longTitle: 'Very long sessions',
     longWhy: (n, min) => `${plural(n, 'conversation exceeds', 'conversations exceed')} ${min} tokens. In a long session, everything accumulated is resent on every turn.`,
     longSuggestion: 'A new conversation per task, or /compact when you change topic.',
-    conversation: (id, at) => `conversation ${id}${at ? ` · ${at}` : ''}`,
+    conversation: (id, at, title) => `${title ? `"${title}" (${id})` : `conversation ${id}`}${at ? ` · ${at}` : ''}`,
     steps: (n) => plural(n, 'step', 'steps'),
     longUsage: (calls, cached) => ` · ${plural(calls, 'model call', 'model calls')} · real tokens, ${cached} with cache`,
   },
@@ -112,6 +118,7 @@ Options:
     modelLine: (model, effort, calls, tokens, pct, perCall) => `${model} · ${effort}  ${plural(calls, 'call', 'calls')}, ${tokens} tokens (${pct}), ~${perCall} per call`,
     sessionModel: 'Model',
     otherModels: (n) => ` +${n} more`,
+    modelsUnknown: (n) => `"unknown": ${n} calls for which agy recorded no model, neither in gen_metadata nor as a model change in the transcript. If there are many, run npx agy-insights@latest --debug-models and paste the result into an issue on GitHub (it only contains counts).`,
     efforts: { minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'Extra high', 'extra high': 'Extra high', max: 'Max' },
     sessionsTitle: 'Sessions (real usage)',
     sessionCols: ['Conversation', 'When', 'Model', 'Tokens', '%', 'With cache', 'Calls', 'Errors'],
@@ -135,12 +142,19 @@ Options:
     filterLabel: 'Period',
     rangeAll: 'All history',
     rangeDays: (n) => `Last ${n} days`,
+    rangeWeek: 'This week',
     chartTitleDay: 'Token usage per day',
     chartTitleWeek: 'Token usage per week',
     chartHint: 'Real tokens (input + output) of the model calls. Hover a column for details.',
     chartTable: 'View as table',
-    chartCols: ['Day', 'Tokens', 'With cache', 'Calls'],
-    chartColsWeek: ['Week of', 'Tokens', 'With cache', 'Calls'],
+    chartModeLabel: 'Show',
+    chartModeTotal: 'Total',
+    chartModeCall: 'Per call',
+    chartHintCall: 'Mean tokens (input + output) per model call. Unlike the total, it doesn\'t depend on how much you used the agent: it drops when each call carries less context (shorter sessions, filtered command output), so it shows whether a change worked.',
+    perCallTip: (n) => `${n} tokens per call`,
+    noActivity: 'No activity',
+    chartCols: ['Day', 'Tokens', 'With cache', 'Calls', 'Per call'],
+    chartColsWeek: ['Week of', 'Tokens', 'With cache', 'Calls', 'Per call'],
     chartCalls: (n) => plural(n, 'call', 'calls'),
     weekOf: (d) => `week of ${d}`,
     withCacheShort: 'with cache',
@@ -158,7 +172,7 @@ Options:
     realUsage: (real, input, output, cached, calls) => `Real usage: ${real} tokens (input ${input} + output ${output}), ${cached} including cache, in ${plural(calls, 'model call', 'model calls')}`,
     noLog: (n) => ` (${plural(n, 'conversation', 'conversations')} without a log)`,
     topSessions: (n) => (n === 1 ? '  The session that uses the most:' : `  The ${n} sessions that use the most:`),
-    sessionLine: (id, calls, errors, cached, model, at) => `conversation ${id}${at ? ` · ${at}` : ''}${model ? ` (${model})` : ''}  ${plural(calls, 'call', 'calls')}${errors ? `, ${plural(errors, 'error', 'errors')}` : ''}, ${cached} with cache`,
+    sessionLine: (id, calls, errors, cached, model, at, title) => `${title ? `"${title}" (${id})` : `conversation ${id}`}${at ? ` · ${at}` : ''}${model ? ` (${model})` : ''}  ${plural(calls, 'call', 'calls')}${errors ? `, ${plural(errors, 'error', 'errors')}` : ''}, ${cached} with cache`,
     top5: (pct, reads, rereads, rpct) => `The 5 largest sessions account for ${pct}. Reads: ${reads}, re-reads ${rereads} (${rpct})`,
     pathHidden: '(path hidden, use --paths)',
     byKindText: 'By file type:',
@@ -182,6 +196,7 @@ Opciones:
   --since <AAAA-MM-DD>  Solo conversaciones con actividad desde esa fecha
   --days <n>            Solo conversaciones con actividad en los últimos n días
   --lang <en|es>        Idioma de la salida (por defecto, el del sistema)
+  --debug-models        Por conversación, de dónde sale el modelo de cada llamada (solo recuentos, para reportar fallos)
   --dir <carpeta>       Otra carpeta de historial (por defecto ${dir})
   --config <fichero>    Configuración (por defecto ~/.agy-insights.json si existe)
   --help                Esta ayuda
@@ -195,6 +210,11 @@ Opciones:
   cannotRead: (f, msg) => `No se puede leer ${f}: ${msg}`,
   mapDone: (tokens, file) => `\n~${tokens} tokens en cada petición. Pégalo en ${file} si te convence; agy-insights no lo escribe.`,
   reportName: 'informe',
+  debugModels: {
+    header: ['conversación', 'llamadas', 'filas gen_metadata', 'filas con modelo', 'llamadas con modelo en transcript', 'desconocidas', 'modelo principal', 'ids de modelo no reconocidos'],
+    total: 'total',
+    note: 'Solo recuentos y nombres o ids de modelo: ni rutas, ni prompts, ni código. Pégalo en una incidencia si salen modelos desconocidos.',
+  },
   done: (convs, found, out) => `${plural(convs, 'conversación analizada', 'conversaciones analizadas')}, ${plural(found, 'hallazgo', 'hallazgos')}.\nInforme: ${out}`,
 
   kinds: {
@@ -243,7 +263,7 @@ Opciones:
     longTitle: 'Sesiones muy largas',
     longWhy: (n, min) => `${plural(n, 'conversación supera', 'conversaciones superan')} ${min} tokens. En una sesión larga, todo lo acumulado se vuelve a enviar en cada turno.`,
     longSuggestion: 'Una conversación nueva por tarea, o /compact cuando cambias de tema.',
-    conversation: (id, at) => `conversación ${id}${at ? ` · ${at}` : ''}`,
+    conversation: (id, at, title) => `${title ? `«${title}» (${id})` : `conversación ${id}`}${at ? ` · ${at}` : ''}`,
     steps: (n) => plural(n, 'paso', 'pasos'),
     longUsage: (calls, cached) => ` · ${plural(calls, 'llamada', 'llamadas')} al modelo · tokens reales, ${cached} con caché`,
   },
@@ -274,6 +294,7 @@ Opciones:
     modelLine: (model, effort, calls, tokens, pct, perCall) => `${model} · ${effort}  ${plural(calls, 'llamada', 'llamadas')}, ${tokens} tokens (${pct}), ~${perCall} por llamada`,
     sessionModel: 'Modelo',
     otherModels: (n) => ` +${n} más`,
+    modelsUnknown: (n) => `«desconocido»: ${n} llamadas de las que agy no anotó el modelo, ni en gen_metadata ni como cambio de modelo en el transcript. Si son muchas, ejecuta npx agy-insights@latest --debug-models y pega el resultado en una incidencia de GitHub (solo contiene recuentos).`,
     efforts: { minimal: 'Mínimo', low: 'Bajo', medium: 'Medio', high: 'Alto', xhigh: 'Muy alto', 'extra high': 'Muy alto', max: 'Máximo' },
     sessionsTitle: 'Sesiones (consumo real)',
     sessionCols: ['Conversación', 'Cuándo', 'Modelo', 'Tokens', '%', 'Con caché', 'Llamadas', 'Errores'],
@@ -297,12 +318,19 @@ Opciones:
     filterLabel: 'Periodo',
     rangeAll: 'Todo el historial',
     rangeDays: (n) => `Últimos ${n} días`,
+    rangeWeek: 'Esta semana',
     chartTitleDay: 'Consumo de tokens por día',
     chartTitleWeek: 'Consumo de tokens por semana',
     chartHint: 'Tokens reales (entrada + salida) de las llamadas al modelo. Pasa el ratón por una columna para ver el detalle.',
     chartTable: 'Ver como tabla',
-    chartCols: ['Día', 'Tokens', 'Con caché', 'Llamadas'],
-    chartColsWeek: ['Semana del', 'Tokens', 'Con caché', 'Llamadas'],
+    chartModeLabel: 'Mostrar',
+    chartModeTotal: 'Total',
+    chartModeCall: 'Por llamada',
+    chartHintCall: 'Tokens medios (entrada + salida) por llamada al modelo. A diferencia del total, no depende de cuánto hayas usado el agente: baja cuando cada llamada lleva menos contexto (sesiones más cortas, salidas de comandos filtradas), así que muestra si un cambio ha funcionado.',
+    perCallTip: (n) => `${n} tokens por llamada`,
+    noActivity: 'Sin actividad',
+    chartCols: ['Día', 'Tokens', 'Con caché', 'Llamadas', 'Por llamada'],
+    chartColsWeek: ['Semana del', 'Tokens', 'Con caché', 'Llamadas', 'Por llamada'],
     chartCalls: (n) => plural(n, 'llamada', 'llamadas'),
     weekOf: (d) => `semana del ${d}`,
     withCacheShort: 'con caché',
@@ -319,7 +347,7 @@ Opciones:
     realUsage: (real, input, output, cached, calls) => `Consumo real: ${real} tokens (entrada ${input} + salida ${output}), ${cached} contando la caché, en ${plural(calls, 'llamada', 'llamadas')} al modelo`,
     noLog: (n) => ` (${plural(n, 'conversación', 'conversaciones')} sin registro)`,
     topSessions: (n) => (n === 1 ? '  La sesión que más gasta:' : `  Las ${n} sesiones que más gastan:`),
-    sessionLine: (id, calls, errors, cached, model, at) => `conversación ${id}${at ? ` · ${at}` : ''}${model ? ` (${model})` : ''}  ${plural(calls, 'llamada', 'llamadas')}${errors ? `, ${plural(errors, 'error', 'errores')}` : ''}, ${cached} con caché`,
+    sessionLine: (id, calls, errors, cached, model, at, title) => `${title ? `«${title}» (${id})` : `conversación ${id}`}${at ? ` · ${at}` : ''}${model ? ` (${model})` : ''}  ${plural(calls, 'llamada', 'llamadas')}${errors ? `, ${plural(errors, 'error', 'errores')}` : ''}, ${cached} con caché`,
     top5: (pct, reads, rereads, rpct) => `Las 5 sesiones más grandes suman el ${pct}. Lecturas: ${reads}, relecturas ${rereads} (${rpct})`,
     pathHidden: '(ruta oculta, usa --paths)',
     byKindText: 'Por tipo de fichero:',

package/lib/report.js

@@ -60,7 +60,7 @@ function sessionsTable(r) {
   if (!rows.length) return '';
   const max = Math.max(...rows.map((s) => billed(s.usage)), 1);
   return `<h3>${t.report.sessionsTitle}</h3><div class="scroll"><table><thead><tr>${t.report.sessionCols.map((c, i) => `<th${i > 2 ? ' class="num"' : ''}>${c}</th>`).join('')}</tr></thead><tbody>
-  ${rows.map((s) => `<tr><td><div class="bar" style="--w:${((100 * billed(s.usage)) / max).toFixed(1)}%"></div><span>${esc(s.id.slice(0, 8))}</span></td><td class="when">${esc(when(s.start, s.end))}</td><td>${esc(sessionModel(s))}</td>
+  ${rows.map((s) => `<tr><td><div class="bar" style="--w:${((100 * billed(s.usage)) / max).toFixed(1)}%"></div><span>${esc(s.title || s.id.slice(0, 8))}</span>${s.title ? `<span class="detail">${esc(s.id.slice(0, 8))}</span>` : ''}</td><td class="when">${esc(when(s.start, s.end))}</td><td>${esc(sessionModel(s))}</td>
     <td class="num">${fmt(billed(s.usage))}</td><td class="num">${pct(billed(s.usage), billed(r.usage))}</td><td class="num">${fmt(withCache(s.usage))}</td>
     <td class="num">${s.usage.calls}</td><td class="num">${s.usage.errors || ''}</td></tr>`).join('')}
   </tbody></table></div>`;
@@ -76,12 +76,13 @@ function modelsTable(r) {
   if (!rows.length || (rows.length === 1 && !rows[0].model)) return '';
   const total = rows.reduce((s, m) => s + m.input + m.output, 0);
   const max = Math.max(...rows.map((m) => m.input + m.output), 1);
+  const unknown = rows.find((m) => !m.model);
   return `<section class="models"><h2>${t.report.modelsTitle}</h2><p class="hint">${t.report.modelsHint}</p>
     <div class="scroll"><table><thead><tr>${t.report.modelCols.map((c, i) => `<th${i > 1 ? ' class="num"' : ''}>${c}</th>`).join('')}</tr></thead><tbody>
     ${rows.map((m) => { const tok = m.input + m.output; return `<tr><td><div class="bar" style="--w:${((100 * tok) / max).toFixed(1)}%"></div><span>${esc(modelName(m))}</span></td>
       <td>${esc(effortLabel(m.effort))}</td><td class="num">${fmt(m.calls)}</td><td class="num">${m.known ? fmt(tok) : '–'}</td><td class="num">${m.known ? pct(tok, total) : '–'}</td>
       <td class="num">${m.known ? fmt(tok / m.known) : '–'}</td><td class="num">${m.known ? fmt(tok + m.cache) : '–'}</td><td class="num">${m.convs}</td></tr>`; }).join('')}
-    </tbody></table></div></section>`;
+    </tbody></table></div>${unknown ? `<p class="hint">${esc(t.report.modelsUnknown(fmt(unknown.calls)))}</p>` : ''}</section>`;
 }
 
 // --- Usage chart ---
@@ -114,12 +115,33 @@ function buckets(r) {
   return { weekly, rows: [...byKey.values()] };
 }
 
+// Mean tokens per call: unlike the total, it doesn't follow how much the agent was used that day.
+const perCall = (x) => (x.calls ? x.billed / x.calls : 0);
+
 function chart(r) {
   const b = buckets(r);
   if (!b) return '';
+  const title = b.weekly ? t.report.chartTitleWeek : t.report.chartTitleDay;
+  const rows = b.rows.filter((x) => x.calls);
+  return `<section class="chart">
+    <h2>${title}</h2>
+    <div class="mode" role="group" aria-label="${esc(t.report.chartModeLabel)}">
+      <button type="button" data-mode="total" aria-pressed="true">${t.report.chartModeTotal}</button><button type="button" data-mode="call" aria-pressed="false">${t.report.chartModeCall}</button></div>
+    <p class="hint" data-mode="total">${t.report.chartHint}</p>
+    <p class="hint" data-mode="call" hidden>${t.report.chartHintCall}</p>
+    <div class="plot" data-mode="total">${plot(b, (x) => x.billed, (x) => `${fmt(x.billed)} tokens`, (x) => `${fmt(x.billed + x.cache)} ${t.report.withCacheShort}`, title)}</div>
+    <div class="plot" data-mode="call" hidden>${plot(b, perCall, (x) => t.report.perCallTip(fmt(perCall(x))), (x) => `${fmt(perCall(x) + x.cache / x.calls)} ${t.report.withCacheShort}`, `${title} · ${t.report.chartModeCall}`)}</div>
+    <details><summary>${t.report.chartTable}</summary><div class="scroll"><table><thead><tr>${(b.weekly ? t.report.chartColsWeek : t.report.chartCols).map((c, i) => `<th${i ? ' class="num"' : ''}>${c}</th>`).join('')}</tr></thead><tbody>
+      ${rows.map((x) => `<tr><td>${esc(shortDate(x.date, true))}</td><td class="num">${fmt(x.billed)}</td><td class="num">${fmt(x.billed + x.cache)}</td><td class="num">${x.calls}</td><td class="num">${fmt(perCall(x))}</td></tr>`).join('')}
+    </tbody></table></div></details>
+  </section>`;
+}
+
+// One column chart of `value` per bucket; `tip` and `cache` are the tooltip's headline and cache line.
+function plot(b, value, tip, cache, label) {
   const W = 900, H = 240, m = { l: 56, r: 8, t: 12, b: 28 };
   const pw = W - m.l - m.r, ph = H - m.t - m.b;
-  const top = niceMax(Math.max(...b.rows.map((x) => x.billed)));
+  const top = niceMax(Math.max(...b.rows.map(value)));
   const band = pw / b.rows.length;
   const bw = Math.max(1, Math.min(24, band - 2));
   const y = (v) => m.t + ph - (v / top) * ph;
@@ -129,28 +151,20 @@ function chart(r) {
     <text x="${m.l - 8}" y="${y(v) + 4}" text-anchor="end" class="axis">${esc(compact(v))}</text>`).join('');
   // Rounded data end (4px), square at the baseline.
   const bars = b.rows.map((x, i) => {
-    const h = (x.billed / top) * ph;
+    const h = (value(x) / top) * ph;
     if (h <= 0) return '';
     const x0 = m.l + i * band + (band - bw) / 2, y0 = m.t + ph - h, rr = Math.min(4, h, bw / 2);
     return `<path class="col" d="M${x0},${m.t + ph}V${y0 + rr}Q${x0},${y0} ${x0 + rr},${y0}H${x0 + bw - rr}Q${x0 + bw},${y0} ${x0 + bw},${y0 + rr}V${m.t + ph}Z"/>`;
   }).join('');
   // Hit targets: the whole band, so a 2px column is as easy to hover as a 24px one.
   const hits = b.rows.map((x, i) => `<rect class="hit" x="${m.l + i * band}" y="${m.t}" width="${band}" height="${ph}"
-    data-when="${esc(when(x))}" data-v="${esc(fmt(x.billed))}" data-c="${esc(fmt(x.billed + x.cache))}" data-n="${esc(t.report.chartCalls(x.calls))}"/>`).join('');
+    data-when="${esc(when(x))}" data-v="${esc(x.calls ? tip(x) : t.report.noActivity)}" data-c="${esc(x.calls ? cache(x) : '')}" data-n="${esc(x.calls ? t.report.chartCalls(x.calls) : '')}"/>`).join('');
   const every = Math.max(1, Math.ceil(b.rows.length / 6));
   // A date every few columns, plus the last one when it isn't crowded by the previous label.
   const last = b.rows.length - 1;
   const ticks = b.rows.map((x, i) => (i % every === 0 || (i === last && last % every >= every / 2)) && `<text x="${i === 0 && band < 40 ? m.l : i === last && band < 40 ? W - m.r : m.l + i * band + band / 2}" y="${H - 8}" text-anchor="${i === 0 && band < 40 ? 'start' : i === last && band < 40 ? 'end' : 'middle'}" class="axis">${esc(shortDate(x.date))}</text>`).filter(Boolean).join('');
 
-  const rows = b.rows.filter((x) => x.calls);
-  return `<section class="chart">
-    <h2>${b.weekly ? t.report.chartTitleWeek : t.report.chartTitleDay}</h2>
-    <p class="hint">${t.report.chartHint}</p>
-    <div class="plot"><svg viewBox="0 0 ${W} ${H}" role="img" aria-label="${esc(b.weekly ? t.report.chartTitleWeek : t.report.chartTitleDay)}">${grid}${bars}${ticks}${hits}</svg></div>
-    <details><summary>${t.report.chartTable}</summary><div class="scroll"><table><thead><tr>${(b.weekly ? t.report.chartColsWeek : t.report.chartCols).map((c, i) => `<th${i ? ' class="num"' : ''}>${c}</th>`).join('')}</tr></thead><tbody>
-      ${rows.map((x) => `<tr><td>${esc(shortDate(x.date, true))}</td><td class="num">${fmt(x.billed)}</td><td class="num">${fmt(x.billed + x.cache)}</td><td class="num">${x.calls}</td></tr>`).join('')}
-    </tbody></table></div></details>
-  </section>`;
+  return `<svg viewBox="0 0 ${W} ${H}" role="img" aria-label="${esc(label)}">${grid}${bars}${ticks}${hits}</svg>`;
 }
 
 // --- Page ---
@@ -218,6 +232,12 @@ function htmlViews(views, { scope }) {
   .filter button:hover { background: var(--accent-soft); }
   .filter button[aria-pressed="true"] { background: var(--accent); border-color: var(--accent); color: var(--surface); font-weight: 600; }
   .filter button:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+  .mode { display: inline-flex; margin: 0 0 0 12px; vertical-align: 3px; border: 1px solid var(--line); border-radius: 6px; overflow: hidden; }
+  .mode button { font: 13px system-ui, sans-serif; color: var(--fg); background: var(--surface); border: 0; padding: 3px 10px; cursor: pointer; }
+  .mode button + button { border-left: 1px solid var(--line); }
+  .mode button:hover { background: var(--accent-soft); }
+  .mode button[aria-pressed="true"] { background: var(--accent-soft); color: var(--accent); font-weight: 600; }
+  .mode button:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; }
   .tiles { display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 12px; margin: 16px 0 20px; }
   .tiles div { background: var(--surface); border: 1px solid var(--line); border-radius: 8px; padding: 12px 14px; }
   .tiles b { display: block; font-size: 24px; font-variant-numeric: tabular-nums; } .tiles span { color: var(--muted); font-size: 14px; }
@@ -270,6 +290,13 @@ function htmlViews(views, { scope }) {
       for (const s of document.querySelectorAll('.view')) s.hidden = s.dataset.view !== v.dataset.view;
       return;
     }
+    // Chart mode: the same in every period, so switching periods keeps it.
+    const m = e.target.closest('.mode button');
+    if (m) {
+      for (const b of document.querySelectorAll('.mode button')) b.setAttribute('aria-pressed', String(b.dataset.mode === m.dataset.mode));
+      for (const p of document.querySelectorAll('.chart [data-mode]:not(button)')) p.hidden = p.dataset.mode !== m.dataset.mode;
+      return;
+    }
     const b = e.target.closest('.copy'); if (!b) return;
     const pre = b.parentElement.querySelector('pre');
     const ok = () => { b.textContent = ${JSON.stringify(t.report.copied)}; setTimeout(() => (b.textContent = ${JSON.stringify(t.report.copy)}), 1500); };
@@ -284,9 +311,10 @@ function htmlViews(views, { scope }) {
     const h = e.target.closest && e.target.closest('.hit');
     if (!h) { tip.hidden = true; return; }
     const [v, when, rest] = tip.children;
-    v.textContent = h.dataset.v + ' tokens';
+    v.textContent = h.dataset.v;
     when.textContent = h.dataset.when;
-    rest.textContent = h.dataset.n + ' · ' + h.dataset.c + ' ' + ${JSON.stringify(t.report.withCacheShort)};
+    rest.textContent = h.dataset.c ? h.dataset.n + ' · ' + h.dataset.c : h.dataset.n;
+    rest.hidden = !rest.textContent;
     tip.hidden = false;
     const x = Math.min(e.clientX + 14, innerWidth - tip.offsetWidth - 8);
     tip.style.left = x + 'px';
@@ -316,7 +344,7 @@ function text(r, found, { scope, paths }) {
     const top = r.sessions.filter((s) => s.usage).slice(0, 5);
     out.push(t.report.topSessions(top.length));
     for (const s of top) {
-      out.push(`    ${fmt(billed(s.usage)).padStart(10)}  ${pct(billed(s.usage), billed(u)).padStart(4)}  ${t.report.sessionLine(s.id.slice(0, 8), s.usage.calls, s.usage.errors, fmt(withCache(s.usage)), sessionModel(s), when(s.start, s.end))}`);
+      out.push(`    ${fmt(billed(s.usage)).padStart(10)}  ${pct(billed(s.usage), billed(u)).padStart(4)}  ${t.report.sessionLine(s.id.slice(0, 8), s.usage.calls, s.usage.errors, fmt(withCache(s.usage)), sessionModel(s), when(s.start, s.end), s.title)}`);
     }
   }
   out.push(t.report.top5(pct(top5, r.tokens), r.reads, r.rereads, pct(r.rereads, r.reads)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-insights",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Measures Antigravity CLI token usage and shows which context is sent repeatedly or needlessly, in English or Spanish. Run: npx agy-insights@latest",
   "license": "MIT",
   "keywords": [