agy-insights 0.8.1 → 0.9.0

package/README.es.md

@@ -23,7 +23,7 @@ Cada fichero que lee el agente y cada salida de comando entra en el contexto y s
 ## Requisitos
 
 - **Node.js 20 o superior** (`node --version`).
-- Haber usado **Antigravity CLI** (`agy`) en este equipo. El historial está en `~/.gemini/antigravity-cli/conversations` (en Windows, `%USERPROFILE%\.gemini\antigravity-cli\conversations`).
+- Haber usado **Antigravity** en este equipo: el CLI (`agy`), el editor o la extensión de VS Code. Se leen los dos historiales: el del CLI en `~/.gemini/antigravity-cli/conversations`, y el del editor y la extensión en `~/.gemini/antigravity/conversations` (en Windows, dentro de `%USERPROFILE%\.gemini\`).
 
 ## Instalar
 
@@ -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.8.1`.
+`@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.9.0`.
 
 **Instalándolo globalmente:**
 
@@ -82,7 +82,7 @@ El informe da dos cifras:
 
 ## Leer el informe
 
-Arriba están el selector de periodo y los totales. Después, una gráfica de **consumo de tokens por día** (por semana si el historial pasa de ~4 meses) para ver la evolución. Cámbiala a **Por llamada** para ver los tokens medios de cada llamada al modelo: el total sube y baja según cuánto hayas trabajado, mientras que por llamada solo baja si cada llamada lleva menos contexto, así que es la que muestra si un cambio ha servido. Pasa el ratón por una columna para ver sus cifras, o abre «Ver como tabla». Después, **Modelos y esfuerzo**: llamadas y tokens reales por modelo y nivel de esfuerzo (por ejemplo Gemini 3.8 Flash · Alto), con los tokens por llamada, para ver cuánto cuesta un esfuerzo mayor. Debajo, **Qué está pasando** reúne los hallazgos; al final, el detalle por proyecto, tipo de fichero, carpeta, fichero, herramienta y comando. El proyecto de cada fichero se detecta por su carpeta `.git`.
+Arriba están el selector de periodo y los totales. Después, una gráfica de **consumo de tokens por día** (por semana si el historial pasa de ~4 meses) para ver la evolución. Cámbiala a **Por llamada** para ver los tokens medios de cada llamada al modelo: el total sube y baja según cuánto hayas trabajado, mientras que por llamada solo baja si cada llamada lleva menos contexto, así que es la que muestra si un cambio ha servido. Pasa el ratón por una columna para ver sus cifras, o abre «Ver como tabla». Si usas el CLI y también el editor o la extensión de VS Code, **Por origen** reparte las conversaciones y los tokens reales entre ellos (el editor y la extensión comparten historial, así que cuentan juntos), y cada sesión indica desde dónde se tuvo. 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 |
 |---|---|---|

package/README.md

@@ -23,7 +23,7 @@ Every file the agent reads and every command output enters the context and is re
 ## Requirements
 
 - **Node.js 20 or later** (`node --version`).
-- Having used **Antigravity CLI** (`agy`) on this machine. The history lives in `~/.gemini/antigravity-cli/conversations` (on Windows, `%USERPROFILE%\.gemini\antigravity-cli\conversations`).
+- Having used **Antigravity** on this machine: the CLI (`agy`), the editor or the VS Code extension. Both histories are read: the CLI's in `~/.gemini/antigravity-cli/conversations`, and the editor's and extension's in `~/.gemini/antigravity/conversations` (on Windows, under `%USERPROFILE%\.gemini\`).
 
 ## Install
 
@@ -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.8.1`.
+`@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.9.0`.
 
 **Globally:**
 
@@ -82,7 +82,7 @@ The report gives two figures:
 
 ## Reading the report
 
-At the top, the period selector and the totals. Then a chart of **token usage per day** (per week when the history spans more than ~4 months), to see how usage evolves. Switch it to **Per call** to see mean tokens per model call: the total follows how much you worked, while per call drops only when each call carries less context, so it is the one that shows whether a change paid off. Hover a column for its figures, or open "View as table". Next, **Models and effort**: calls and real tokens per model and effort level (for example Gemini 3.8 Flash · High), including tokens per call, so you can see what a higher effort costs. Below, **What's happening** lists the findings; at the end, the details by project, file type, folder, file, tool and command. The project of each file is detected through its `.git` folder.
+At the top, the period selector and the totals. Then a chart of **token usage per day** (per week when the history spans more than ~4 months), to see how usage evolves. Switch it to **Per call** to see mean tokens per model call: the total follows how much you worked, while per call drops only when each call carries less context, so it is the one that shows whether a change paid off. Hover a column for its figures, or open "View as table". If you use both the CLI and the editor or the VS Code extension, **By origin** splits conversations and real tokens between them (the editor and the extension share their history, so they count together), and each session shows where it was held. 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 |
 |---|---|---|

package/agy-insights.js

@@ -6,7 +6,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const { spawn } = require('child_process');
-const { analyze, DEFAULT_DIR } = require('./lib/history');
+const { analyze, DEFAULT_DIRS } = require('./lib/history');
 const { findings, DEFAULTS } = require('./lib/findings');
 const report = require('./lib/report');
 const { buildMap } = require('./lib/map');
@@ -115,7 +115,7 @@ async function main() {
   if (!(argv.includes('--lang') && setLang(argv[argv.indexOf('--lang') + 1]))) setLang(detect());
   const opts = parseArgs(argv);
   if (opts.lang && !setLang(opts.lang)) fail(t.badLang(opts.lang));
-  if (opts.help) return console.log(t.help(DEFAULT_DIR));
+  if (opts.help) return console.log(t.help(DEFAULT_DIRS.join(' + ')));
   const cfg = loadConfig(opts.config);
   if (!opts.lang && cfg.lang && !setLang(cfg.lang)) fail(t.badLang(cfg.lang));
 
@@ -123,7 +123,7 @@ async function main() {
   const since = sinceTime(opts);
   const run = (from) => analyze({
     since: from,
-    dir: opts.dir || cfg.conversationsDir || DEFAULT_DIR,
+    dir: opts.dir || cfg.conversationsDir || DEFAULT_DIRS,
     workspaces: opts.project ? [opts.project] : [],
     customKinds: cfg.customKinds || {},
   });

package/docs/how-it-works.md

@@ -31,11 +31,11 @@ test/*.test.js        tests (node --test)
 
 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.
+- One SQLite database per conversation: `~/.gemini/antigravity-cli/conversations/<uuid>.db`, in WAL mode. The editor and the VS Code extension keep the same layout under `~/.gemini/antigravity/` (`conversations/`, `brain/`, `conversation_summaries.db`); both folders are read by default. The editor's summaries also list CLI conversations, sometimes with only a preview, so the first folder's titles win. Conversations stored there as `.pb` files are not read.
 - 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. 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.
+- 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. Some logs (seen with the VS Code plugin) have `PLANNER_RESPONSE` lines without any token field; those are not counted as 0 tokens. The same figures are also in each `gen_metadata` row, at protobuf field 1 › 4 (2 = input, 3 = output, 5 = cache read; the model's display name is at 1 › 21). When the transcript has no counts, or there is no transcript, `usageFromMeta()` takes real usage from there, keeping the day and selected model of the transcript's n-th call when there is one.
 
 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.
 

package/lib/history.js

@@ -7,7 +7,13 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
-const DEFAULT_DIR = path.join(os.homedir(), '.gemini', 'antigravity-cli', 'conversations');
+// The CLI (agy) keeps its history in antigravity-cli; the editor and the VS Code extension in antigravity,
+// with the same layout. Both are read by default.
+const DEFAULT_DIRS = ['antigravity-cli', 'antigravity'].map((d) => path.join(os.homedir(), '.gemini', d, 'conversations'));
+const DEFAULT_DIR = DEFAULT_DIRS[0];
+// Which Antigravity a history folder belongs to, from its parent's name; null for any other folder.
+// The editor and the VS Code extension share their folder, so they cannot be told apart.
+const originOf = (dir) => ({ 'antigravity-cli': 'cli', antigravity: 'editor' })[path.basename(path.dirname(dir))] || null;
 const BYTES_PER_TOKEN = 4;
 const TOOL_RE = /^[a-z][a-z0-9_]{2,40}$/;
 const FILE_KEYS = ['AbsolutePath', 'TargetFile', 'FilePath', 'File', 'Path'];
@@ -114,6 +120,39 @@ function collect(blob) {
   return out;
 }
 
+// The top-level fields of one protobuf message: tag -> varint value or bytes (last one wins). Null if malformed.
+function fields(buf) {
+  const out = new Map();
+  let i = 0;
+  const varint = () => {
+    let v = 0, s = 0, b;
+    do { if (i >= buf.length) throw 0; b = buf[i++]; v += (b & 0x7f) * 2 ** s; s += 7; } while (b & 0x80);
+    return v;
+  };
+  try {
+    while (i < buf.length) {
+      const k = varint(), tag = Math.floor(k / 8), wt = k & 7;
+      if (wt === 0) out.set(tag, varint());
+      else if (wt === 1) i += 8;
+      else if (wt === 5) i += 4;
+      else if (wt === 2) { const len = varint(); if (i + len > buf.length) throw 0; out.set(tag, buf.subarray(i, i + len)); i += len; } else throw 0;
+    }
+    return out;
+  } catch { return null; }
+}
+
+// Token counts of one gen_metadata row (one model call): field 1 › 4 holds 2 = input, 3 = output,
+// 5 = cache read, the same figures the transcript logs. Null when the row has none: some logs (seen
+// with the VS Code plugin) carry no token counts, and this is then the only place that has them.
+function metaUsage(blob) {
+  const top = blob && fields(Buffer.from(blob));
+  const call = Buffer.isBuffer(top?.get(1)) && fields(top.get(1));
+  const u = Buffer.isBuffer(call?.get(4)) && fields(call.get(4));
+  if (!u || !(u.has(2) || u.has(3))) return null;
+  const n = (k) => (typeof u.get(k) === 'number' ? u.get(k) : 0);
+  return { input: n(2), output: n(3), cache: n(5) };
+}
+
 // A tool call is stored as the tool name followed (within a few strings) by its JSON arguments,
 // e.g. "view_file" + {"AbsolutePath":"C:\\dev\\...\\X.cs","StartLine":301,"EndLine":380}.
 // The call id ("call_5859111") just before the name identifies the call: agy stores each call twice,
@@ -242,7 +281,7 @@ function realUsage(dir, id) {
     if (!['input_tokens', 'cache_read_tokens', 'output_tokens'].some((k) => k in e)) {
       u.unmetered++;
       for (const k of Object.keys(e)) if (k.length < 40) u.unmeteredKeys.add(k);
-      u.perCall.push({ metered: false, model: selected });
+      u.perCall.push({ metered: false, model: selected, at });
       continue;
     }
     u.calls++;
@@ -261,6 +300,27 @@ function realUsage(dir, id) {
   return u;
 }
 
+// Real usage rebuilt from gen_metadata, one row per model call, for conversations whose log has no token
+// counts (or no log). Each row's call keeps the model and day of the log's n-th call when there is one.
+function usageFromMeta(blobs, log, end) {
+  const rows = blobs.map(metaUsage);
+  if (!rows.some(Boolean)) return null;
+  const u = { calls: 0, input: 0, cache: 0, output: 0, errors: log?.errors || 0, start: log?.start ?? null, end: log?.end ?? null,
+    days: new Map(), perCall: [], unmetered: 0, unmeteredKeys: new Set(), unrecognized: log?.unrecognized || new Set(), fromMeta: true };
+  rows.forEach((x, i) => {
+    const from = log?.perCall[i];
+    if (!x) { u.perCall.push({ metered: false, model: from?.model || null }); return; }
+    u.calls++;
+    u.input += x.input; u.cache += x.cache; u.output += x.output;
+    u.perCall.push({ metered: true, ...x, model: from?.model || null });
+    const k = dayKey(from?.at || log?.end || end);
+    const d = u.days.get(k) || { calls: 0, input: 0, cache: 0, output: 0 };
+    d.calls++; d.input += x.input; d.cache += x.cache; d.output += x.output;
+    u.days.set(k, d);
+  });
+  return u;
+}
+
 // --- Titles ---
 
 // The short title agy gives each conversation ("Analyzing Package Lock Dependencies"), from
@@ -296,12 +356,15 @@ class Counter {
 
 /**
  * @param {object} opts
- * @param {string} [opts.dir] conversations directory
+ * @param {string|string[]} [opts.dir] conversations directory, or several (the CLI's and the editor's by default)
  * @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 = {}, since = null } = {}) {
+async function analyze({ dir: dirs = DEFAULT_DIRS, workspaces = [], customKinds = {}, since = null } = {}) {
+  dirs = [].concat(dirs);
+  // The folders that exist, for the report's header; all of them when none does, to say where it looked.
+  const dir = (dirs.filter((d) => fs.existsSync(d)).length ? dirs.filter((d) => fs.existsSync(d)) : dirs).join(' + ');
   const custom = Object.entries(customKinds).map(([re, label]) => [new RegExp(re, 'i'), label]);
   // 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]
@@ -321,16 +384,18 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
   const wsKeys = workspaces.map(key);
 
   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) {
+    const dbs = dirs.flatMap((d) => (fs.existsSync(d) ? fs.readdirSync(d).filter((f) => /^[0-9a-f-]{36}\.db$/i.test(f)).map((f) => [d, f]) : []));
+    const titles = new Map();
+    // The editor's summaries also list CLI conversations, sometimes with just a preview: the first folder's title wins.
+    for (const d of dirs) for (const [k, v] of await conversationTitles(d, tmp)) if (!titles.has(k)) titles.set(k, v);
+    for (const [dir, f] of dbs) {
       // When it happened: the transcript's step times, else the database's last write.
       const id = f.replace(/\.db$/, '');
       const log = realUsage(dir, id);
       const end = log?.end ?? fs.statSync(path.join(dir, f)).mtimeMs;
       const start = log?.start ?? end;
-      // Real usage only when the log has token counts; otherwise the session is shown with the estimate.
-      const usage = log?.calls ? log : null;
+      // Real usage from the log when it has token counts; else from gen_metadata (below), else the estimate.
+      let usage = log?.calls ? log : null;
       if (since && end < since) { r.olderSkipped++; continue; }
       let db;
       try { db = await openDb(path.join(dir, f), tmp); } catch { r.unreadable++; continue; }
@@ -390,6 +455,8 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
             files.add(key(file), { ...fields, convs: once(seenFiles, key(file)) }, { abs: file, rel, root, project, kind: k });
           });
         }
+        const metaBlobs = db.all('select data from gen_metadata order by idx').map(([blob]) => blob);
+        if (!usage) usage = usageFromMeta(metaBlobs, log, end);
         if (usage) {
           r.usage.conversations++;
           for (const k of ['calls', 'input', 'cache', 'output', 'errors']) r.usage[k] += usage[k];
@@ -404,9 +471,9 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
         // 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 metaStrs = metaBlobs.map(collect);
         const metaRows = metaStrs.map(modelOf);
-        const calls = log ? log.perCall : metaRows.map(() => null);
+        const calls = usage?.fromMeta ? usage.perCall : log ? log.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;
@@ -431,7 +498,7 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
         const main = [...counts].sort((a, b) => b[1] - a[1])[0];
         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,
+          id, title: titles.get(id) || null, origin: originOf(dir), 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.
@@ -453,8 +520,17 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
   r.sessions.sort((a, b) => billed(b) - billed(a) || b.tokens - a.tokens);
   // Many steps but no recognizable tool call: agy probably changed its storage format.
   r.formatUnrecognized = r.steps > 50 && r.toolCallsFound === 0;
+  // Conversations and real usage per origin (CLI, editor), biggest first.
+  const origins = new Map();
+  for (const s of r.sessions) {
+    const o = origins.get(s.origin) || { origin: s.origin, conversations: 0, calls: 0, input: 0, cache: 0, output: 0 };
+    o.conversations++;
+    if (s.usage) for (const k of ['calls', 'input', 'cache', 'output']) o[k] += s.usage[k];
+    origins.set(s.origin, o);
+  }
   return {
     ...r,
+    origins: [...origins.values()].sort((a, b) => b.input + b.output - (a.input + a.output) || b.conversations - a.conversations),
     tools: tools.all(), kinds: kinds.all(), folders: folders.all(), files: files.all(), projects: projects.all(),
     commands: commands.all(),
     models: [...models.values()].sort((a, b) => b.input + b.output - (a.input + a.output) || b.calls - a.calls),
@@ -462,4 +538,4 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
   };
 }
 
-module.exports = { analyze, DEFAULT_DIR, kind, NON_SOURCE, realUsage, dayKey, modelOf, selectedModel, repoFiles };
+module.exports = { analyze, DEFAULT_DIR, DEFAULT_DIRS, kind, NON_SOURCE, realUsage, dayKey, modelOf, selectedModel, repoFiles };

package/lib/i18n.js

@@ -21,7 +21,7 @@ Options:
   --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})
+  --dir <folder>        Another history folder (default the CLI's and the editor's: ${dir})
   --config <file>       Configuration (default ~/.agy-insights.json if it exists)
   --help                This help
 `,
@@ -121,7 +121,12 @@ Options:
     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'],
+    sessionCols: ['Conversation', 'When', 'Origin', 'Model', 'Tokens', '%', 'With cache', 'Calls', 'Errors'],
+    origin: { cli: 'CLI', editor: 'Editor / VS Code', other: 'Other folder' },
+    originsTitle: 'By origin',
+    originsHint: 'Where each conversation was held. The editor and the VS Code extension keep the same history, so they are counted together.',
+    originCols: ['Origin', 'Conversations', 'Calls', 'Tokens', '%', 'Per call', 'With cache'],
+    originsText: '  By origin:',
     noConversations: (scope, dir) => `No conversations${scope ? ` for <code>${scope}</code>` : ''} in <code>${dir}</code>.`,
     tileReal: 'real tokens (input + output)',
     tileCache: (calls) => `including cache · ${plural(calls, 'call', 'calls')}`,
@@ -197,7 +202,7 @@ Opciones:
   --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})
+  --dir <carpeta>       Otra carpeta de historial (por defecto, la del CLI y la del editor: ${dir})
   --config <fichero>    Configuración (por defecto ~/.agy-insights.json si existe)
   --help                Esta ayuda
 `,
@@ -297,7 +302,12 @@ Opciones:
     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'],
+    sessionCols: ['Conversación', 'Cuándo', 'Origen', 'Modelo', 'Tokens', '%', 'Con caché', 'Llamadas', 'Errores'],
+    origin: { cli: 'CLI', editor: 'Editor / VS Code', other: 'Otra carpeta' },
+    originsTitle: 'Por origen',
+    originsHint: 'Desde dónde se tuvo cada conversación. El editor y la extensión de VS Code guardan el mismo historial, así que se cuentan juntos.',
+    originCols: ['Origen', 'Conversaciones', 'Llamadas', 'Tokens', '%', 'Por llamada', 'Con caché'],
+    originsText: '  Por origen:',
     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é · ${plural(calls, 'llamada', 'llamadas')}`,

package/lib/report.js

@@ -58,12 +58,17 @@ function table(title, rows, total, name = label) {
   </tbody></table></div>`;
 }
 
+// Origins are only told apart when the history mixes several (CLI and editor).
+const mixed = (r) => r.origins.length > 1;
+const originName = (o) => t.report.origin[o] || t.report.origin.other;
+
 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 > 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.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>
+  const cols = mixed(r) ? t.report.sessionCols : t.report.sessionCols.filter((_, i) => i !== 2);
+  return `<h3>${t.report.sessionsTitle}</h3><div class="scroll"><table><thead><tr>${cols.map((c, i) => `<th${i > cols.length - 6 ? ' 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.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>${mixed(r) ? `<td class="when">${esc(originName(s.origin))}</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>`;
@@ -88,6 +93,19 @@ function modelsTable(r) {
     </tbody></table></div>${unknown ? `<p class="hint">${esc(t.report.modelsUnknown(fmt(unknown.calls)))}</p>` : ''}</section>`;
 }
 
+// Conversations and real usage per origin (CLI, editor / VS Code), when the history mixes them.
+function originsTable(r) {
+  if (!mixed(r)) return '';
+  const total = billed(r.usage);
+  const max = Math.max(...r.origins.map(billed), 1);
+  return `<section class="origins"><h2>${t.report.originsTitle}</h2><p class="hint">${t.report.originsHint}</p>
+    <div class="scroll"><table><thead><tr>${t.report.originCols.map((c, i) => `<th${i ? ' class="num"' : ''}>${c}</th>`).join('')}</tr></thead><tbody>
+    ${r.origins.map((o) => `<tr><td><div class="bar" style="--w:${((100 * billed(o)) / max).toFixed(1)}%"></div><span>${esc(originName(o.origin))}</span></td>
+      <td class="num">${o.conversations}</td><td class="num">${fmt(o.calls)}</td><td class="num">${fmt(billed(o))}</td><td class="num">${pct(billed(o), total)}</td>
+      <td class="num">${o.calls ? fmt(billed(o) / o.calls) : '–'}</td><td class="num">${fmt(withCache(o))}</td></tr>`).join('')}
+    </tbody></table></div></section>`;
+}
+
 // --- Usage chart ---
 
 const DAY = 24 * 60 * 60 * 1000;
@@ -188,6 +206,7 @@ function body(r, found, scope) {
       <div><b>${pct(r.rereads, r.reads)}</b><span>${t.report.tileRereads}</span></div>
     </div>
     ${chart(r)}
+    ${originsTable(r)}
     ${modelsTable(r)}
     <h2>${t.report.happening}</h2>
     <p class="hint">${t.report.happeningHint}</p>
@@ -270,7 +289,7 @@ function htmlViews(views, { scope }) {
   .copy:focus-visible { outline: 2px solid var(--accent); }
   .scroll { overflow-x: auto; } table { width: 100%; border-collapse: collapse; font-size: 14px; margin: 6px 0 18px; }
   th { text-align: left; color: var(--muted); font-weight: 600; } th, td { padding: 5px 8px; border-bottom: 1px solid var(--line); }
-  td:first-child { position: relative; word-break: break-all; } td.when { white-space: nowrap; }
+  td:first-child { position: relative; overflow-wrap: anywhere; } td.when { white-space: nowrap; }
   .bar { position: absolute; inset: 3px auto 3px 0; width: var(--w); background: var(--bar); opacity: .15; border-radius: 3px; } td span { position: relative; }
   .detail-all > summary { color: var(--fg); }
   footer { margin-top: 32px; font-size: 13px; color: var(--muted); }
@@ -347,7 +366,11 @@ 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), s.title)}`);
+      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), mixed(r) && originName(s.origin)].filter(Boolean).join(' · '), s.title)}`);
+    }
+    if (mixed(r)) {
+      out.push(t.report.originsText);
+      for (const o of r.origins) out.push(`    ${fmt(billed(o)).padStart(10)}  ${pct(billed(o), billed(u)).padStart(4)}  ${originName(o.origin)} (${t.report.convs(o.conversations)})`);
     }
   }
   out.push(t.report.top5(pct(top5, r.tokens), r.reads, r.rereads, pct(r.rereads, r.reads)));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agy-insights",
-  "version": "0.8.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",
+  "version": "0.9.0",
+  "description": "Measures Antigravity token usage (CLI, editor and VS Code extension) and shows which context is sent repeatedly or needlessly, in English or Spanish. Run: npx agy-insights@latest",
   "license": "MIT",
   "keywords": [
     "antigravity",