@analitikisler/ai-tag-debugger 0.9.0 → 0.11.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@analitikisler/ai-tag-debugger",
   "mcpName": "io.github.analitikisler/ai-tag-debugger",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Open-source AI agent that QA-tests your website's analytics, ad and consent tracking (GA4, GTM, Google Ads, Meta, TikTok). Bring your own model (Claude, OpenAI, Gemini) or use it from your chat app over MCP.",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
     "setup": "node scripts/setup.js",
     "test": "node --test test/*.test.js",
     "demo:serve": "node examples/serve.js",
-    "demo": "node src/cli.js run --config examples/demo.config.json --scripted --no-ai --out reports/demo"
+    "demo": "node src/cli.js run --config examples/demo.config.json --scripted --no-ai"
   },
   "engines": {
     "node": ">=20"
@@ -57,5 +57,8 @@
     "openai": "^7.30.1",
     "playwright": "1.56.1",
     "zod": "^4.6.5"
+  },
+  "optionalDependencies": {
+    "fflate": "^0.8.3"
   }
 }

package/src/agent.js

@@ -95,7 +95,7 @@ const TIMEOUTS = { model: 180_000, action: 120_000, page: 60_000 };
 
 const LAST_STEP_WAIT_MS = 3000;
 
-class StepTimeout extends Error {}
+export class StepTimeout extends Error {}
 
 /** The promise's value, or a StepTimeout with this message once ms have passed. */
 function withTimeout(promise, ms, message) {

package/src/ask.js

@@ -0,0 +1,123 @@
+// Turns a plain sentence like "check my GA tags" into an aitd command.
+// The AI provider fills a fixed intent schema, so it can never invent options;
+// without an AI key a small keyword matcher handles the common phrases.
+import { PROVIDERS as PLATFORMS } from "./parsers.js";
+
+const PLATFORM_KEYS = Object.keys(PLATFORMS);
+// The same values as plan --topic (TOPICS in discover.js, kept in step by a test).
+export const TOPIC_KEYS = ["custom-events", "ecommerce", "forms", "consent"];
+
+export const INTENT_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  required: ["action", "site", "against", "platforms", "goal", "journey", "topic", "question"],
+  properties: {
+    action: { type: "string", enum: ["plan", "run", "report", "unclear"], description: "plan drafts what a site should track; run audits what the site sends; report re-reads an existing report; unclear when you cannot tell plan from run." },
+    site: { type: ["string", "null"], description: "The site's domain or URL if the sentence names one." },
+    against: { type: ["string", "null"], enum: ["plan", "latest", null], description: "run only: compare with the saved plan, or with the latest run (\"what changed\", \"since the last run\", \"after the deploy\")." },
+    platforms: { type: "array", items: { type: "string", enum: PLATFORM_KEYS }, description: "Only the tracking platforms the sentence names; empty for all." },
+    goal: { type: ["string", "null"], description: "run only: a short user journey to try, in plain words, e.g. \"submit the contact form\"." },
+    journey: { type: ["string", "null"], enum: ["purchase", null], description: "run only: purchase when the sentence is about the purchase event or revenue." },
+    topic: { type: ["string", "null"], enum: [...TOPIC_KEYS, null], description: "plan only: limit the plan to one kind of event when the sentence asks about it." },
+    question: { type: ["string", "null"], description: "One short question to ask back when the sentence is ambiguous; otherwise null." },
+  },
+};
+
+const SYSTEM = `You translate a request about website tracking (analytics, ads, consent tags) into options for the aitd command line tool. Fill the schema with only what the sentence says; leave the rest null or empty. Use action "unclear" and a short question when you cannot tell whether the user wants a tracking plan or an audit of the live site.`;
+
+const has = (s, re) => re.test(s);
+
+/** The intent for a sentence from keywords alone, for when no AI key is set. */
+export function matchKeywords(sentence) {
+  const s = ` ${sentence.toLowerCase()} `;
+  const intent = { action: null, site: null, against: null, platforms: [], goal: null, journey: null, topic: null, question: null };
+  const site = sentence.match(/\b(?:https?:\/\/)?((?:[a-z0-9-]+\.)+[a-z]{2,})(?:\/\S*)?/i);
+  if (site) intent.site = site[1].toLowerCase();
+
+  if (has(s, /google analytics|\bga4?\b/)) intent.platforms.push("ga4");
+  if (has(s, /google ads|adwords/)) intent.platforms.push("google_ads");
+  if (has(s, /\bmeta\b|facebook/)) intent.platforms.push("meta");
+  if (has(s, /tiktok/)) intent.platforms.push("tiktok");
+
+  if (has(s, /only the (errors|failures)|from the (last|latest) report/)) intent.action = "report";
+  else if (has(s, /tracking plan|make a plan|should .* track|does my site need|events .* need/)) intent.action = "plan";
+  else {
+    if (has(s, /since (the )?last run|what changed|\bbreak|\bbroke|deploy/)) intent.against = "latest";
+    else if (has(s, /(against|in) the plan/)) intent.against = "plan";
+    if (has(s, /revenue|purchase event/)) intent.journey = "purchase";
+    else if (has(s, /newsletter/)) intent.goal = "sign up for the newsletter";
+    else if (has(s, /accept(ing)? (the )?cookies|consent/)) intent.goal = "browse without accepting cookies";
+    else if (has(s, /contact form/)) intent.goal = "submit the contact form";
+    else if (has(s, /checkout/)) intent.goal = "reach checkout";
+    if (intent.platforms.length || intent.against || intent.goal || intent.journey || has(s, /\b(check|test|audit|firing|fire|working)\b/)) intent.action = "run";
+  }
+  if (intent.action === "plan") {
+    if (has(s, /custom events?/)) intent.topic = "custom-events";
+    else if (has(s, /ecommerce|e-commerce|online shop|\bshop\b|\bstore\b/)) intent.topic = "ecommerce";
+    else if (has(s, /\bforms?\b/)) intent.topic = "forms";
+    else if (has(s, /consent|cookies?/)) intent.topic = "consent";
+  }
+  if (!intent.action) {
+    intent.action = "unclear";
+    intent.question = "Do you want a tracking plan or a check of what the site sends? (plan/run)";
+  }
+  return intent;
+}
+
+/** Asks the provider for the intent of a sentence; falls back to keywords without one. */
+export async function translate(sentence, { provider } = {}) {
+  if (!provider) return { intent: matchKeywords(sentence), by: "keywords" };
+  const result = await provider.json({ system: SYSTEM, texts: [sentence], schema: INTENT_SCHEMA });
+  if (result.error) return { intent: matchKeywords(sentence), by: "keywords" };
+  return { intent: normalize(result.value), by: "ai" };
+}
+
+/** Keeps only schema values, so an odd reply can never become an option. */
+export function normalize(v = {}) {
+  const str = (x) => (typeof x === "string" && x.trim() ? x.trim() : null);
+  return {
+    action: ["plan", "run", "report", "unclear"].includes(v.action) ? v.action : "unclear",
+    site: str(v.site),
+    against: ["plan", "latest"].includes(v.against) ? v.against : null,
+    platforms: [...new Set((Array.isArray(v.platforms) ? v.platforms : []).filter((p) => PLATFORM_KEYS.includes(p)))],
+    goal: str(v.goal),
+    journey: v.journey === "purchase" ? "purchase" : null,
+    topic: TOPIC_KEYS.includes(v.topic) ? v.topic : null,
+    question: str(v.question),
+  };
+}
+
+const siteUrl = (site) => (/^https?:\/\//i.test(site) ? site : `https://${site}`);
+
+/** The aitd arguments for an intent, or { question } when one more answer is needed. */
+export function intentToArgs(intent) {
+  if (intent.action === "unclear") return { question: intent.question ?? "Do you want a tracking plan or a check of what the site sends? (plan/run)" };
+  if (intent.action === "report") return { unsupported: "Filtering an existing report is not available yet. Open the latest report in aitd/<domain>/runs/." };
+  const args = [intent.action];
+  if (intent.site) args.push("--site", siteUrl(intent.site));
+  if (intent.action === "plan" && intent.topic) args.push("--topic", intent.topic);
+  if (intent.action === "run") {
+    // --against takes a saved plan. Every run already reports what changed since the previous
+    // run, so "since the last run" needs no option of its own.
+    if (intent.against === "plan") args.push("--against", "latest");
+    if (intent.platforms.length) args.push("--platforms", intent.platforms.join(","));
+    if (intent.journey) args.push("--journey", intent.journey);
+    if (intent.goal) args.push("--goal", intent.goal);
+  }
+  return { args };
+}
+
+/** True when a run has nothing to test yet: no plan to check against, no journey, no goal. */
+export function needsWhatToTest(args) {
+  return args[0] === "run" && !["--against", "--journey", "--goal"].some((o) => args.includes(o));
+}
+
+/** The command as the user would type it. */
+export function commandText(args) {
+  return ["aitd", ...args.map((a) => (/^[\w.,:/@=-]+$/.test(a) ? a : `"${a.replace(/(["\\$`])/g, "\\$1")}"`))].join(" ");
+}
+
+/** True when the arguments are one sentence rather than a command. */
+export function isSentence(positionals) {
+  return positionals.length === 1 && /\s/.test(positionals[0].trim());
+}

package/src/audit.js

@@ -1,14 +1,16 @@
 // A full audit from a config file: run every journey, check, explain, write the reports.
 // Shared by the CLI and the MCP server's run_audit tool.
+import { newRunDir } from "./workspace.js";
+import { compareRuns, previousRun } from "./changes.js";
 import { readFile, mkdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { failedRun, runJourney } from "./agent.js";
 import { VIEWPORTS } from "./browser.js";
-import { checkRun, groupFindings, summarize } from "./checks.js";
+import { checkRun, groupFindings, planCheck, summarize } from "./checks.js";
 import { explainFindings, renderCsv, renderHtml, renderMarkdown } from "./report.js";
 import { LANGUAGES, messages } from "./i18n.js";
 import { createProvider } from "./providers.js";
-import { filterFindings, planRun } from "./journeys.js";
+import { filterFindings, JOURNEY_PRESETS, planRun } from "./journeys.js";
 import { resolveProviders } from "./parsers.js";
 import { SAVED_SITE_FILE, writeSavedSite } from "./replay.js";
 
@@ -32,30 +34,38 @@ export async function loadConfig(configFile) {
   return { config, plan, gtmContainer };
 }
 
-export const defaultOutDir = () => path.resolve("reports", new Date().toISOString().replace(/[:.]/g, "-"));
 
-/** Writes report.md, report.html, timeline.csv and capture.json. */
-export async function writeReports({ outDir, config, plan, runs, findings, explained, lang, branding = config.branding !== false }) {
+/**
+ * Writes report.md, report.html, timeline.csv and capture.json, plus plan-check.json with --against.
+ * previous: the site's last saved run (see previousRun), null when there is none, or undefined to skip
+ * the "Changed since last run" section.
+ */
+export async function writeReports({ outDir, config, plan, runs, findings, explained, lang, against = null, branding = config.branding !== false, previous = undefined }) {
   await mkdir(outDir, { recursive: true });
   const title = messages(lang).ui.title(new URL(config.site).hostname);
   const generatedAt = new Date().toISOString().slice(0, 16).replace("T", " ") + " UTC";
-  const report = { title, generatedAt, findings, explained, runs, plan, lang, branding };
+  const check = against ? { plan_id: against.id ?? null, ...planCheck(plan, runs, findings) } : null;
+  const changes = previous === undefined ? null : compareRuns(previous, { findings, planCheck: check });
+  const report = { title, generatedAt, findings, explained, runs, plan, lang, branding, against: against?.label ?? null, planCheck: check, changes };
   await writeFile(path.join(outDir, "report.md"), renderMarkdown(report));
   await writeFile(path.join(outDir, "report.html"), renderHtml(report));
   await writeFile(path.join(outDir, "timeline.csv"), renderCsv(report));
-  await writeFile(path.join(outDir, "capture.json"), JSON.stringify({ config: { ...config, plan }, runs, findings, explained }, null, 2));
+  if (check) await writeFile(path.join(outDir, "plan-check.json"), JSON.stringify(check, null, 2));
+  await writeFile(path.join(outDir, "capture.json"), JSON.stringify({ config: { ...config, plan }, ...(against ? { against: { plan_id: against.id, file: against.file } } : {}), runs, findings, explained, ...(changes ? { changes } : {}) }, null, 2));
   return path.join(outDir, "report.html");
 }
 
 /**
  * @param {{ config: any, plan?: any, gtmContainer?: any, journeys?: string[], goals?: string[], events?: string[], viewports?: string[],
  *   scripted?: boolean, ai?: boolean, provider?: string, model?: string, baseUrl?: string, maxSteps?: number, lang?: string, headed?: boolean,
- *   outDir?: string, branding?: boolean, providers?: string[], saveSite?: string, replaySite?: string, log?: (m: string) => void }} opts
+ *   outDir?: string, dataDir?: string, branding?: boolean, providers?: string[], saveSite?: string, replaySite?: string, log?: (m: string) => void }} opts
  *   journeys: config journey ids or ready-made journeys (purchase, add_to_cart, sign_up, lead, search).
  *   goals: extra journeys described in plain language. events: only check these events.
  *   providers: tracking providers to check (default: config "providers", else GA4, Google Ads, Meta, TikTok).
  *   saveSite: record the site's responses and the steps taken into this folder, for replaySite (see replay.js).
  *   replaySite: answer every request from a folder saved with saveSite, without the network.
+ *   against: { id, file } of the plan given with --against; opts.plan is then that plan. Used alone, the
+ *   journeys come from the plan; with journeys or goals, only the plan events expected on them are checked.
  */
 export async function runAudit(opts) {
   const { gtmContainer } = opts;
@@ -68,19 +78,29 @@ export async function runAudit(opts) {
   const useAi = opts.ai !== false;
   if (!useAi && !opts.scripted) throw new Error("Without an AI model, journeys must be replayed from their fixed steps (scripted).");
 
-  const { journeys, plan } = planRun({ config, plan: opts.plan, picks: opts.journeys, goals: opts.goals, events });
+  const against = opts.against ? { ...opts.against, label: opts.against.id ?? path.relative(process.cwd(), opts.against.file) } : null;
+  const { journeys, plan } = planRun({ config, plan: opts.plan, picks: opts.journeys, goals: opts.goals, events, against: Boolean(against) });
   config = { ...config, providers: resolveProviders(opts.providers ?? config.providers, plan) };
   const viewports = opts.viewports?.length ? opts.viewports : config.viewports ?? ["desktop"];
   const allowed = Object.keys(VIEWPORTS).join(", ");
   if (!Array.isArray(viewports)) throw new Error(`"viewports" must be a list, e.g. ["desktop", "mobile"]. Allowed values: ${allowed}.`);
   const unknown = viewports.filter((v) => !Object.hasOwn(VIEWPORTS, v));
   if (unknown.length) throw new Error(`Unknown viewport ${unknown.map((v) => `"${v}"`).join(", ")}. Use: ${allowed}.`);
-  if (!journeys.length) throw new Error("No journeys to run. Pick one with --journey (e.g. purchase) or describe one with --goal.");
+  if (!journeys.length) throw new Error(`No journeys to run. A run needs one of:\n  --journey <name>   one of: ${Object.keys(JOURNEY_PRESETS).join(", ")} (or a journey id from your config)\n  --goal "<text>"    describe what to do in your own words\n  --config <file>    a config file with "journeys"\nNot sure what to test? "aitd plan --site ${config.site}" drafts a measurement plan.`);
   if (opts.scripted) {
     const unscripted = journeys.filter((j) => !j.steps?.length && !j.incomplete).map((j) => j.id);
     if (unscripted.length) throw new Error(`Journeys without fixed steps can't be replayed with --scripted: ${unscripted.join(", ")}.`);
   }
 
+  if (against) {
+    const notChecked = plan.events.filter((e) => Array.isArray(e.journeys) && !e.journeys.some((j) => journeys.some((jj) => jj.id === j))).length;
+    log(`Checking against plan ${against.label}: ${journeys.length} ${journeys.length === 1 ? "journey" : "journeys"}${notChecked ? `, ${notChecked} planned ${notChecked === 1 ? "event" : "events"} not checked in this run` : ""}`);
+    for (const j of journeys) {
+      const expected = plan.events.filter((e) => !e.journeys || e.journeys.includes(j.id)).map((e) => e.name);
+      log(`  - ${j.id}: ${j.goal ?? "fixed steps"}${expected.length ? ` [${[...new Set(expected)].join(", ")}]` : ""}`);
+    }
+  }
+
   const provider = useAi ? await createProvider({ name: opts.provider ?? config.provider, model: opts.model ?? config.model, baseUrl: opts.baseUrl ?? config.base_url }) : null;
   if (provider) log(`Using ${provider.name} (${provider.model})`);
 
@@ -116,8 +136,10 @@ export async function runAudit(opts) {
     explained = await explainFindings({ findings, plan, runs, gtmContainer, provider, lang, log });
   }
 
-  const outDir = path.resolve(opts.outDir ?? defaultOutDir());
-  const reportPath = await writeReports({ outDir, config, plan, runs, findings, explained, lang, branding: opts.branding ?? config.branding !== false });
+  // Runs saved in the site's runs folder are compared with the one before; a run sent to --out is not.
+  const previous = opts.outDir ? undefined : await previousRun(opts.dataDir, config.site);
+  const outDir = path.resolve(opts.outDir ?? (await newRunDir(opts.dataDir, config.site)).dir);
+  const reportPath = await writeReports({ outDir, config, plan, runs, findings, explained, lang, against, branding: opts.branding ?? config.branding !== false, previous });
   const counts = summarize(groupFindings(findings));
-  return { journeys, plan, runs, findings, explained, counts, reportPath, outDir, lang, ...(saveError ? { saveError } : {}) };
+  return { journeys, plan, runs, findings, explained, counts, reportPath, outDir, lang, ...(against ? { againstId: against.id } : {}), ...(saveError ? { saveError } : {}) };
 }

package/src/changes.js

@@ -0,0 +1,66 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { listRunIds, runsDir } from "./workspace.js";
+
+const PROBLEMS = new Set(["broken", "risk", "warning"]);
+const PLAN_PROBLEMS = new Set(["missing", "missing_params", "wrong_values"]);
+
+const readJson = (file) => readFile(file, "utf8").then(JSON.parse).catch(() => null);
+
+/** The site's newest saved run before this one, with its capture and plan check, or null. */
+export async function previousRun(dataDir, site, before = null) {
+  const ids = (await listRunIds(dataDir, site)).filter((id) => !before || id < before);
+  for (const id of ids.reverse()) {
+    const dir = path.join(runsDir(dataDir, site), id);
+    const capture = await readJson(path.join(dir, "capture.json"));
+    if (capture) return { id, capture, planCheck: await readJson(path.join(dir, "plan-check.json")) };
+  }
+  return null;
+}
+
+/** One entry per problem, keyed so the same problem matches across runs whatever its wording. */
+function findingProblems(findings = []) {
+  const out = new Map();
+  for (const f of findings) {
+    if (!PROBLEMS.has(f.severity)) continue;
+    const k = [f.check, f.platform ?? "", f.event ?? ""].join("|");
+    if (!out.has(k)) out.set(k, { check: f.check, platform: f.platform ?? null, event: f.event ?? null, severity: f.severity, detail: f.detail });
+  }
+  return out;
+}
+
+function planProblems(pc) {
+  const out = new Map();
+  for (const e of pc?.events ?? []) out.set(`${e.platform}|${e.event}`, { platform: e.platform, event: e.event, bucket: e.bucket });
+  return out;
+}
+
+/**
+ * What changed since the previous run of the same site. Compares plan coverage when both runs were
+ * checked against a plan, and the health findings otherwise.
+ * Returns { previous: null } when there is no earlier run, else
+ * { previous, mode: "plan" | "findings", fixed: [...], new: [...] }.
+ */
+export function compareRuns(prev, { findings, planCheck = null }) {
+  if (!prev) return { previous: null };
+  if (planCheck && prev.planCheck) {
+    const before = planProblems(prev.planCheck);
+    const now = planProblems(planCheck);
+    const fixed = [];
+    const added = [];
+    for (const [k, e] of now) {
+      const was = before.get(k)?.bucket;
+      if (e.bucket === "implemented" && PLAN_PROBLEMS.has(was)) fixed.push({ ...e, was });
+      if (PLAN_PROBLEMS.has(e.bucket) && !PLAN_PROBLEMS.has(was)) added.push({ ...e, was: was ?? null });
+    }
+    return { previous: prev.id, mode: "plan", fixed, new: added };
+  }
+  const before = findingProblems(prev.capture?.findings);
+  const now = findingProblems(findings);
+  return {
+    previous: prev.id,
+    mode: "findings",
+    fixed: [...before].filter(([k]) => !now.has(k)).map(([, f]) => f),
+    new: [...now].filter(([k]) => !before.has(k)).map(([, f]) => f),
+  };
+}

package/src/checks.js

@@ -110,7 +110,7 @@ function expectedIn(planEvent, journeyId) {
   return !planEvent.journeys || planEvent.journeys.includes(journeyId);
 }
 
-function isConsentCommand(entry, kind) {
+export function isConsentCommand(entry, kind) {
   return Array.isArray(entry.value) && entry.value[0] === "consent" && entry.value[1] === kind;
 }
 
@@ -444,3 +444,58 @@ export function groupFindings(findings) {
   }
   return [...groups.values()].sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity]);
 }
+
+const WRONG_VALUE_CHECKS = new Set(["purchase_value_invalid", "purchase_currency_invalid", "purchase_items_empty", "purchase_mismatch"]);
+export const PLAN_BUCKETS = ["implemented", "missing", "missing_params", "wrong_values", "unplanned", "not_checked"];
+
+/**
+ * Sorts every planned event into one bucket from the runs and the findings checkRun gave them:
+ * implemented, missing, missing_params, wrong_values or not_checked, plus one unplanned entry per
+ * event that fired but is not in the plan. Coverage = implemented / planned events that were checkable.
+ * @param {Plan} plan
+ * @param {any[]} runs
+ * @param {Finding[]} findings
+ */
+export function planCheck(plan, runs, findings) {
+  const events = (plan?.events ?? []).map((e) => ({ ...e, platform: String(e.platform ?? "").toLowerCase() }));
+  const entries = [];
+  for (const ev of events) {
+    const walked = runs.filter((r) => expectedIn(ev, r.journeyId) && (!r.providers || r.providers.includes(ev.platform)));
+    const entry = { platform: ev.platform, event: ev.name, bucket: "not_checked", journeys: [...new Set(walked.map((r) => r.journeyId))] };
+    if (walked.length) {
+      const own = findings.filter((f) => f.event && walked.some((r) => r.journeyId === f.journey && r.viewport === f.viewport) && hitMatchesEvent(ev, { platform: f.platform, name: f.event }));
+      const params = own.filter((f) => f.check === "missing_params");
+      const values = own.filter((f) => WRONG_VALUE_CHECKS.has(f.check));
+      const fired = walked.some((r) => r.hits.some((h) => hitMatchesEvent(ev, h)));
+      if (params.length) entry.bucket = "missing_params";
+      else if (values.length) entry.bucket = "wrong_values";
+      else entry.bucket = fired ? "implemented" : "missing";
+      const details = [...new Set([...params, ...values].map((f) => f.detail))];
+      if (details.length) entry.details = details;
+    }
+    entries.push(entry);
+  }
+  // Unplanned events, from the runs whose unplanned_events finding survived the --event filter.
+  const seen = new Set();
+  for (const r of runs) {
+    if (!findings.some((f) => f.check === "unplanned_events" && f.journey === r.journeyId && f.viewport === r.viewport)) continue;
+    for (const h of r.hits) {
+      if (events.some((e) => hitMatchesEvent(e, h)) || seen.has(key(h.platform, h.name))) continue;
+      seen.add(key(h.platform, h.name));
+      entries.push({ platform: h.platform, event: h.name, bucket: "unplanned", journeys: [r.journeyId] });
+    }
+  }
+  const score = (list) => {
+    const planned = list.filter((e) => e.bucket !== "unplanned");
+    const checkable = planned.filter((e) => e.bucket !== "not_checked").length;
+    const implemented = planned.filter((e) => e.bucket === "implemented").length;
+    return { implemented, checkable, not_checked: planned.length - checkable, percent: checkable ? Math.round((implemented / checkable) * 100) : null };
+  };
+  const platforms = [...new Set(entries.filter((e) => e.bucket !== "unplanned").map((e) => e.platform))];
+  const counts = Object.fromEntries(PLAN_BUCKETS.map((b) => [b, entries.filter((e) => e.bucket === b).length]));
+  return {
+    coverage: { ...score(entries), platforms: Object.fromEntries(platforms.map((p) => [p, score(entries.filter((e) => e.platform === p))])) },
+    counts,
+    events: entries,
+  };
+}