agy-insights 0.4.0 → 0.7.1

package/README.es.md

@@ -10,8 +10,8 @@ Te muestra qué contexto le estás mandando a **Antigravity** de forma repetida
 - Funciona con cualquier editor, en Windows, macOS y Linux.
 
 ```sh
-npx agy-insights          # informe HTML en el navegador
-npx agy-insights --text   # resumen en la terminal
+npx agy-insights@latest         # informe HTML en el navegador
+npx agy-insights@latest --text  # resumen en la terminal
 ```
 
 Solo necesitas Node.js 20 o superior y haber usado Antigravity CLI (`agy`) en el equipo. La salida sale en español o en inglés según el idioma del sistema; puedes forzarlo con `--lang es` o `--lang en`.
@@ -33,10 +33,10 @@ No tiene dependencias. Elige una forma:
 
 ```sh
 npx agy-insights
-npx agy-insights --text
+npx agy-insights@latest --text
 ```
 
-Para fijar una versión: `npx agy-insights@0.4.0`.
+`@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.1`.
 
 **Instalándolo globalmente:**
 
@@ -45,13 +45,15 @@ npm install -g agy-insights
 agy-insights
 ```
 
+Para actualizarlo: `npm install -g agy-insights@latest`.
+
 **Clonando el repositorio:**
 
 ```sh
 git clone https://github.com/migohe14/agy-insights.git
 ```
 
-Y ejecútalo con `node agy-insights/agy-insights.js` en lugar de `npx agy-insights`. Para actualizar: `git pull` dentro de la carpeta.
+Y ejecútalo con `node agy-insights/agy-insights.js` en lugar de `npx agy-insights@latest`. Para actualizar: `git pull` dentro de la carpeta.
 
 ## Usar
 
@@ -59,18 +61,19 @@ Y ejecútalo con `node agy-insights/agy-insights.js` en lugar de `npx agy-insigh
 npx agy-insights
 ```
 
-Analiza todo tu historial, guarda un informe HTML en la carpeta temporal y lo abre en el navegador.
+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.
 
 | Para… | Ejecuta |
 |---|---|
-| Ver solo un proyecto | `npx agy-insights --project C:\dev\mi-proyecto` |
-| Ver el proyecto de la carpeta actual | `npx agy-insights --project .` |
-| Un resumen en la terminal | `npx agy-insights --text` |
-| El resumen con rutas y exclusiones | `npx agy-insights --text --paths` |
-| Un mapa del proyecto para pegar en `AGENTS.md` (carpetas, ficheros grandes, carpetas generadas; ~20 líneas aunque el repo sea grande) | `npx agy-insights --map --project <carpeta>` |
-| Elegir el idioma (español o inglés) | `npx agy-insights --lang es` |
-| Guardar el informe en otro sitio | `npx agy-insights --out informe.html --no-open` |
-| Ver todas las opciones | `npx agy-insights --help` |
+| Ver solo un proyecto | `npx agy-insights@latest --project C:\dev\mi-proyecto` |
+| Ver el proyecto de la carpeta actual | `npx agy-insights@latest --project .` |
+| Un resumen en la terminal | `npx agy-insights@latest --text` |
+| El resumen con rutas y exclusiones | `npx agy-insights@latest --text --paths` |
+| Un mapa del proyecto para pegar en `AGENTS.md` (carpetas, ficheros grandes, carpetas generadas; ~20 líneas aunque el repo sea grande) | `npx agy-insights@latest --map --project <carpeta>` |
+| Solo un periodo a medida (el informe ya no tiene selector de periodo) | `npx agy-insights@latest --since 2026-10-01` o `--days 14` |
+| Elegir el idioma (español o inglés) | `npx agy-insights@latest --lang es` |
+| Guardar el informe en otro sitio | `npx agy-insights@latest --out informe.html --no-open` |
+| Ver todas las opciones | `npx agy-insights@latest --help` |
 
 El informe da dos cifras:
 
@@ -79,12 +82,12 @@ El informe da dos cifras:
 
 ## Leer el informe
 
-Arriba están los totales. 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; 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 |
 |---|---|---|
 | El agente vuelve a leer lo que ya tenía | Lee otra vez un trozo de fichero que ya estaba en la conversación | Sesiones más cortas, una por tarea, o `/compact`. No excluyas el fichero: lo necesita. |
-| Ficheros generados, compilados o de dependencias | Lecturas de `bin/`, `obj/`, `dist/`, `node_modules`, migraciones, lockfiles o logs | Si no hacían falta, exclúyelos (ver abajo) |
+| Ficheros generados, compilados o de dependencias | Lecturas de `bin/`, `obj/`, `dist/`, `node_modules`, migraciones, lockfiles o logs (nunca cuentan los ficheros propios de Antigravity en `~/.gemini`, como su brain, ni una carpeta `build/` o `bin/` que git mantiene en el repo, como una configuración de webpack) | Si no hacían falta, exclúyelos (ver abajo) |
 | Los mismos ficheros entran en muchas sesiones | Un fichero se lee en varias conversaciones distintas | Si es código central es normal; si es grande, dile al agente qué parte mirar |
 | Comandos con salidas muy largas | La salida de tests o builds entra entera | Pide ejecutar solo el test o proyecto afectado |
 | Sesiones muy largas | Todo lo acumulado se reenvía en cada turno | Una conversación nueva por tarea |

package/README.md

@@ -10,8 +10,8 @@ Shows which context you are sending to **Antigravity** repeatedly or needlessly,
 - Works with any editor, on Windows, macOS and Linux.
 
 ```sh
-npx agy-insights          # HTML report in the browser
-npx agy-insights --text   # summary in the terminal
+npx agy-insights@latest         # HTML report in the browser
+npx agy-insights@latest --text  # summary in the terminal
 ```
 
 All you need is Node.js 20 or later and to have used Antigravity CLI (`agy`) on this machine. The output is in English or Spanish, following your system language; force it with `--lang en` or `--lang es`.
@@ -33,10 +33,10 @@ It has no dependencies. Pick one:
 
 ```sh
 npx agy-insights
-npx agy-insights --text
+npx agy-insights@latest --text
 ```
 
-To pin a version: `npx agy-insights@0.4.0`.
+`@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.1`.
 
 **Globally:**
 
@@ -45,13 +45,15 @@ npm install -g agy-insights
 agy-insights
 ```
 
+To update it: `npm install -g agy-insights@latest`.
+
 **From the repository:**
 
 ```sh
 git clone https://github.com/migohe14/agy-insights.git
 ```
 
-Then run it with `node agy-insights/agy-insights.js` instead of `npx agy-insights`. To update: `git pull` inside the folder.
+Then run it with `node agy-insights/agy-insights.js` instead of `npx agy-insights@latest`. To update: `git pull` inside the folder.
 
 ## Usage
 
@@ -59,18 +61,19 @@ Then run it with `node agy-insights/agy-insights.js` instead of `npx agy-insight
 npx agy-insights
 ```
 
-Analyzes your whole history, saves an HTML report in the temp folder and opens it in the browser.
+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.
 
 | To… | Run |
 |---|---|
-| See only one project | `npx agy-insights --project C:\dev\my-project` |
-| See the project in the current folder | `npx agy-insights --project .` |
-| Get a summary in the terminal | `npx agy-insights --text` |
-| Get the summary with paths and exclusions | `npx agy-insights --text --paths` |
-| Get a project map to paste into `AGENTS.md` (folders, large files, generated folders; ~20 lines even for a large repo) | `npx agy-insights --map --project <folder>` |
-| Choose the language (English or Spanish) | `npx agy-insights --lang es` |
-| Save the report somewhere else | `npx agy-insights --out report.html --no-open` |
-| See all options | `npx agy-insights --help` |
+| See only one project | `npx agy-insights@latest --project C:\dev\my-project` |
+| See the project in the current folder | `npx agy-insights@latest --project .` |
+| Get a summary in the terminal | `npx agy-insights@latest --text` |
+| Get the summary with paths and exclusions | `npx agy-insights@latest --text --paths` |
+| Get a project map to paste into `AGENTS.md` (folders, large files, generated folders; ~20 lines even for a large repo) | `npx agy-insights@latest --map --project <folder>` |
+| Only a custom period (the report then has no period selector) | `npx agy-insights@latest --since 2026-10-01` or `--days 14` |
+| Choose the language (English or Spanish) | `npx agy-insights@latest --lang es` |
+| Save the report somewhere else | `npx agy-insights@latest --out report.html --no-open` |
+| See all options | `npx agy-insights@latest --help` |
 
 The report gives two figures:
 
@@ -79,12 +82,12 @@ The report gives two figures:
 
 ## Reading the report
 
-The totals are at the top. 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; 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 |
 |---|---|---|
 | The agent re-reads what it already had | It reads again a chunk of a file that was already in the conversation | Shorter sessions, one per task, or `/compact`. Don't exclude the file: the agent needs it. |
-| Generated, build or dependency files are being read | Reads from `bin/`, `obj/`, `dist/`, `node_modules`, migrations, lockfiles or logs | If they weren't needed, exclude them (see below) |
+| Generated, build or dependency files are being read | Reads from `bin/`, `obj/`, `dist/`, `node_modules`, migrations, lockfiles or logs (Antigravity's own files in `~/.gemini`, such as its brain, never count; nor does a `build/` or `bin/` folder that git keeps in the repo, like a webpack config) | If they weren't needed, exclude them (see below) |
 | The same files enter many sessions | A file is read in several different conversations | Normal for core code; if it is large, tell the agent which part to look at |
 | Commands with very long output | The full output of tests or builds enters the context | Ask it to run only the affected test or project |
 | Very long sessions | Everything accumulated is resent on every turn | A new conversation per task |

package/agy-insights.js

@@ -30,6 +30,8 @@ function parseArgs(argv) {
     else if (a === '--dir') opts.dir = path.resolve(value());
     else if (a === '--config') opts.config = path.resolve(value());
     else if (a === '--lang') opts.lang = value();
+    else if (a === '--since') opts.since = value();
+    else if (a === '--days') opts.days = value();
     else fail(t.unknownOption(a));
   }
   return opts;
@@ -65,6 +67,24 @@ function openInBrowser(file) {
   } catch { /* the path is printed anyway */ }
 }
 
+// --since YYYY-MM-DD (local midnight) or --days n (n days back from now), as a time in ms; null for all.
+function sinceTime({ since, days }) {
+  if (since) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(since);
+    const d = m && new Date(+m[1], m[2] - 1, +m[3]);
+    if (!d || d.getMonth() !== m[2] - 1) fail(t.badDate(since));
+    return d.getTime();
+  }
+  if (days !== undefined) {
+    if (!/^\d+$/.test(days)) fail(t.badDays(days));
+    return Date.now() - Number(days) * 24 * 60 * 60 * 1000;
+  }
+  return null;
+}
+
+// Periods the HTML report can switch to, besides the whole history.
+const PRESET_DAYS = [90, 30, 7];
+
 async function main() {
   const argv = process.argv.slice(2);
   // Language first, so that option errors are already in it.
@@ -76,28 +96,40 @@ async function main() {
   if (!opts.lang && cfg.lang && !setLang(cfg.lang)) fail(t.badLang(cfg.lang));
 
   if (opts.map) opts.project = opts.project || process.cwd();
-  const r = await analyze({
+  const since = sinceTime(opts);
+  const run = (from) => analyze({
+    since: from,
     dir: opts.dir || cfg.conversationsDir || DEFAULT_DIR,
     workspaces: opts.project ? [opts.project] : [],
     customKinds: cfg.customKinds || {},
   });
+  const r = await run(since);
   if (opts.map) {
     const m = buildMap(opts.project, { ...cfg.map, history: r.files });
     console.log(m.block);
     return console.error(t.mapDone(m.tokens, path.join(opts.project, 'AGENTS.md')));
   }
-  const found = findings(r, {
+  const find = (x) => findings(x, {
     crossSessionMin: cfg.crossSessionMin ?? DEFAULTS.crossSessionMin,
     heavyOutputTokens: cfg.heavyOutputTokens ?? DEFAULTS.heavyOutputTokens,
     longSessionTokens: cfg.longSessionTokens ?? DEFAULTS.longSessionTokens,
   });
+  const found = find(r);
 
   if (opts.text) return process.stdout.write(report.text(r, found, { scope: opts.project, paths: opts.paths }));
 
   const stamp = new Date().toISOString().slice(0, 16).replace(/[-:T]/g, '');
   const out = opts.out || path.join(os.tmpdir(), 'agy-insights', `${t.reportName}-${stamp}.html`);
   fs.mkdirSync(path.dirname(out), { recursive: true });
-  fs.writeFileSync(out, report.html(r, found, { scope: opts.project }));
+  // Whole history by default, plus the presets the page can switch to. With --since/--days, just that period.
+  const views = [{ key: 'all', label: since ? '' : t.report.rangeAll, r, found }];
+  if (!since && r.conversations) {
+    for (const days of PRESET_DAYS) {
+      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) });
+    }
+  }
+  fs.writeFileSync(out, report.htmlViews(views, { scope: opts.project }));
   console.log(t.done(r.conversations, found.length, out));
   if (opts.open) openInBrowser(out);
 }

package/docs/how-it-works.md

@@ -34,9 +34,13 @@ 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`: configuration of each model call, including the model name.
+- 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.
 - 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.
+
+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.
+
 `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.
 
 ### SQLite
@@ -54,6 +58,10 @@ The project of each file is detected by walking up its path until a folder with
 
 All user-facing text lives in `lib/i18n.js`, in an `en` and an `es` table with the same keys (a test checks it). Modules read it through `t`, which always points at the current language. The language comes from `--lang`, then the `lang` config key, then the system locale (`LC_ALL`, `LC_MESSAGES`, `LANG`, `LANGUAGE`, or `Intl`): Spanish if it starts with `es`, English otherwise. Numbers follow it too (`en-US` / `es-ES`).
 
+Folder names alone are not enough for build output: `build/webpack/` or `bin/` often hold sources. When the file's repo is on this machine, `repoFiles()` asks git for the files it does not ignore (`git ls-files --cached --others --exclude-standard`, once per repo), and a file in that list is never kind `build`. `--map` does the same, since it lists files through git. Without git, or for a repo that is not on this machine, the folder name decides.
+
+Anything under `~/.gemini/` is kind `agent`: the agent's own brain (plans, artifacts, its logs) and skills. It is checked first and is not in `NON_SOURCE`, so those reads are never reported as generated files or proposed for exclusion, even when a path contains `out/` or ends in `.log`.
+
 Built-in file kinds are stable ids (`build`, `logs`, `generated`, `code .cs`…) and are only turned into text when shown, with `kindLabel()`. Kinds from `customKinds` are shown as the user wrote them.
 
 To add a message, add it to both tables. To add a language, add a table and teach `detect()` to pick it.

package/lib/history.js

@@ -5,12 +5,29 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { spawnSync } = require('child_process');
 
 const DEFAULT_DIR = path.join(os.homedir(), '.gemini', 'antigravity-cli', 'conversations');
 const BYTES_PER_TOKEN = 4;
 const TOOL_RE = /^[a-z][a-z0-9_]{2,40}$/;
 const FILE_KEYS = ['AbsolutePath', 'TargetFile', 'FilePath', 'File', 'Path'];
-const MODEL_RE = /\b(gemini-[\w.-]+|Gemini \d[\w. ]*\((?:Low|Medium|High)\)|Claude \w+ [\d.]+ \(\w+\))/g;
+// Model of a call, as agy names it in gen_metadata: "Gemini 3.8 Flash (High)" (name and effort level), or
+// the id "gemini-3.8-flash-high" when the display name is missing.
+// Whole strings only, so that prose in the system prompt that mentions a model is not taken for one.
+const MODEL_NAME_RE = /^((?:Gemini|Claude|GPT)[\w .-]*?) \(([A-Za-z][A-Za-z ]{1,15})\)$/;
+const MODEL_ID_RE = /^((?:gemini|claude|gpt)-[\w.-]*?)-(minimal|low|medium|high|xhigh|max)$/;
+
+function modelOf(strs) {
+  for (const s of strs) {
+    const m = s.length < 200 && MODEL_NAME_RE.exec(s);
+    if (m) return { model: m[1].trim(), effort: m[2].trim() };
+  }
+  for (const s of strs) {
+    const m = s.length < 200 && MODEL_ID_RE.exec(s);
+    if (m) return { model: m[1], effort: m[2] };
+  }
+  return { model: null, effort: null };
+}
 
 // --- SQLite access: node:sqlite when the runtime has it (Node >= 22.13), sql.js (WASM) otherwise. ---
 
@@ -109,9 +126,18 @@ const key = (p) => norm(p).toLowerCase().replace(/\/+$/, '');
 // Kinds are stable ids; i18n.kindLabel() turns them into text.
 const NON_SOURCE = new Set(['node_modules', 'build', 'lockfiles', 'logs', 'generated']);
 
-function kind(p) {
+/**
+ * @param {string} p path with "/" separators
+ * @param {object} [opts]
+ * @param {boolean} [opts.inRepo] git says the file is part of the repo (not ignored): a build/ or bin/
+ *   folder then holds sources (webpack config, CLI scripts), not build output.
+ */
+function kind(p, { inRepo = false } = {}) {
+  // Antigravity's own data (the agent's brain: plans, artifacts, logs; and skills): it needs them, so they
+  // are never reported as generated or proposed for exclusion, whatever their names look like.
+  if (/(^|\/)\.gemini\//i.test(p)) return 'agent';
   if (/(^|\/)node_modules\//.test(p)) return 'node_modules';
-  if (/(^|\/)(dist|build|out|target|coverage|\.next|bin|obj)\//i.test(p)) return 'build';
+  if (!inRepo && /(^|\/)(dist|build|out|target|coverage|\.next|bin|obj)\//i.test(p)) return 'build';
   if (/(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|packages\.lock\.json|\.lock)$/.test(p)) return 'lockfiles';
   if (/\.(log|map)$|\.min\.(js|css)$/.test(p)) return 'logs';
   if (/(^|\/)(tests?|__tests__|specs?)\//i.test(p) || /\.(test|spec|tests?)\.\w+$/i.test(p) || /Tests?\//.test(p)) return 'tests';
@@ -120,6 +146,17 @@ function kind(p) {
   return ext ? `code ${ext}` : 'other';
 }
 
+// Files of a git repo that git does not ignore (tracked, or untracked and not ignored), lowercased and
+// relative to the root; null when git cannot tell (no git, or the repo is not on this machine).
+const repoFilesCache = new Map();
+function repoFiles(root) {
+  if (!repoFilesCache.has(root)) {
+    const git = spawnSync('git', ['ls-files', '--cached', '--others', '--exclude-standard', '-z'], { cwd: root, encoding: 'utf8', maxBuffer: 1 << 28, windowsHide: true });
+    repoFilesCache.set(root, git.status === 0 ? new Set(git.stdout.split('\0').filter(Boolean).map((f) => f.toLowerCase())) : null);
+  }
+  return repoFilesCache.get(root);
+}
+
 // Project root of a file: an explicit workspace containing it, or else the nearest folder with a .git
 // entry, when the path exists on this machine. Null when unknown (e.g. a repo that was deleted).
 const rootCache = new Map();
@@ -154,6 +191,9 @@ function locate(file, workspaces, depth = 3) {
 
 // --- Real usage ---
 
+// Local calendar day of a time, as YYYY-MM-DD.
+const dayKey = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`; };
+
 // What the model was actually billed for in a conversation, from the transcript agy keeps next to the
 // history (<conversations>/../brain/<id>/.system_generated/logs/transcript.jsonl): one line per step,
 // and model calls carry input, cache-read and output tokens. Subagents have their own conversation and
@@ -162,16 +202,28 @@ function realUsage(dir, id) {
   const file = path.join(dir, '..', 'brain', id, '.system_generated', 'logs', 'transcript.jsonl');
   let text;
   try { text = fs.readFileSync(file, 'utf8'); } catch { return null; }
-  const u = { calls: 0, input: 0, cache: 0, output: 0, errors: 0 };
+  // `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).
+  const u = { calls: 0, input: 0, cache: 0, output: 0, errors: 0, start: null, end: null, days: new Map(), perCall: [] };
   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 !== '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 });
+    const k = at ? dayKey(at) : null;
+    const d = u.days.get(k) || { calls: 0, input: 0, cache: 0, output: 0 };
+    d.calls++;
+    d.input += Number(e.input_tokens) || 0;
+    d.cache += Number(e.cache_read_tokens) || 0;
+    d.output += Number(e.output_tokens) || 0;
+    u.days.set(k, d);
   }
   return u;
 }
@@ -194,23 +246,36 @@ class Counter {
  * @param {string} [opts.dir] conversations directory
  * @param {string[]} [opts.workspaces] only count conversations that touched these folders (all if empty)
  * @param {Object<string,string>} [opts.customKinds] regex -> label, checked before the built-in types
+ * @param {number} [opts.since] only conversations whose last activity is at or after this time (ms)
  */
-async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {} } = {}) {
+async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, since = null } = {}) {
   const custom = Object.entries(customKinds).map(([re, label]) => [new RegExp(re, 'i'), label]);
-  const classify = (p) => custom.find(([re]) => re.test(p))?.[1] || kind(p);
+  // A file git keeps in the repo is never build output, whatever its folder is called.
+  const classify = (p, root, rel) => custom.find(([re]) => re.test(p))?.[1]
+    || kind(p, { inRepo: Boolean(root && repoFiles(root)?.has(rel.toLowerCase())) });
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'agy-insights-'));
   const r = {
     dir, backend: nodeSqlite ? 'node:sqlite' : 'sql.js', conversations: 0, unreadable: 0, steps: 0, tokens: 0,
+    since, period: null, olderSkipped: 0,
     toolCallsFound: 0, reads: 0, rangedReads: 0, linesRead: 0, rereads: 0, rereadTokens: 0, sessions: [],
     usage: { conversations: 0, calls: 0, input: 0, cache: 0, output: 0, errors: 0 },
   };
   const tools = new Counter(), kinds = new Counter(), folders = new Counter(), files = new Counter();
-  const commands = new Counter(), models = new Counter(), projects = new Counter();
+  const commands = new Counter(), projects = new Counter();
+  const models = new Map(); // "model|effort" -> calls and real tokens
+  const daily = new Map(); // YYYY-MM-DD -> real usage that day
+  const firstDay = since ? dayKey(since) : '';
   const wsKeys = workspaces.map(key);
 
   try {
     const dbs = fs.existsSync(dir) ? fs.readdirSync(dir).filter((f) => /^[0-9a-f-]{36}\.db$/i.test(f)) : [];
     for (const f of dbs) {
+      // When it happened: the transcript's step times, else the database's last write.
+      const id = f.replace(/\.db$/, '');
+      const usage = realUsage(dir, id);
+      const end = usage?.end ?? fs.statSync(path.join(dir, f)).mtimeMs;
+      const start = usage?.start ?? end;
+      if (since && end < since) { r.olderSkipped++; continue; }
       let db;
       try { db = await openDb(path.join(dir, f), tmp); } catch { r.unreadable++; continue; }
       try {
@@ -223,6 +288,7 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {} }
         }
 
         r.conversations++;
+        r.period = { from: Math.min(r.period?.from ?? start, start), to: Math.max(r.period?.to ?? end, end) };
         let convBytes = 0;
         const seenRanges = new Set(), seenFiles = new Set(), seenFolders = new Set(), seenKinds = new Set(), seenProjects = new Set();
         const seenCalls = new Map(); // call id -> 1 if that call re-read a range already read, else 0
@@ -260,7 +326,7 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {} }
 
             // Folders and files are keyed by absolute path: several projects can share relative paths.
             const { root, project, rel, folderRel, folderAbs } = locate(file, workspaces);
-            const k = classify(file);
+            const k = classify(file, root, rel);
             const fields = { calls, tokens, rereads: isNew ? reread : 0, rereadTokens: reread * tokens };
             kinds.add(k, { ...fields, convs: once(seenKinds, k) }, { nonSource: NON_SOURCE.has(k) });
             projects.add(root || '', { ...fields, convs: once(seenProjects, root || '') }, { project });
@@ -268,17 +334,38 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {} }
             files.add(key(file), { ...fields, convs: once(seenFiles, key(file)) }, { abs: file, rel, root, project, kind: k });
           });
         }
-        const id = f.replace(/\.db$/, '');
-        const usage = realUsage(dir, id);
         if (usage) {
           r.usage.conversations++;
           for (const k of ['calls', 'input', 'cache', 'output', 'errors']) r.usage[k] += usage[k];
+          for (const [k, v] of usage.days) {
+            const day = k || dayKey(end);
+            if (day < firstDay) continue;
+            const d = daily.get(day) || { day, calls: 0, input: 0, cache: 0, output: 0 };
+            for (const f of ['calls', 'input', 'cache', 'output']) d[f] += v[f];
+            daily.set(day, d);
+          }
         }
-        r.sessions.push({ id, steps: steps.length, tokens: convBytes / BYTES_PER_TOKEN, usage });
-        r.tokens += convBytes / BYTES_PER_TOKEN;
-        for (const [blob] of db.all('select data from gen_metadata')) {
-          for (const s of collect(blob)) for (const m of s.matchAll(MODEL_RE)) models.add(m[1], { calls: 1 });
+        // 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 };
+          e.calls++;
+          if (!seenModels.has(k)) { seenModels.add(k); e.convs++; }
+          const c = usage?.perCall[i];
+          if (c) { e.known++; e.input += c.input; e.cache += c.cache; e.output += c.output; }
+          models.set(k, e);
         }
+        // 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 });
+        r.tokens += convBytes / BYTES_PER_TOKEN;
       } catch { r.unreadable++; } finally { db.close(); }
     }
   } finally {
@@ -293,8 +380,10 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {} }
   return {
     ...r,
     tools: tools.all(), kinds: kinds.all(), folders: folders.all(), files: files.all(), projects: projects.all(),
-    commands: commands.all(), models: models.all(),
+    commands: commands.all(),
+    models: [...models.values()].sort((a, b) => b.input + b.output - (a.input + a.output) || b.calls - a.calls),
+    daily: [...daily.values()].sort((a, b) => (a.day < b.day ? -1 : 1)),
   };
 }
 
-module.exports = { analyze, DEFAULT_DIR, kind, NON_SOURCE, realUsage };
+module.exports = { analyze, DEFAULT_DIR, kind, NON_SOURCE, realUsage, dayKey, modelOf };

package/lib/i18n.js

@@ -17,6 +17,8 @@ Options:
   --map                 Print a project map (--project, or the current folder) for AGENTS.md
   --out <file>          Where to save the HTML report (default: the temp folder)
   --no-open             Don't open the browser
+  --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)
   --dir <folder>        Another history folder (default ${dir})
   --config <file>       Configuration (default ~/.agy-insights.json if it exists)
@@ -25,13 +27,16 @@ Options:
   missingValue: (opt) => `Missing value for ${opt}`,
   unknownOption: (opt) => `Unknown option: ${opt}. See --help.`,
   badLang: (v) => `Unsupported language: ${v}. Use en or es.`,
+  badDate: (v) => `Invalid date: ${v}. Use YYYY-MM-DD.`,
+  badDays: (v) => `Invalid number of days: ${v}.`,
   configNotFound: (f) => `Configuration file not found: ${f}`,
   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',
-  done: (convs, found, out) => `${convs} conversations analyzed, ${found} findings.\nReport: ${out}`,
+  done: (convs, found, out) => `${plural(convs, 'conversation', 'conversations')} analyzed, ${plural(found, 'finding', 'findings')}.\nReport: ${out}`,
 
   kinds: {
+    agent: "Antigravity's own files (brain, skills)",
     build: 'build output (dist, bin, obj…)', logs: 'logs, maps, minified', generated: 'generated code / migrations',
     other: 'other', code: (ext) => `code ${ext}`,
   },
@@ -78,7 +83,7 @@ Options:
     longSuggestion: 'A new conversation per task, or /compact when you change topic.',
     conversation: (id) => `conversation ${id}`,
     steps: (n) => plural(n, 'step', 'steps'),
-    longUsage: (calls, real, cached) => ` · ${calls} model calls, ${real} real tokens (${cached} with cache)`,
+    longUsage: (calls, real, cached) => ` · ${plural(calls, 'model call', 'model calls')}, ${real} real tokens (${cached} with cache)`,
   },
 
   map: {
@@ -99,11 +104,20 @@ Options:
     exampleRule: 'Example rule for AGENTS.md',
     exampleHint: "Add it to the project's AGENTS.md only if this happens often: rules are sent with every request.",
     cols: ['What', '~tokens', '%', 'Times', 'Sessions'],
+    modelsTitle: 'Models and effort',
+    modelsHint: 'Model and effort level (reasoning) of each model call, as agy records them. Higher effort usually means more tokens per call.',
+    modelCols: ['Model', 'Effort', 'Calls', 'Tokens', '%', 'Per call', 'With cache', 'Sessions'],
+    unknownModel: 'unknown',
+    modelsText: 'Models and effort:',
+    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`,
+    efforts: { minimal: 'Minimal', low: 'Low', medium: 'Medium', high: 'High', xhigh: 'Extra high', 'extra high': 'Extra high', max: 'Max' },
     sessionsTitle: 'Sessions (real usage)',
-    sessionCols: ['Conversation', 'Tokens', '%', 'With cache', 'Calls', 'Errors'],
+    sessionCols: ['Conversation', 'Model', 'Tokens', '%', 'With cache', 'Calls', 'Errors'],
     noConversations: (scope, dir) => `No conversations${scope ? ` for <code>${scope}</code>` : ''} in <code>${dir}</code>.`,
     tileReal: 'real tokens (input + output)',
-    tileCache: (calls) => `including cache · ${calls} calls`,
+    tileCache: (calls) => `including cache · ${plural(calls, 'call', 'calls')}`,
     tileContext: '~tokens in context',
     tileTop5: 'in the 5 largest sessions',
     tileReads: 'file reads',
@@ -116,18 +130,35 @@ Options:
     byKind: 'By file type', byFolder: 'By folder', files: 'Files', tools: 'Tools', commands: 'Commands',
     title: 'Context usage in Antigravity',
     project: 'Project', wholeHistory: 'Whole history',
-    meta: (convs, date) => `${convs} conversations · generated ${date}`,
-    footerReal: (missing) => `Real tokens: the ones Antigravity records in each conversation's log (subagents included)${missing ? `; ${missing} conversations have no log and are not counted` : ''}.`,
+    convs: (n) => plural(n, 'conversation', 'conversations'),
+    generated: (date) => `generated ${date}`,
+    filterLabel: 'Period',
+    rangeAll: 'All history',
+    rangeDays: (n) => `Last ${n} days`,
+    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'],
+    chartCalls: (n) => plural(n, 'call', 'calls'),
+    weekOf: (d) => `week of ${d}`,
+    withCacheShort: 'with cache',
+    period: (from, to) => (from === to ? `on ${from}` : `from ${from} to ${to}`),
+    since: (date) => `active since ${date}`,
+    olderSkipped: (n) => `${plural(n, 'older conversation', 'older conversations')} left out by the date filter`,
+    periodLine: (period, since) => `Period: ${period}${since ? ` (filter: ${since})` : ''}`,
+    footerReal: (missing) => `Real tokens: the ones Antigravity records in each conversation's log (subagents included)${missing ? `; ${plural(missing, 'conversation has', 'conversations have')} no log and ${missing === 1 ? 'is' : 'are'} not counted` : ''}.`,
     footerCache: 'It is unknown whether the quota counts cache the same as new input, so both figures are shown.',
     footerEstimate: '~tokens = stored size of each step / 4: useful to compare files and folders with each other.',
     footerPrivacy: 'The history was read from a copy and was not modified. This page contains paths from your projects: review it before sharing.',
     // Text summary
     history: 'History', projectLower: 'project',
-    summary: (convs, steps, tokens) => `${convs} conversations, ${steps} steps, ~${tokens} tokens in context (estimated)`,
-    realUsage: (real, input, output, cached, calls) => `Real usage: ${real} tokens (input ${input} + output ${output}), ${cached} including cache, in ${calls} model calls`,
-    noLog: (n) => ` (${n} conversations without a log)`,
-    topSessions: (n) => `  The ${n} sessions that use the most:`,
-    sessionLine: (id, calls, errors, cached) => `conversation ${id}  ${calls} calls${errors ? `, ${errors} errors` : ''}, ${cached} with cache`,
+    summary: (convs, steps, tokens) => `${plural(convs, 'conversation', 'conversations')}, ${plural(steps, 'step', 'steps')}, ~${tokens} tokens in context (estimated)`,
+    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) => `conversation ${id}${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:',
@@ -148,6 +179,8 @@ Opciones:
   --map                 Imprime un mapa del proyecto (--project, o la carpeta actual) para AGENTS.md
   --out <fichero>       Dónde guardar el informe HTML (por defecto, en la carpeta temporal)
   --no-open             No abrir el navegador
+  --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)
   --dir <carpeta>       Otra carpeta de historial (por defecto ${dir})
   --config <fichero>    Configuración (por defecto ~/.agy-insights.json si existe)
@@ -156,13 +189,16 @@ Opciones:
   missingValue: (opt) => `Falta el valor de ${opt}`,
   unknownOption: (opt) => `Opción desconocida: ${opt}. Usa --help.`,
   badLang: (v) => `Idioma no soportado: ${v}. Usa en o es.`,
+  badDate: (v) => `Fecha no válida: ${v}. Usa AAAA-MM-DD.`,
+  badDays: (v) => `Número de días no válido: ${v}.`,
   configNotFound: (f) => `No existe el fichero de configuración ${f}`,
   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',
-  done: (convs, found, out) => `${convs} conversaciones analizadas, ${found} hallazgos.\nInforme: ${out}`,
+  done: (convs, found, out) => `${plural(convs, 'conversación analizada', 'conversaciones analizadas')}, ${plural(found, 'hallazgo', 'hallazgos')}.\nInforme: ${out}`,
 
   kinds: {
+    agent: 'ficheros propios de Antigravity (brain, skills)',
     build: 'build output (dist, bin, obj…)', logs: 'logs, maps, minificados', generated: 'código generado / migraciones',
     other: 'otros', code: (ext) => `código ${ext}`,
   },
@@ -209,7 +245,7 @@ Opciones:
     longSuggestion: 'Una conversación nueva por tarea, o /compact cuando cambias de tema.',
     conversation: (id) => `conversación ${id}`,
     steps: (n) => plural(n, 'paso', 'pasos'),
-    longUsage: (calls, real, cached) => ` · ${calls} llamadas al modelo, ${real} tokens reales (${cached} con caché)`,
+    longUsage: (calls, real, cached) => ` · ${plural(calls, 'llamada', 'llamadas')} al modelo, ${real} tokens reales (${cached} con caché)`,
   },
 
   map: {
@@ -230,11 +266,20 @@ Opciones:
     exampleRule: 'Regla de ejemplo para AGENTS.md',
     exampleHint: 'Ponla en el AGENTS.md del proyecto solo si te pasa a menudo: las reglas se envían en cada petición.',
     cols: ['Qué', '~tokens', '%', 'Veces', 'Sesiones'],
+    modelsTitle: 'Modelos y esfuerzo',
+    modelsHint: 'Modelo y nivel de esfuerzo (razonamiento) de cada llamada al modelo, tal como los anota agy. Más esfuerzo suele suponer más tokens por llamada.',
+    modelCols: ['Modelo', 'Esfuerzo', 'Llamadas', 'Tokens', '%', 'Por llamada', 'Con caché', 'Sesiones'],
+    unknownModel: 'desconocido',
+    modelsText: 'Modelos y esfuerzo:',
+    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`,
+    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', 'Tokens', '%', 'Con caché', 'Llamadas', 'Errores'],
+    sessionCols: ['Conversación', 'Modelo', 'Tokens', '%', 'Con caché', 'Llamadas', 'Errores'],
     noConversations: (scope, dir) => `No hay conversaciones${scope ? ` de <code>${scope}</code>` : ''} en <code>${dir}</code>.`,
     tileReal: 'tokens reales (entrada + salida)',
-    tileCache: (calls) => `contando la caché · ${calls} llamadas`,
+    tileCache: (calls) => `contando la caché · ${plural(calls, 'llamada', 'llamadas')}`,
     tileContext: '~tokens en contexto',
     tileTop5: 'en las 5 sesiones más grandes',
     tileReads: 'lecturas de ficheros',
@@ -247,17 +292,34 @@ Opciones:
     byKind: 'Por tipo de fichero', byFolder: 'Por carpeta', files: 'Ficheros', tools: 'Herramientas', commands: 'Comandos',
     title: 'Uso de contexto en Antigravity',
     project: 'Proyecto', wholeHistory: 'Todo el historial',
-    meta: (convs, date) => `${convs} conversaciones · generado ${date}`,
-    footerReal: (missing) => `Tokens reales: los que Antigravity anota en el registro de cada conversación (incluidos subagentes)${missing ? `; ${missing} conversaciones no tienen registro y no cuentan` : ''}.`,
+    convs: (n) => plural(n, 'conversación', 'conversaciones'),
+    generated: (date) => `generado ${date}`,
+    filterLabel: 'Periodo',
+    rangeAll: 'Todo el historial',
+    rangeDays: (n) => `Últimos ${n} días`,
+    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'],
+    chartCalls: (n) => plural(n, 'llamada', 'llamadas'),
+    weekOf: (d) => `semana del ${d}`,
+    withCacheShort: 'con caché',
+    period: (from, to) => (from === to ? `el ${from}` : `del ${from} al ${to}`),
+    since: (date) => `con actividad desde el ${date}`,
+    olderSkipped: (n) => `${plural(n, 'conversación anterior queda fuera', 'conversaciones anteriores quedan fuera')} por el filtro de fechas`,
+    periodLine: (period, since) => `Periodo: ${period}${since ? ` (filtro: ${since})` : ''}`,
+    footerReal: (missing) => `Tokens reales: los que Antigravity anota en el registro de cada conversación (incluidos subagentes)${missing ? `; ${missing === 1 ? '1 conversación no tiene registro y no cuenta' : `${missing} conversaciones no tienen registro y no cuentan`}` : ''}.`,
     footerCache: 'No se sabe si la cuota cuenta la caché igual que la entrada nueva: por eso se muestran las dos cifras.',
     footerEstimate: '~tokens = tamaño guardado de cada paso / 4: sirve para comparar ficheros y carpetas entre sí.',
     footerPrivacy: 'El historial se ha leído desde una copia y no se ha modificado. Esta página contiene rutas de tus proyectos: no la compartas sin revisarla.',
     history: 'Historial', projectLower: 'proyecto',
-    summary: (convs, steps, tokens) => `${convs} conversaciones, ${steps} pasos, ~${tokens} tokens en contexto (estimado)`,
-    realUsage: (real, input, output, cached, calls) => `Consumo real: ${real} tokens (entrada ${input} + salida ${output}), ${cached} contando la caché, en ${calls} llamadas al modelo`,
-    noLog: (n) => ` (${n} conversaciones sin registro)`,
-    topSessions: (n) => `  Las ${n} sesiones que más gastan:`,
-    sessionLine: (id, calls, errors, cached) => `conversación ${id}  ${calls} llamadas${errors ? `, ${errors} errores` : ''}, ${cached} con caché`,
+    summary: (convs, steps, tokens) => `${plural(convs, 'conversación', 'conversaciones')}, ${plural(steps, 'paso', 'pasos')}, ~${tokens} tokens en contexto (estimado)`,
+    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) => `conversación ${id}${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:',
@@ -283,6 +345,7 @@ function setLang(lang) {
 const t = new Proxy({}, { get: (_, k) => LANGS[current][k] });
 const lang = () => current;
 const num = (n) => Math.round(n).toLocaleString(t.locale);
+const date = (ms) => new Date(ms).toLocaleDateString(t.locale, { day: 'numeric', month: 'short', year: 'numeric' });
 
 // Built-in kinds are stable ids (see history.js kind()); custom kinds from the config are shown as written.
 function kindLabel(k) {
@@ -290,4 +353,7 @@ function kindLabel(k) {
   return t.kinds[k] || k;
 }
 
-module.exports = { t, setLang, lang, detect, num, kindLabel, LANGS };
+// "High" / "high" → "High" or "Alto"; levels agy may add later are shown as written.
+const effortLabel = (e) => (e ? t.report.efforts[e.toLowerCase()] || e : t.report.unknownModel);
+
+module.exports = { t, setLang, lang, detect, num, date, kindLabel, effortLabel, LANGS };

package/lib/map.js

@@ -15,10 +15,10 @@ const SKIP_DIRS = new Set(['.git', 'node_modules', '.vs', '.vscode', '.idea', '.
 const BYTES_PER_TOKEN = 4;
 
 // Project files relative to `root`, with "/" separators: tracked plus untracked-but-not-ignored when
-// it is a git repo, else a plain walk.
+// it is a git repo (`inRepo`: none of them is ignored build output), else a plain walk.
 function listFiles(root) {
   const git = spawnSync('git', ['ls-files', '--cached', '--others', '--exclude-standard', '-z'], { cwd: root, encoding: 'utf8', maxBuffer: 1 << 28 });
-  if (git.status === 0) return [...new Set(git.stdout.split('\0').filter(Boolean))];
+  if (git.status === 0) return { files: [...new Set(git.stdout.split('\0').filter(Boolean))], inRepo: true };
   const out = [];
   const walk = (rel) => {
     for (const e of fs.readdirSync(path.join(root, rel), { withFileTypes: true })) {
@@ -27,7 +27,7 @@ function listFiles(root) {
     }
   };
   walk('');
-  return out;
+  return { files: out, inRepo: false };
 }
 
 // Line count of a text file; null for binaries or unreadable files.
@@ -71,11 +71,12 @@ function mainFolders(files, maxFolders) {
  */
 function buildMap(root, opts = {}) {
   const o = { ...DEFAULTS, ...opts };
-  const all = listFiles(root);
+  const { files: all, inRepo } = listFiles(root);
   const generated = new Set(), source = [];
   for (const f of all) {
-    const g = NON_SOURCE.has(kind(f)) ? generatedFolder(f) : null;
-    if (g) generated.add(g); else if (!NON_SOURCE.has(kind(f))) source.push(f);
+    const nonSource = NON_SOURCE.has(kind(f, { inRepo }));
+    const g = nonSource ? generatedFolder(f) : null;
+    if (g) generated.add(g); else if (!nonSource) source.push(f);
   }
   const reads = new Map((o.history || []).filter((h) => h.root).map((h) => [`${h.root}/${h.rel}`.toLowerCase(), h.calls]));
   const rootNorm = root.replace(/[\\/]+/g, '/').replace(/\/$/, '');

package/lib/report.js

@@ -1,11 +1,15 @@
 // Renders the analysis as a self-contained HTML page (opened in the browser) or as plain text.
-// The page is static: its only interaction is copying text, so it cannot change anything on disk.
+// The page is static: its only interactions are switching the period, the chart tooltip and copying text,
+// so it cannot change anything on disk.
 
-const { t, lang, num, kindLabel } = require('./i18n');
+const { t, lang, num, date, kindLabel, effortLabel } = require('./i18n');
+const { dayKey } = require('./history');
 
 const esc = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
 const fmt = num;
 const pct = (a, b) => (b ? `${Math.round((100 * a) / b)}%` : '–');
+// "Period: from 3 Oct 2026 to 29 Oct 2026 (filter: active since 1 Oct 2026)", or '' with no conversations.
+const periodLine = (r) => (r.period ? t.report.periodLine(t.report.period(date(r.period.from), date(r.period.to)), r.since && t.report.since(date(r.since))) : '');
 const label = (x) => (x.project ? `${x.project} › ${x.rel}` : x.abs || x.key);
 
 // Real usage, from agy's transcripts: what counts against the quota, unlike the size estimate.
@@ -55,55 +59,176 @@ function sessionsTable(r) {
   const rows = r.sessions.filter((s) => s.usage).slice(0, 15);
   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 ? ' 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>
+  return `<h3>${t.report.sessionsTitle}</h3><div class="scroll"><table><thead><tr>${t.report.sessionCols.map((c, i) => `<th${i > 1 ? ' 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>${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>`;
 }
 
-function html(r, found, { scope }) {
+// "Gemini 3.8 Flash · High", or "Gemini 3.8 Flash · High +1 more" when the session used several.
+const modelName = (m) => (m.model || t.report.unknownModel);
+const sessionModel = (s) => (s.model ? `${modelName(s.model)} · ${effortLabel(s.model.effort)}${s.models > 1 ? t.report.otherModels(s.models - 1) : ''}` : '');
+
+// Calls and real tokens per model and effort level.
+function modelsTable(r) {
+  const rows = r.models.filter((m) => m.model || m.calls);
+  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);
+  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>`;
+}
+
+// --- Usage chart ---
+
+const DAY = 24 * 60 * 60 * 1000;
+const parseDay = (k) => { const [y, m, d] = k.split('-').map(Number); return new Date(y, m - 1, d); };
+const shortDate = (d, year) => d.toLocaleDateString(t.locale, { day: 'numeric', month: 'short', ...(year ? { year: 'numeric' } : {}) });
+const compact = (n) => new Intl.NumberFormat(t.locale, { notation: 'compact', maximumFractionDigits: 1 }).format(n);
+// 1, 2, 2.5, 5 × 10^k: a round top for the y axis.
+const niceMax = (v) => { const p = 10 ** Math.floor(Math.log10(v || 1)); return [1, 2, 2.5, 5, 10].map((m) => m * p).find((x) => x >= v); };
+
+// Real usage per day (per week past ~4 months), continuous: days without calls are zero-height columns.
+function buckets(r) {
+  if (!r.daily.length) return null;
+  const first = r.since ? parseDay(dayKey(r.since)) : parseDay(r.daily[0].day);
+  const last = r.since ? parseDay(dayKey(Date.now())) : parseDay(r.daily[r.daily.length - 1].day);
+  const weekly = (last - first) / DAY > 120;
+  const startOf = (d) => (weekly ? new Date(d.getFullYear(), d.getMonth(), d.getDate() - ((d.getDay() + 6) % 7)) : d);
+  const byKey = new Map();
+  for (let d = startOf(first); d <= last; d = new Date(d.getFullYear(), d.getMonth(), d.getDate() + (weekly ? 7 : 1))) {
+    byKey.set(dayKey(d.getTime()), { date: d, billed: 0, cache: 0, calls: 0 });
+  }
+  for (const x of r.daily) {
+    const b = byKey.get(dayKey(startOf(parseDay(x.day)).getTime()));
+    if (!b) continue;
+    b.billed += x.input + x.output;
+    b.cache += x.cache;
+    b.calls += x.calls;
+  }
+  return { weekly, rows: [...byKey.values()] };
+}
+
+function chart(r) {
+  const b = buckets(r);
+  if (!b) return '';
+  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 band = pw / b.rows.length;
+  const bw = Math.max(1, Math.min(24, band - 2));
+  const y = (v) => m.t + ph - (v / top) * ph;
+  const when = (x) => (b.weekly ? t.report.weekOf(shortDate(x.date, true)) : shortDate(x.date, true));
+
+  const grid = [0, top / 2, top].map((v) => `<line x1="${m.l}" x2="${W - m.r}" y1="${y(v)}" y2="${y(v)}" class="grid"/>
+    <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;
+    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('');
+  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>`;
+}
+
+// --- Page ---
+
+function body(r, found, scope) {
   const top5 = r.sessions.slice(0, 5).reduce((s, x) => s + x.tokens, 0);
   const u = r.usage;
-  const body = !r.conversations
-    ? `<p>${t.report.noConversations(scope && esc(scope), esc(r.dir))}</p>`
-    : `<div class="tiles">
-        ${u.conversations ? `<div><b>${fmt(billed(u))}</b><span>${t.report.tileReal}</span></div>
-        <div><b>${fmt(withCache(u))}</b><span>${t.report.tileCache(u.calls)}</span></div>` : ''}
-        <div><b>${fmt(r.tokens)}</b><span>${t.report.tileContext}</span></div>
-        <div><b>${pct(top5, r.tokens)}</b><span>${t.report.tileTop5}</span></div>
-        <div><b>${r.reads}</b><span>${t.report.tileReads}</span></div>
-        <div><b>${pct(r.rereads, r.reads)}</b><span>${t.report.tileRereads}</span></div>
-      </div>
-      <h2>${t.report.happening}</h2>
-      <p class="hint">${t.report.happeningHint}</p>
-      ${found.length ? found.map((f) => finding(f, r.tokens)).join('') : `<p>${t.report.nothing}</p>`}
-      <details class="detail-all"><summary><h2>${t.report.details}</h2></summary>
-        ${sessionsTable(r)}
-        ${table(t.report.byProject, r.projects, r.tokens, (x) => x.project || t.report.outsideGit)}
-        ${table(t.report.byKind, r.kinds, r.tokens, (x) => kindLabel(x.key))}
-        ${table(t.report.byFolder, r.folders, r.tokens)}
-        ${table(t.report.files, r.files, r.tokens)}
-        ${table(t.report.tools, r.tools, r.tokens, (x) => x.key)}
-        ${table(t.report.commands, r.commands, r.tokens, (x) => x.key)}
-      </details>`;
+  const meta = `<p class="meta">${t.report.convs(r.conversations)}${r.period ? ` · ${esc(periodLine(r))}` : ''}</p>`;
+  if (!r.conversations) {
+    return `${meta}<p>${t.report.noConversations(scope && esc(scope), esc(r.dir))}${r.olderSkipped ? ` ${esc(t.report.olderSkipped(r.olderSkipped))}.` : ''}</p>`;
+  }
+  return `${meta}<div class="tiles">
+      ${u.conversations ? `<div><b>${fmt(billed(u))}</b><span>${t.report.tileReal}</span></div>
+      <div><b>${fmt(withCache(u))}</b><span>${t.report.tileCache(u.calls)}</span></div>` : ''}
+      <div><b>${fmt(r.tokens)}</b><span>${t.report.tileContext}</span></div>
+      <div><b>${pct(top5, r.tokens)}</b><span>${t.report.tileTop5}</span></div>
+      <div><b>${r.reads}</b><span>${t.report.tileReads}</span></div>
+      <div><b>${pct(r.rereads, r.reads)}</b><span>${t.report.tileRereads}</span></div>
+    </div>
+    ${chart(r)}
+    ${modelsTable(r)}
+    <h2>${t.report.happening}</h2>
+    <p class="hint">${t.report.happeningHint}</p>
+    ${found.length ? found.map((f) => finding(f, r.tokens)).join('') : `<p>${t.report.nothing}</p>`}
+    <details class="detail-all"><summary><h2>${t.report.details}</h2></summary>
+      ${sessionsTable(r)}
+      ${table(t.report.byProject, r.projects, r.tokens, (x) => x.project || t.report.outsideGit)}
+      ${table(t.report.byKind, r.kinds, r.tokens, (x) => kindLabel(x.key))}
+      ${table(t.report.byFolder, r.folders, r.tokens)}
+      ${table(t.report.files, r.files, r.tokens)}
+      ${table(t.report.tools, r.tools, r.tokens, (x) => x.key)}
+      ${table(t.report.commands, r.commands, r.tokens, (x) => x.key)}
+    </details>`;
+}
+
+/**
+ * One report per period, switched in the browser by a row of presets. Each period is analyzed on its own,
+ * so every number, finding and table below the filter agrees with it.
+ * @param {{ key: string, label: string, r: object, found: object[] }[]} views the first one shows by default
+ */
+function htmlViews(views, { scope }) {
+  const u = views[0].r.usage;
+  const filter = views.length > 1
+    ? `<div class="filter" role="group" aria-label="${esc(t.report.filterLabel)}"><span>${t.report.filterLabel}</span>
+      ${views.map((v, i) => `<button type="button" data-view="${v.key}" aria-pressed="${i === 0}">${esc(v.label)}</button>`).join('')}</div>`
+    : '';
+  const sections = views.map((v, i) => `<div class="view" data-view="${v.key}"${i ? ' hidden' : ''}>${body(v.r, v.found, scope)}</div>`).join('');
 
   return `<!doctype html><html lang="${lang()}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
 <title>agy-insights</title>
 <style>
   :root { --bg: #f7f8f7; --surface: #fff; --fg: #1d2421; --muted: #5d6963; --line: #dde3df; --accent: #1f7a5a; --accent-soft: #e3f1ea;
-    --warn: #b06a00; --code: #eef1ef; --bar: #1f7a5a; color-scheme: light; }
+    --warn: #b06a00; --code: #eef1ef; --bar: #1f7a5a; --series: #13805a; color-scheme: light; }
   @media (prefers-color-scheme: dark) { :root { --bg: #141917; --surface: #1b211e; --fg: #e3e9e5; --muted: #9aa8a0; --line: #2c3530;
-    --accent: #5cc79c; --accent-soft: #1d3329; --warn: #e2a64a; --code: #222a26; --bar: #5cc79c; color-scheme: dark; } }
+    --accent: #5cc79c; --accent-soft: #1d3329; --warn: #e2a64a; --code: #222a26; --bar: #5cc79c; --series: #33a376; color-scheme: dark; } }
   body { margin: 0; background: var(--bg); color: var(--fg); font: 15px/1.55 system-ui, -apple-system, "Segoe UI", sans-serif; }
   main { max-width: 980px; margin: 0 auto; padding: 32px 16px 48px; }
   h1 { font-size: 26px; margin: 0 0 4px; } h2 { font-size: 20px; margin: 32px 0 6px; display: inline-block; } h3 { font-size: 16px; margin: 0 0 6px; }
   .meta, .hint, .detail, .tok, .where { color: var(--muted); } .tok { font-weight: normal; font-size: 14px; }
   code, pre { font-family: ui-monospace, "Cascadia Mono", Consolas, monospace; font-size: 13px; }
   code { background: var(--code); padding: 1px 5px; border-radius: 4px; overflow-wrap: anywhere; }
-  .tiles { display: grid; grid-template-columns: repeat(auto-fit, minmax(170px, 1fr)); gap: 12px; margin: 20px 0; }
+  .filter { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; margin: 20px 0 4px; }
+  .filter span { color: var(--muted); font-size: 14px; margin-right: 4px; }
+  .filter button { font: 14px system-ui, sans-serif; color: var(--fg); background: var(--surface); border: 1px solid var(--line); border-radius: 999px; padding: 4px 12px; cursor: pointer; }
+  .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; }
+  .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; }
+  .chart h2 { margin-top: 8px; } .models .hint { margin-top: 0; } .chart .hint { margin-top: 0; }
+  .plot { background: var(--surface); border: 1px solid var(--line); border-radius: 8px; padding: 8px 8px 0; }
+  .plot svg { display: block; width: 100%; height: auto; }
+  .grid { stroke: var(--line); stroke-width: 1; } .axis { fill: var(--muted); font: 12px system-ui, sans-serif; font-variant-numeric: tabular-nums; }
+  .col { fill: var(--series); } .hit { fill: transparent; cursor: default; } .hit:hover { fill: var(--fg); fill-opacity: .05; }
+  .tip { position: fixed; pointer-events: none; background: var(--surface); color: var(--fg); border: 1px solid var(--line); border-radius: 6px;
+    padding: 6px 10px; font-size: 13px; box-shadow: 0 2px 8px rgb(0 0 0 / .12); z-index: 10; }
+  .tip b { display: block; font-size: 15px; font-variant-numeric: tabular-nums; } .tip span { display: block; color: var(--muted); }
   .finding { background: var(--surface); border: 1px solid var(--line); border-left: 4px solid var(--accent); border-radius: 8px; padding: 14px 16px; margin: 12px 0; }
   .finding.warn { border-left-color: var(--warn); } .finding p { margin: 4px 0; }
   .items { list-style: none; margin: 10px 0 0; padding: 0; }
@@ -128,15 +253,23 @@ function html(r, found, { scope }) {
   footer { margin-top: 32px; font-size: 13px; color: var(--muted); }
 </style></head><body><main>
   <h1>${t.report.title}</h1>
-  <p class="meta">${scope ? `${t.report.project} <code>${esc(scope)}</code>` : t.report.wholeHistory} · ${t.report.meta(r.conversations, esc(new Date().toLocaleString(t.locale)))}</p>
-  ${body}
-  <footer>${esc(t.report.footerReal(r.conversations - u.conversations))}
+  <p class="meta">${scope ? `${t.report.project} <code>${esc(scope)}</code> · ` : views[0].r.since ? '' : `${t.report.wholeHistory} · `}${esc(t.report.generated(new Date().toLocaleString(t.locale)))}</p>
+  ${filter}
+  ${sections}
+  <footer>${esc(t.report.footerReal(views[0].r.conversations - u.conversations))}
   ${esc(t.report.footerCache)}
   ${esc(t.report.footerEstimate)}
   ${esc(t.report.footerPrivacy)}</footer>
 </main>
+<div class="tip" hidden><b></b><span></span><span></span></div>
 <script>
   document.addEventListener('click', (e) => {
+    const v = e.target.closest('.filter button');
+    if (v) {
+      for (const b of document.querySelectorAll('.filter button')) b.setAttribute('aria-pressed', String(b === v));
+      for (const s of document.querySelectorAll('.view')) s.hidden = s.dataset.view !== v.dataset.view;
+      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); };
@@ -145,15 +278,36 @@ function html(r, found, { scope }) {
       const sel = getSelection(); sel.removeAllRanges(); sel.addRange(range);
     });
   });
+  // Chart tooltip: values are filled with textContent, never as HTML.
+  const tip = document.querySelector('.tip');
+  document.addEventListener('pointermove', (e) => {
+    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';
+    when.textContent = h.dataset.when;
+    rest.textContent = h.dataset.n + ' · ' + h.dataset.c + ' ' + ${JSON.stringify(t.report.withCacheShort)};
+    tip.hidden = false;
+    const x = Math.min(e.clientX + 14, innerWidth - tip.offsetWidth - 8);
+    tip.style.left = x + 'px';
+    tip.style.top = (e.clientY - tip.offsetHeight - 10) + 'px';
+  });
 </script></body></html>`;
 }
 
+function html(r, found, opts) {
+  return htmlViews([{ key: 'all', label: '', r, found }], opts);
+}
+
+
 // --- Text ---
 
 function text(r, found, { scope, paths }) {
   const top5 = r.sessions.slice(0, 5).reduce((s, x) => s + x.tokens, 0);
   const out = [`\n${t.report.history}: ${r.dir} (${r.backend})${scope ? ` · ${t.report.projectLower} ${scope}` : ''}`,
     t.report.summary(r.conversations, r.steps, fmt(r.tokens))];
+  if (r.period) out.push(periodLine(r));
+  if (r.olderSkipped) out.push(`(${t.report.olderSkipped(r.olderSkipped)})`);
   if (!r.conversations) return out.join('\n') + '\n';
   const u = r.usage;
   if (u.conversations) {
@@ -162,10 +316,19 @@ 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)))}`);
+      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))}`);
     }
   }
   out.push(t.report.top5(pct(top5, r.tokens), r.reads, r.rereads, pct(r.rereads, r.reads)));
+  const models = r.models.filter((m) => m.model);
+  if (models.length) {
+    const total = r.models.reduce((s, m) => s + m.input + m.output, 0);
+    out.push('', t.report.modelsText);
+    for (const m of models) {
+      const tok = m.input + m.output;
+      out.push(`  ${t.report.modelLine(m.model, effortLabel(m.effort), m.calls, fmt(tok), pct(tok, total), m.known ? fmt(tok / m.known) : '–')}`);
+    }
+  }
   for (const f of found) {
     out.push('', `${f.level === 'warn' ? '⚠' : '•'} ${f.title}${f.tokens ? `  (~${fmt(f.tokens)} tokens, ${pct(f.tokens, r.tokens)})` : ''}`,
       `  ${f.why}`, `  → ${f.suggestion}`);
@@ -182,4 +345,4 @@ function text(r, found, { scope, paths }) {
   return out.join('\n');
 }
 
-module.exports = { html, text };
+module.exports = { html, htmlViews, text };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agy-insights",
-  "version": "0.4.0",
-  "description": "Measures Antigravity CLI token usage and shows which context is sent repeatedly or needlessly, in English or Spanish. Run: npx agy-insights",
+  "version": "0.7.1",
+  "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": [
     "antigravity",