agy-insights 0.8.0 → 0.8.2

package/README.es.md

@@ -36,7 +36,7 @@ npx agy-insights
 npx agy-insights@latest --text
 ```
 
-`@latest` hace que npx compruebe cada vez si hay una versión nueva. Sin él, una copia instalada globalmente (`npm install -g`) o en el proyecto actual tiene prioridad y no se actualiza nunca. Para fijar una versión concreta: `npx agy-insights@0.8.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.8.2`.
 
 **Instalándolo globalmente:**
 

package/README.md

@@ -36,7 +36,7 @@ npx agy-insights
 npx agy-insights@latest --text
 ```
 
-`@latest` makes npx check for the newest version every time. Without it, a copy installed globally (`npm install -g`) or in the current project takes precedence and is never updated. To pin a version instead: `npx agy-insights@0.8.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.8.2`.
 
 **Globally:**
 

package/agy-insights.js

@@ -86,14 +86,15 @@ function sinceTime({ since, days }) {
 // Tab-separated table of where each conversation's call models came from, for bug reports.
 function debugModels(r) {
   const d = t.debugModels;
-  const sum = { rows: 0, rowsWithModel: 0, calls: 0, fromTranscript: 0, unknown: 0 };
+  const sum = { rows: 0, rowsWithModel: 0, calls: 0, fromTranscript: 0, unknown: 0, unmetered: 0 };
   const lines = [d.header.join('\t')];
   for (const s of r.sessions) {
     const m = s.modelSources;
     for (const k of Object.keys(sum)) sum[k] += m[k];
-    lines.push([s.id.slice(0, 8), m.calls, m.rows, m.rowsWithModel, m.fromTranscript, m.unknown, s.model ? `${s.model.model} (${s.model.effort})` : '', m.unknown ? m.candidates.join(' | ') : ''].join('\t'));
+    lines.push([s.id.slice(0, 8), m.calls, m.rows, m.rowsWithModel, m.fromTranscript, m.unknown, s.model ? `${s.model.model} (${s.model.effort})` : '', m.unknown ? m.candidates.join(' | ') : '',
+      m.unmetered || '', m.unmetered ? m.unmeteredKeys.join(' ') : ''].join('\t'));
   }
-  lines.push([d.total, sum.calls, sum.rows, sum.rowsWithModel, sum.fromTranscript, sum.unknown, '', ''].join('\t'), '', d.note, '');
+  lines.push([d.total, sum.calls, sum.rows, sum.rowsWithModel, sum.fromTranscript, sum.unknown, '', '', sum.unmetered || '', ''].join('\t'), '', d.note, '');
   return lines.join('\n');
 }
 

package/docs/how-it-works.md

@@ -35,7 +35,7 @@ It is undocumented; this is what has been observed in `agy` 1.4.x.
 - 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/findings.js

@@ -10,7 +10,7 @@ const DEFAULTS = { crossSessionMin: 3, heavyOutputTokens: 2000, longSessionToken
 // Suggested .antigravityignore patterns for the built-in non-source types.
 const KIND_PATTERNS = {
   'node_modules': ['node_modules/'],
-  'build': ['bin/', 'obj/', 'dist/', 'build/', 'out/', 'target/', 'coverage/'],
+  'build': ['bin/', 'obj/', 'dist/', 'build/', 'out/', 'target/', 'coverage/', 'allure-results/', 'allure-report/'],
   'lockfiles': ['*.lock', 'package-lock.json', 'pnpm-lock.yaml', 'packages.lock.json'],
   'logs': ['*.log', '*.map', '*.min.js', '*.min.css'],
   'generated': ['*.designer.cs', '*.g.cs', 'Migrations/'],
@@ -126,8 +126,9 @@ function findings(r, opts = {}) {
   const size = (s) => (s.usage ? s.usage.input + s.usage.output : s.tokens);
   const long = r.sessions.filter((s) => size(s) >= o.longSessionTokens);
   if (long.length) {
+    // `exact`: every one has real usage, so the header shows the same figures as its items, as a share of real usage.
     out.push({
-      id: 'long-sessions', level: 'info', title: f.longTitle, tokens: sum(long, (s) => s.tokens),
+      id: 'long-sessions', level: 'info', title: f.longTitle, tokens: sum(long, size), exact: long.every((s) => s.usage),
       why: f.longWhy(long.length, num(o.longSessionTokens)), suggestion: f.longSuggestion,
       items: long.slice(0, 5).map((s) => ({
         // Real tokens when agy logged them (`exact`: shown without "~"), else the size estimate.

package/lib/history.js

@@ -114,6 +114,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,
@@ -154,7 +187,7 @@ function kind(p, { inRepo = false } = {}) {
   // 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 (!inRepo && /(^|\/)(dist|build|out|target|coverage|\.next|bin|obj)\//i.test(p)) return 'build';
+  if (!inRepo && /(^|\/)(dist|build|out|target|coverage|allure-results|allure-report|\.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';
@@ -221,7 +254,10 @@ function realUsage(dir, id) {
   try { text = fs.readFileSync(file, 'utf8'); } catch { return null; }
   // `days`: the same figures per local day of each model call (calls without a time go under null).
   // `perCall`: each call's figures, in order, and the model selected in the transcript when it was made.
-  const u = { calls: 0, input: 0, cache: 0, output: 0, errors: 0, start: null, end: null, days: new Map(), perCall: [] };
+  // `calls` counts only the calls that carry token counts; some logs (seen with the VS Code plugin) list
+  // calls without them, and counting those as 0 tokens would drag every per-call figure down.
+  // `unmetered`: those other calls, and `unmeteredKeys` the field names they do have, for --debug-models.
+  const u = { calls: 0, input: 0, cache: 0, output: 0, errors: 0, start: null, end: null, days: new Map(), perCall: [], unmetered: 0, unmeteredKeys: new Set() };
   let selected = null;
   u.unrecognized = new Set();
   for (const line of text.split('\n')) {
@@ -236,11 +272,17 @@ function realUsage(dir, id) {
       for (const m of String(e.content).matchAll(MODEL_SETTING_RE)) if (!modelOf([m[1].trim()]).model) u.unrecognized.add(m[1].trim().slice(0, 60));
     }
     if (e.type !== 'PLANNER_RESPONSE') continue;
+    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, at });
+      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, model: selected });
+    u.perCall.push({ metered: true, input: Number(e.input_tokens) || 0, cache: Number(e.cache_read_tokens) || 0, output: Number(e.output_tokens) || 0, model: selected });
     const k = at ? dayKey(at) : null;
     const d = u.days.get(k) || { calls: 0, input: 0, cache: 0, output: 0 };
     d.calls++;
@@ -252,6 +294,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
@@ -317,9 +380,11 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
     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;
+      const log = realUsage(dir, id);
+      const end = log?.end ?? fs.statSync(path.join(dir, f)).mtimeMs;
+      const start = log?.start ?? end;
+      // 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; }
@@ -379,6 +444,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];
@@ -393,9 +460,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 = usage ? usage.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;
@@ -412,7 +479,7 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
           e.calls++;
           if (!seenModels.has(k)) { seenModels.add(k); e.convs++; }
           const c = calls[i];
-          if (c) { e.known++; e.input += c.input; e.cache += c.cache; e.output += c.output; }
+          if (c?.metered) { e.known++; e.input += c.input; e.cache += c.cache; e.output += c.output; }
           models.set(k, e);
           if (m.model) counts.set(k, (counts.get(k) || 0) + 1);
         });
@@ -426,7 +493,8 @@ async function analyze({ dir = DEFAULT_DIR, workspaces = [], customKinds = {}, s
           // the short strings that look like a model id (to spot a new format). Never prompts, paths or code.
           modelSources: { rows: metaRows.length, rowsWithModel: metaRows.filter((m) => m.model).length, calls: calls.length,
             fromTranscript: calls.filter((c) => c?.model).length, unknown: callModels.filter((m) => !m.model).length,
-            candidates: [...new Set([...(usage?.unrecognized || []),
+            unmetered: log?.unmetered || 0, unmeteredKeys: [...(log?.unmeteredKeys || [])].sort(),
+            candidates: [...new Set([...(log?.unrecognized || []),
               ...metaStrs.filter((_, i) => !metaRows[i].model).flat().filter(looksLikeModel)])].slice(0, 10) },
         });
         r.tokens += convBytes / BYTES_PER_TOKEN;

package/lib/i18n.js

@@ -35,7 +35,7 @@ Options:
   mapDone: (tokens, file) => `\n~${tokens} tokens on every request. Paste it into ${file} if you like it; agy-insights does not write it.`,
   reportName: 'report',
   debugModels: {
-    header: ['conversation', 'calls', 'gen_metadata rows', 'rows with model', 'calls with model in transcript', 'unknown', 'main model', 'unrecognized model ids'],
+    header: ['conversation', 'calls', 'gen_metadata rows', 'rows with model', 'calls with model in transcript', 'unknown', 'main model', 'unrecognized model ids', 'calls without tokens', 'fields of those calls'],
     total: 'total',
     note: 'Only counts and model names or ids: no paths, prompts or code. Paste it into an issue if models show up as unknown.',
   },
@@ -162,7 +162,7 @@ Options:
     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` : ''}.`,
+    footerReal: (missing) => `Real tokens: the ones Antigravity records in each conversation's log (subagents included)${missing ? `; ${plural(missing, 'conversation has', 'conversations have')} no token counts in its 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.',
@@ -211,7 +211,7 @@ Opciones:
   mapDone: (tokens, file) => `\n~${tokens} tokens en cada petición. Pégalo en ${file} si te convence; agy-insights no lo escribe.`,
   reportName: 'informe',
   debugModels: {
-    header: ['conversación', 'llamadas', 'filas gen_metadata', 'filas con modelo', 'llamadas con modelo en transcript', 'desconocidas', 'modelo principal', 'ids de modelo no reconocidos'],
+    header: ['conversación', 'llamadas', 'filas gen_metadata', 'filas con modelo', 'llamadas con modelo en transcript', 'desconocidas', 'modelo principal', 'ids de modelo no reconocidos', 'llamadas sin tokens', 'campos de esas llamadas'],
     total: 'total',
     note: 'Solo recuentos y nombres o ids de modelo: ni rutas, ni prompts, ni código. Pégalo en una incidencia si salen modelos desconocidos.',
   },
@@ -338,7 +338,7 @@ Opciones:
     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`}` : ''}.`,
+    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 tokens en su registro y no cuenta' : `${missing} conversaciones no tienen tokens en su 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.',

package/lib/report.js

@@ -38,9 +38,12 @@ function item(it) {
     <span class="num">${it.tokens ? `${it.exact ? '' : '~'}${fmt(it.tokens)}` : ''}</span></div>${extra}</li>`;
 }
 
-function finding(f, total) {
+// A finding's share: of real usage when its figure is real (`exact`), else of the estimated context.
+const share = (f, r) => (f.exact ? billed(r.usage) : r.tokens);
+
+function finding(f, r) {
   return `<section class="finding ${f.level}">
-    <h3>${esc(f.title)}${f.tokens ? ` <span class="tok">~${fmt(f.tokens)} tokens · ${pct(f.tokens, total)}</span>` : ''}</h3>
+    <h3>${esc(f.title)}${f.tokens ? ` <span class="tok">${f.exact ? '' : '~'}${fmt(f.tokens)} tokens · ${pct(f.tokens, share(f, r))}</span>` : ''}</h3>
     <p>${esc(f.why)}</p><p class="hint">${esc(f.suggestion)}</p>
     ${f.items.length ? `<ul class="items">${f.items.map(item).join('')}</ul>` : ''}
   </section>`;
@@ -188,7 +191,7 @@ function body(r, found, scope) {
     ${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>`}
+    ${found.length ? found.map((f) => finding(f, r)).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)}
@@ -358,7 +361,7 @@ function text(r, found, { scope, paths }) {
     }
   }
   for (const f of found) {
-    out.push('', `${f.level === 'warn' ? '⚠' : '•'} ${f.title}${f.tokens ? `  (~${fmt(f.tokens)} tokens, ${pct(f.tokens, r.tokens)})` : ''}`,
+    out.push('', `${f.level === 'warn' ? '⚠' : '•'} ${f.title}${f.tokens ? `  (${f.exact ? '' : '~'}${fmt(f.tokens)} tokens, ${pct(f.tokens, share(f, r))})` : ''}`,
       `  ${f.why}`, `  → ${f.suggestion}`);
     // Only file and folder labels are paths; commands and session ids are always shown.
     const hasPaths = ['rereads', 'non-source', 'cross-session'].includes(f.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-insights",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "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": [