agy-insights 0.7.2 → 0.7.3

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.7.3`.
 
 **Instalándolo globalmente:**
 
@@ -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.7.3`.
 
 **Globally:**
 
@@ -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,6 +83,20 @@ 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];
 
@@ -104,6 +119,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);

package/docs/how-it-works.md

@@ -34,10 +34,10 @@ 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.
 

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'],
@@ -158,7 +165,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 +189,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 +203,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 +256,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 +287,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'],
@@ -319,7 +333,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 ---
@@ -316,7 +317,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.7.3",
   "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": [