token-goat 2.9.29 → 2.9.30

package/dist/token-goat-chunk-3Z5S4KGM.mjs

@@ -0,0 +1,918 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  getDb,
+  isReadOnlyDb
+} from "./token-goat-chunk-VL3YIFHZ.mjs";
+import {
+  Database
+} from "./token-goat-chunk-XB5KKOCG.mjs";
+import {
+  getHarnessName
+} from "./token-goat-chunk-U4N3BN2W.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  countNoun,
+  ensureDirSync,
+  extractErrorMessage
+} from "./token-goat-chunk-GOLEOXZP.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  VERSION,
+  dataDir,
+  dataDirForHome
+} from "./token-goat-chunk-VES7EL7O.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/stats.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// src/token_estimate.ts
+init_define_import_meta_env();
+var BYTES_PER_TOKEN = {
+  text: 4,
+  dense: 1.45
+};
+var GUARD_MARGIN = 0.75;
+function creditDivisor(cls = "text") {
+  return BYTES_PER_TOKEN[cls];
+}
+function guardDivisor(cls = "text") {
+  return BYTES_PER_TOKEN[cls] * GUARD_MARGIN;
+}
+var DENSE_ALPHABET = /^[A-Za-z0-9+/=_-]$/;
+var MIN_DENSE_SAMPLE = 200;
+var MIN_DENSE_DISTINCT = 16;
+var CLASSIFY_SAMPLE_CHARS = 4096;
+function classifyContent(text) {
+  const sample = text.slice(0, CLASSIFY_SAMPLE_CHARS);
+  if (sample.length < MIN_DENSE_SAMPLE) return "text";
+  let whitespace = 0;
+  let dense = 0;
+  const distinct = /* @__PURE__ */ new Set();
+  for (const ch of sample) {
+    if (ch === " " || ch === "\n" || ch === "	" || ch === "\r") whitespace++;
+    else if (DENSE_ALPHABET.test(ch)) {
+      dense++;
+      distinct.add(ch);
+    }
+  }
+  if (whitespace / sample.length >= 0.05) return "text";
+  if (distinct.size < MIN_DENSE_DISTINCT) return "text";
+  return dense / sample.length >= 0.95 ? "dense" : "text";
+}
+
+// src/stats.ts
+var HARNESS_UNRECORDED = "unrecorded (pre-2.8.1)";
+var PRICING_VERSION_UNRECORDED = "unrecorded (pre-tg_version column)";
+function hasMixedPricingEras(summary) {
+  return Object.keys(summary.by_pricing_version).length > 1;
+}
+var SOURCE_IMAGE = "image";
+var SOURCE_HINT = "hint";
+var SOURCE_READ = "read";
+var SOURCE_BASH = "bash";
+var SOURCE_WEB = "web";
+var SOURCE_MCP = "mcp";
+var SOURCE_SKILL = "skill";
+var SOURCE_CONTENT = "content";
+var SOURCE_OTHER = "other";
+var COUNT_ONLY_KINDS = /* @__PURE__ */ new Set(["secret_redacted"]);
+function savedTokensFromBytes(bytes, cls = "text") {
+  return Math.round(Math.max(0, bytes) / creditDivisor(cls));
+}
+var KIND_TO_SOURCE = {
+  image_shrink: SOURCE_IMAGE,
+  image_shrink_cache_hit: SOURCE_IMAGE,
+  image_shrink_skipped: SOURCE_IMAGE,
+  image_shrink_over_pixel_limit: SOURCE_IMAGE,
+  image_ocr: SOURCE_IMAGE,
+  webfetch_image: SOURCE_IMAGE,
+  gdrive_image: SOURCE_IMAGE,
+  session_hint: SOURCE_HINT,
+  session_hint_suppressed: SOURCE_HINT,
+  diff_hint: SOURCE_HINT,
+  evidence_cache_hit: SOURCE_HINT,
+  structured_file_hint: SOURCE_HINT,
+  predictive_prefetch_hit: SOURCE_HINT,
+  grep_dedup_hint: SOURCE_HINT,
+  glob_dedup_hint: SOURCE_HINT,
+  write_rewrite_hint: SOURCE_HINT,
+  websearch_dedup_hint: SOURCE_HINT,
+  large_file_hint_followed: SOURCE_HINT,
+  large_file_hint_ignored: SOURCE_HINT,
+  read_count_deny: SOURCE_HINT,
+  read_served_deny: SOURCE_HINT,
+  // hooks_read.ts's subagent first-read markdown deny (hints.subagent_markdown_first_read_deny, off by default). Always recorded at 0 bytes / 0 tokens: no first-read deny of this shape exists in the transcript corpus, so its abandoned/substituted/shell-read/retried rates are unknown and can only be borrowed from the re-read heading-tree census. Booking withheld bytes against borrowed rates would claim a saving this path cannot back up. The kind exists to make the intervention countable in session-audit, not to claim a win.
+  subagent_markdown_first_read_deny: SOURCE_HINT,
+  // hooks_agent_spawn.ts's scoped-spawn deny (hints.agent_scoped_spawn_deny, off by default). Recorded at 0 bytes / 0 tokens: the lane prefix a redirected spawn avoids depends on which agent the retry picks, if any, and nothing in the hook can observe that, so booking a saving here would be a guess.
+  agent_scoped_spawn_deny: SOURCE_HINT,
+  // A measurement booked beside every whole-file re-read deny in hooks_read.ts: which branch fired and whether the refused file still held what the session last read (detail `branch=… identity=identical|changed|unknown basis=snapshot|stat|none edited=0|1`). SOURCE_OTHER, not SOURCE_HINT: stats_report.ts counts SOURCE_HINT events as hints fired, and this row is a second record of a deny its sibling session_hint or read_count_deny row already counts.
+  reread_deny_identity: SOURCE_OTHER,
+  // A measurement booked by postEditHandler when an edit lands on a file whose last Read in the session handed over only part of it (detail `last_read=outline|skeleton|fold|truncated|partial tool=<name>`), from the record read_shape.ts keeps. Zero bytes: it saves nothing, it counts edits composed from a partial view.
+  edit_after_fold: SOURCE_OTHER,
+  read_replacement: SOURCE_READ,
+  section_replacement: SOURCE_READ,
+  symbol_read: SOURCE_READ,
+  section_read: SOURCE_READ,
+  stub_view: SOURCE_READ,
+  symbol_lookup: SOURCE_READ,
+  semantic_search: SOURCE_READ,
+  map_lookup: SOURCE_READ,
+  changed_lookup: SOURCE_READ,
+  outline: SOURCE_READ,
+  exports: SOURCE_READ,
+  imports: SOURCE_READ,
+  dep_docs: SOURCE_READ,
+  csv_query: SOURCE_READ,
+  csv_profile: SOURCE_READ,
+  pdf_extract: SOURCE_READ,
+  pdf_locate: SOURCE_READ,
+  pdf_outline: SOURCE_READ,
+  pdf_meta: SOURCE_READ,
+  xlsx_sheets: SOURCE_READ,
+  xlsx_head: SOURCE_READ,
+  xlsx_range: SOURCE_READ,
+  xlsx_query: SOURCE_READ,
+  xlsx_columns: SOURCE_READ,
+  pptx_outline: SOURCE_READ,
+  pptx_slide: SOURCE_READ,
+  pptx_notes: SOURCE_READ,
+  pptx_text: SOURCE_READ,
+  docx_outline: SOURCE_READ,
+  docx_tables: SOURCE_READ,
+  docx_text: SOURCE_READ,
+  transcript_outline: SOURCE_READ,
+  transcript: SOURCE_READ,
+  video_chapters: SOURCE_READ,
+  image_meta: SOURCE_READ,
+  image_text: SOURCE_READ,
+  coverage_report_gaps: SOURCE_READ,
+  json_query: SOURCE_READ,
+  json_outline: SOURCE_READ,
+  yaml_query: SOURCE_READ,
+  yaml_outline: SOURCE_READ,
+  xml_query: SOURCE_READ,
+  xml_outline: SOURCE_READ,
+  html_query: SOURCE_READ,
+  html_outline: SOURCE_READ,
+  openapi_op: SOURCE_READ,
+  openapi_outline: SOURCE_READ,
+  zip_list: SOURCE_READ,
+  zip_read: SOURCE_READ,
+  sqlite_query: SOURCE_READ,
+  sqlite_schema: SOURCE_READ,
+  sqlite_tables: SOURCE_READ,
+  conflicts: SOURCE_READ,
+  brief_view: SOURCE_READ,
+  session_outline: SOURCE_READ,
+  session_slice: SOURCE_READ,
+  gdrive_sections: SOURCE_READ,
+  pr_slice: SOURCE_READ,
+  compact_doc: SOURCE_READ,
+  note_read: SOURCE_READ,
+  note_list: SOURCE_READ,
+  // note-add is a write (like insert-section/replace, which record no stat at all -- neither has a "full source it replaces" savings concept). It still gets an event-only entry here (no bytesSaved/tokensSaved argument, same as skill_load) purely so `token-goat note-add` usage is visible in `token-goat stats --full` at all -- SOURCE_OTHER, not SOURCE_READ, since it is not a token-savings substitute for a read.
+  note_write: SOURCE_OTHER,
+  web_fetch: SOURCE_WEB,
+  injection_detected: SOURCE_WEB,
+  skill_load: SOURCE_SKILL,
+  skill_oversized_first_load: SOURCE_SKILL,
+  // Cold first load of an oversized skill where preSkillHandler inlined the compact slice in its reply instead of pointing at `skill-body --compact`. Unlike its skill_oversized_first_load sibling (event-only, 0 bytes -- the pointer deny saves nothing by itself, the follow-up command does) this one records real savings: the full body never landed, the slice did, so bytesSaved is body minus slice.
+  skill_compact_inlined: SOURCE_SKILL,
+  // Cold first load of an oversized skill with no compact marker at all, where preSkillHandler inlined a heading tree in its reply instead of letting the whole body fall through. Same shape as skill_compact_inlined: real savings, bytesSaved is body minus the rendered tree.
+  skill_heading_tree_inlined: SOURCE_SKILL,
+  secret_redacted: SOURCE_OTHER,
+  // Fail-soft diagnostic counters from hooks_edit.ts: they record that a side task threw, never a byte saving, so "other" is the right home. Listed explicitly rather than left to kindToSource()'s fallback so the registration guard can tell a deliberate placement from an unregistered kind.
+  dirty_queue_append_failed: SOURCE_OTHER,
+  worker_healthcheck_failed: SOURCE_OTHER,
+  known_root_record_failed: SOURCE_OTHER,
+  // Same fail-soft shape, from hooks_session_start.ts's reconcileNote: a thrown reconcile sweep must not block session start, but it also must not vanish silently, so the catch that swallows it records why instead of returning null with nothing recorded.
+  reconcile_note_failed: SOURCE_OTHER,
+  // Measurement of what a compaction produced (hooks_compact.ts postCompactHandler): summary size and how many manifest paths survived into it. SOURCE_OTHER and always recorded at (0, 0) -- the summary was written whether or not token-goat was watching, so there is no counterfactual in which those bytes were saved. Filing it anywhere with a savings total would credit token-goat for the whole summary, which is the accounting mistake this registry exists to prevent.
+  compact_summary: SOURCE_OTHER,
+  // One row per failed tool call the post_tool_use_failure hook sees (hooks_tool_failure.ts), with its tool_error_class.ts verdict in `detail` so failure rates by reason accumulate going forward. A measurement at (0, 0): a failure saves nothing.
+  tool_failure: SOURCE_OTHER,
+  // Envelope compaction of an oversized subagent report (hooks_agent_spawn.ts). SOURCE_CONTENT, not SOURCE_HINT: the handler's sibling session_hint entry is advisory (it only appends a recall pointer and genuinely saves nothing), whereas this kind records a real rewrite with real bytes removed, so filing it under the advisory bucket would understate the compaction and repeat the zero-savings desync this registry keeps getting bitten by.
+  agent_report_compact: SOURCE_CONTENT,
+  // Decline counterpart to agent_report_compact: the fence-collapse net-benefit gate ran and found at least one over-long fence, but declined to rewrite because net savings did not clear the notice cost. Always recorded at (0, 0) -- see the recordStat call site -- so it never contributes to any savings total; it exists purely to make gate hit-rate and near-misses visible instead of the decline being invisible.
+  agent_report_compact_declined: SOURCE_CONTENT,
+  content_compress: SOURCE_CONTENT,
+  // Verbatim-repeat collapse of a browser tool's "Tab Context:" text block (hooks_browser_image.ts postBrowserImageHandler). SOURCE_CONTENT for the same reason as agent_report_compact above: it is a real rewrite with real bytes removed, not an advisory nudge. Deliberately not SOURCE_IMAGE -- it shares a handler with image_shrink but collapses text, and folding text bytes into the image ledger is the two-units-under-one-label mistake this file's image_shrink entry was just fixed for.
+  browser_tab_dedup: SOURCE_CONTENT,
+  // Collapse of the plan echo in an approved ExitPlanMode result (hooks_exitplanmode.ts). SOURCE_CONTENT for the same reason as agent_report_compact: real bytes removed from a tool result, not an advisory nudge. The handler shipped for releases emitting this rewrite and recording nothing at all, so the mechanism was invisible in `stats` and its net benefit could not be checked against the gate that admits it.
+  plan_echo_collapse: SOURCE_CONTENT,
+  // Lossless re-layout of Grep content-mode output (hooks_grep.ts foldGrepContentHandler). SOURCE_CONTENT, not SOURCE_HINT, for the same reason as agent_report_compact above: its sibling grep_dedup_hint is advisory and saves nothing directly, whereas this is a real rewrite with real bytes removed. Filing it under the advisory bucket would silently add non-hint savings to hint_stats.ts's savedBytes (which reads by_source[SOURCE_HINT] wholesale) and overstate the hint ledger's net benefit.
+  "grep:fold": SOURCE_CONTENT,
+  // Withholding of already-served stretches from a completed Read (hooks_read_post.ts elideAlreadyServedLines). SOURCE_CONTENT, not SOURCE_HINT, for the same reason as grep:fold above: its siblings read_count_deny and read_served_deny are decisions about whether a read happens at all, whereas this is a rewrite of a result that did happen, with real bytes removed from it. Filing it under the advisory bucket would add non-hint savings to hint_stats.ts's savedBytes, which reads by_source[SOURCE_HINT] wholesale.
+  "read:served_elide": SOURCE_CONTENT,
+  // Same bucket and same reasoning as read:served_elide directly above: a rewrite of a Read that did happen, with real bytes removed, not an advisory about whether to read at all.
+  "read:body_fold": SOURCE_CONTENT,
+  // Same bucket and same reasoning as read:body_fold directly above: a coarser sibling rewrite of a large untargeted markdown Read (hooks_read_post.ts foldMarkdownOutline) that replaces the body with a heading tree plus preamble, with real bytes removed, not an advisory about whether to read at all.
+  "read:markdown_outline": SOURCE_CONTENT,
+  // Same bucket and same reasoning as read:markdown_outline directly above, on source instead of prose: the structural-skeleton replacement of a large untargeted source Read (hooks_read_post.ts foldSourceSkeleton), with real bytes removed, not an advisory about whether to read at all.
+  "read:source_skeleton": SOURCE_CONTENT,
+  content_retrieve: SOURCE_CONTENT,
+  handoff_create: SOURCE_CONTENT,
+  handoff_resolve: SOURCE_CONTENT
+};
+var KIND_PREFIX_TO_SOURCE = [
+  ["bash_compress:", SOURCE_BASH],
+  ["webfetch:", SOURCE_WEB],
+  ["gdrive:", SOURCE_WEB],
+  ["mcp:", SOURCE_MCP],
+  ["skill_body:", SOURCE_SKILL],
+  ["skill_compact:", SOURCE_SKILL],
+  ["bashoutput:", SOURCE_BASH],
+  ["taskoutput:", SOURCE_CONTENT],
+  // Hook wall-clock timing (relay.ts's relayInProcess), one row per invocation, always 0 bytes/0 tokens: it measures token-goat's own overhead, not a saving. See hook_latency.ts's hookLatencyBreakdown() for the dedicated read path and pruneHookStats() below for its own (shorter) retention.
+  ["hook:", SOURCE_OTHER],
+  // See recordStaleServed (read_commands.ts).
+  ["stale_served:", SOURCE_OTHER],
+  // See recordAnswer (answer_router.ts).
+  ["answer:", SOURCE_OTHER]
+];
+var ANSWER_ROUTES = ["symbol", "callers", "impact", "test-for", "exports", "imports", "deps", "brief", "refused"];
+var COMMAND_KINDS = {
+  symbol: /* @__PURE__ */ new Set(["symbol_lookup"]),
+  // runAnswer's routes and refusals; savings stay on the delegate's own kind.
+  answer: new Set(ANSWER_ROUTES.map((r) => `answer:${r}`)),
+  read: /* @__PURE__ */ new Set(["read_replacement"]),
+  section: /* @__PURE__ */ new Set(["section_replacement", "section_read"]),
+  semantic: /* @__PURE__ */ new Set(["semantic_search"]),
+  outline: /* @__PURE__ */ new Set(["outline"]),
+  exports: /* @__PURE__ */ new Set(["exports"]),
+  imports: /* @__PURE__ */ new Set(["imports"]),
+  skeleton: /* @__PURE__ */ new Set(["stub_view"]),
+  refs: /* @__PURE__ */ new Set(["symbol_read"]),
+  map: /* @__PURE__ */ new Set(["map_lookup"]),
+  changed: /* @__PURE__ */ new Set(["changed_lookup"]),
+  "dep-docs": /* @__PURE__ */ new Set(["dep_docs"]),
+  "csv-query": /* @__PURE__ */ new Set(["csv_query"]),
+  "csv-profile": /* @__PURE__ */ new Set(["csv_profile"]),
+  "pdf-extract": /* @__PURE__ */ new Set(["pdf_extract"]),
+  "pdf-locate": /* @__PURE__ */ new Set(["pdf_locate"]),
+  "pdf-outline": /* @__PURE__ */ new Set(["pdf_outline"]),
+  "pdf-meta": /* @__PURE__ */ new Set(["pdf_meta"]),
+  "xlsx-sheets": /* @__PURE__ */ new Set(["xlsx_sheets"]),
+  "xlsx-head": /* @__PURE__ */ new Set(["xlsx_head"]),
+  "xlsx-range": /* @__PURE__ */ new Set(["xlsx_range"]),
+  "xlsx-query": /* @__PURE__ */ new Set(["xlsx_query"]),
+  "xlsx-columns": /* @__PURE__ */ new Set(["xlsx_columns"]),
+  "pptx-outline": /* @__PURE__ */ new Set(["pptx_outline"]),
+  "pptx-slide": /* @__PURE__ */ new Set(["pptx_slide"]),
+  "pptx-notes": /* @__PURE__ */ new Set(["pptx_notes"]),
+  "pptx-text": /* @__PURE__ */ new Set(["pptx_text"]),
+  "docx-outline": /* @__PURE__ */ new Set(["docx_outline"]),
+  "docx-tables": /* @__PURE__ */ new Set(["docx_tables"]),
+  "docx-text": /* @__PURE__ */ new Set(["docx_text"]),
+  "transcript-outline": /* @__PURE__ */ new Set(["transcript_outline"]),
+  transcript: /* @__PURE__ */ new Set(["transcript"]),
+  "video-chapters": /* @__PURE__ */ new Set(["video_chapters"]),
+  "image-meta": /* @__PURE__ */ new Set(["image_meta"]),
+  "image-text": /* @__PURE__ */ new Set(["image_text"]),
+  "coverage-report-gaps": /* @__PURE__ */ new Set(["coverage_report_gaps"]),
+  "json-query": /* @__PURE__ */ new Set(["json_query"]),
+  "json-outline": /* @__PURE__ */ new Set(["json_outline"]),
+  "yaml-query": /* @__PURE__ */ new Set(["yaml_query"]),
+  "yaml-outline": /* @__PURE__ */ new Set(["yaml_outline"]),
+  "xml-query": /* @__PURE__ */ new Set(["xml_query"]),
+  "xml-outline": /* @__PURE__ */ new Set(["xml_outline"]),
+  "html-query": /* @__PURE__ */ new Set(["html_query"]),
+  "html-outline": /* @__PURE__ */ new Set(["html_outline"]),
+  "openapi-op": /* @__PURE__ */ new Set(["openapi_op"]),
+  "openapi-outline": /* @__PURE__ */ new Set(["openapi_outline"]),
+  "zip-list": /* @__PURE__ */ new Set(["zip_list"]),
+  "zip-read": /* @__PURE__ */ new Set(["zip_read"]),
+  "sqlite-query": /* @__PURE__ */ new Set(["sqlite_query"]),
+  "sqlite-schema": /* @__PURE__ */ new Set(["sqlite_schema"]),
+  "sqlite-tables": /* @__PURE__ */ new Set(["sqlite_tables"]),
+  conflicts: /* @__PURE__ */ new Set(["conflicts"]),
+  brief: /* @__PURE__ */ new Set(["brief_view"]),
+  "session-outline": /* @__PURE__ */ new Set(["session_outline"]),
+  "session-slice": /* @__PURE__ */ new Set(["session_slice"]),
+  "gdrive-sections": /* @__PURE__ */ new Set(["gdrive_sections"]),
+  "pr-slice": /* @__PURE__ */ new Set(["pr_slice"]),
+  "compact-doc": /* @__PURE__ */ new Set(["compact_doc"]),
+  "note-add": /* @__PURE__ */ new Set(["note_write"]),
+  "note-get": /* @__PURE__ */ new Set(["note_read"]),
+  "note-list": /* @__PURE__ */ new Set(["note_list"]),
+  "compress-text": /* @__PURE__ */ new Set(["content_compress"]),
+  retrieve: /* @__PURE__ */ new Set(["content_retrieve"]),
+  "handoff-create": /* @__PURE__ */ new Set(["handoff_create"]),
+  "handoff-resolve": /* @__PURE__ */ new Set(["handoff_resolve"]),
+  npm: /* @__PURE__ */ new Set([
+    "bash_compress:npm_install",
+    "bash_compress:npm_ci",
+    "bash_compress:npm_audit",
+    "bash_compress:npm_ls",
+    "bash_compress:npm_outdated",
+    "bash_compress:npx"
+  ])
+};
+var OVERHEAD_SUFFIX = "_overhead";
+function kindToSource(kind) {
+  const src = KIND_TO_SOURCE[kind];
+  if (src !== void 0) return src;
+  if (kind.endsWith(OVERHEAD_SUFFIX)) {
+    const base = kind.slice(0, -OVERHEAD_SUFFIX.length);
+    const baseSrc = KIND_TO_SOURCE[base];
+    if (baseSrc !== void 0) return baseSrc;
+  }
+  for (const [prefix, prefixSrc] of KIND_PREFIX_TO_SOURCE) {
+    if (kind.startsWith(prefix)) return prefixSrc;
+  }
+  return SOURCE_OTHER;
+}
+function toLocalDateKey(d) {
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function formatLocalTimestamp(d) {
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  const seconds = String(d.getSeconds()).padStart(2, "0");
+  return `${toLocalDateKey(d)}T${hours}:${minutes}:${seconds}`;
+}
+function zeroBucket() {
+  return { events: 0, bytes_saved: 0, tokens_saved: 0 };
+}
+function incBucket(bucket, bytesSaved, tokensSaved) {
+  bucket.events += 1;
+  bucket.bytes_saved += bytesSaved;
+  bucket.tokens_saved += tokensSaved;
+}
+var GLOBAL_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS stats (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  ts INTEGER NOT NULL,
+  kind TEXT NOT NULL,
+  tokens_saved INTEGER NOT NULL DEFAULT 0,
+  bytes_saved INTEGER NOT NULL DEFAULT 0,
+  detail TEXT,
+  harness TEXT,
+  traceparent TEXT,
+  tg_version TEXT,
+  duration_ms INTEGER
+);
+CREATE INDEX IF NOT EXISTS idx_stats_ts ON stats(ts);
+CREATE INDEX IF NOT EXISTS idx_stats_kind ON stats(kind);
+-- Day-granularity rollup of stats rows older than STATS_RETENTION_DAYS -- see
+-- rollupAndPruneStats's doc comment for why raw rows are pruned instead of kept forever, and
+-- summarize()'s rollup merge for how a --window-days report spanning pruned days still gets a
+-- correct total. Deliberately day+kind+harness+tg_version, not day+kind alone: those are exactly
+-- the dimensions summarize() breaks totals out by, and collapsing any of them here would make an
+-- old --window-days report under-report a breakdown a recent one still shows in full.
+CREATE TABLE IF NOT EXISTS stats_daily_rollup (
+  day TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  harness TEXT NOT NULL DEFAULT '',
+  tg_version TEXT NOT NULL DEFAULT '',
+  events INTEGER NOT NULL DEFAULT 0,
+  bytes_saved INTEGER NOT NULL DEFAULT 0,
+  tokens_saved INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (day, kind, harness, tg_version)
+);
+CREATE INDEX IF NOT EXISTS idx_stats_daily_rollup_day ON stats_daily_rollup(day);
+-- Single-row (id=1, same pattern as embedding_provenance in db.ts) throttle so the rollup+prune
+-- pass -- an aggregate scan over the whole stats table -- runs at most once per
+-- STATS_ROLLUP_INTERVAL_MS regardless of how often recordStat() itself is called (many times a
+-- minute during active use).
+CREATE TABLE IF NOT EXISTS stats_maintenance (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  last_rollup_ts INTEGER NOT NULL DEFAULT 0
+);
+CREATE TABLE IF NOT EXISTS unmapped_tools (
+  harness TEXT NOT NULL,
+  tool_name TEXT NOT NULL,
+  event_name TEXT NOT NULL,
+  near_miss TEXT,
+  first_seen INTEGER NOT NULL,
+  last_seen INTEGER NOT NULL,
+  hits INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (harness, tool_name, event_name)
+);
+CREATE TABLE IF NOT EXISTS stats_flags (
+  name TEXT PRIMARY KEY,
+  set_ts INTEGER NOT NULL
+);
+-- One row per semantic query's dense outcome, for semantic --distances. Deliberately no query text: only distances and a project hash, so the ledger cannot leak what was asked. Pruned with the stats table's retention (pruneSemanticQueries).
+CREATE TABLE IF NOT EXISTS semantic_queries (
+  ts INTEGER NOT NULL,
+  project_hash TEXT,
+  closest_distance REAL,
+  floor_rejected_min REAL,
+  weak INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_semantic_queries_ts ON semantic_queries(ts);
+`;
+var _globalSchemaApplied = /* @__PURE__ */ new Set();
+registerReset(() => _globalSchemaApplied.clear(), { perRequest: true });
+function migrateGlobalSchema(db) {
+  try {
+    db.exec("ALTER TABLE stats ADD COLUMN harness TEXT");
+  } catch (err) {
+    if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
+  }
+  try {
+    db.exec("ALTER TABLE stats ADD COLUMN traceparent TEXT");
+  } catch (err) {
+    if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
+  }
+  try {
+    db.exec("ALTER TABLE stats ADD COLUMN tg_version TEXT");
+  } catch (err) {
+    if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
+  }
+  try {
+    db.exec("ALTER TABLE stats ADD COLUMN duration_ms INTEGER");
+  } catch (err) {
+    if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
+  }
+}
+var TEST_ISOLATION_LEAK_WINDOW_START_TS = 1780406895;
+var TEST_ISOLATION_LEAK_WINDOW_END_TS = 1782119331;
+function pruneTestIsolationLeakRows(db) {
+  try {
+    db.prepare(
+      `DELETE FROM stats WHERE tg_version IS NULL AND ts BETWEEN ? AND ? AND (detail LIKE '%pytest-of-%' OR detail LIKE '%/fake/%')`
+    ).run(TEST_ISOLATION_LEAK_WINDOW_START_TS, TEST_ISOLATION_LEAK_WINDOW_END_TS);
+  } catch {
+  }
+}
+function dropRetiredPythonTables(db) {
+  try {
+    db.prepare("DROP TABLE IF EXISTS grep_patterns").run();
+    db.prepare("DROP TABLE IF EXISTS miss_patterns").run();
+    db.prepare("DROP TABLE IF EXISTS wal_bloat").run();
+  } catch {
+  }
+}
+var _harnessColumnByDb = /* @__PURE__ */ new WeakMap();
+function statsHasHarnessColumn(db) {
+  const cached = _harnessColumnByDb.get(db);
+  if (cached !== void 0) return cached;
+  let present;
+  try {
+    present = db.prepare("PRAGMA table_info(stats)").all().some(
+      (c) => c.name === "harness"
+    );
+  } catch {
+    present = false;
+  }
+  _harnessColumnByDb.set(db, present);
+  return present;
+}
+var _traceparentColumnByDb = /* @__PURE__ */ new WeakMap();
+function statsHasTraceparentColumn(db) {
+  const cached = _traceparentColumnByDb.get(db);
+  if (cached !== void 0) return cached;
+  let present;
+  try {
+    present = db.prepare("PRAGMA table_info(stats)").all().some(
+      (c) => c.name === "traceparent"
+    );
+  } catch {
+    present = false;
+  }
+  _traceparentColumnByDb.set(db, present);
+  return present;
+}
+var _versionColumnByDb = /* @__PURE__ */ new WeakMap();
+function statsHasVersionColumn(db) {
+  const cached = _versionColumnByDb.get(db);
+  if (cached !== void 0) return cached;
+  let present;
+  try {
+    present = db.prepare("PRAGMA table_info(stats)").all().some(
+      (c) => c.name === "tg_version"
+    );
+  } catch {
+    present = false;
+  }
+  _versionColumnByDb.set(db, present);
+  return present;
+}
+var _durationColumnByDb = /* @__PURE__ */ new WeakMap();
+function statsHasDurationColumn(db) {
+  const cached = _durationColumnByDb.get(db);
+  if (cached !== void 0) return cached;
+  let present;
+  try {
+    present = db.prepare("PRAGMA table_info(stats)").all().some(
+      (c) => c.name === "duration_ms"
+    );
+  } catch {
+    present = false;
+  }
+  _durationColumnByDb.set(db, present);
+  return present;
+}
+function getGlobalDb(homeDir) {
+  const basePath = homeDir ? dataDirForHome(homeDir) : dataDir();
+  const dbPath = path.join(basePath, "global.db");
+  const db = getDb(dbPath);
+  if (!_globalSchemaApplied.has(dbPath) && !isReadOnlyDb(dbPath)) {
+    db.exec(GLOBAL_SCHEMA_SQL);
+    migrateGlobalSchema(db);
+    _globalSchemaApplied.add(dbPath);
+  }
+  return db;
+}
+var STATS_RETENTION_DAYS = 180;
+var UNMAPPED_TOOL_RETENTION_DAYS = 30;
+var STATS_ROLLUP_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+function rollupAndPruneStats(db, retentionDays = STATS_RETENTION_DAYS) {
+  try {
+    const cutoffTs = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
+    const run = db.transaction((cutoff) => {
+      db.prepare(
+        `INSERT INTO stats_daily_rollup (day, kind, harness, tg_version, events, bytes_saved, tokens_saved)
+         SELECT strftime('%Y-%m-%d', ts, 'unixepoch', 'localtime') AS day,
+                kind,
+                COALESCE(harness, '') AS harness,
+                COALESCE(tg_version, '') AS tg_version,
+                COUNT(*), SUM(bytes_saved), SUM(tokens_saved)
+         FROM stats
+         WHERE ts < ?
+         GROUP BY day, kind, harness, tg_version
+         ON CONFLICT(day, kind, harness, tg_version) DO UPDATE SET
+           events = events + excluded.events,
+           bytes_saved = bytes_saved + excluded.bytes_saved,
+           tokens_saved = tokens_saved + excluded.tokens_saved`
+      ).run(cutoff);
+      db.prepare(`DELETE FROM stats WHERE ts < ?`).run(cutoff);
+      try {
+        const unmappedCutoff = Math.floor(Date.now() / 1e3) - UNMAPPED_TOOL_RETENTION_DAYS * 86400;
+        db.prepare(`DELETE FROM unmapped_tools WHERE last_seen < ?`).run(unmappedCutoff);
+      } catch {
+      }
+    });
+    run(cutoffTs);
+  } catch {
+  }
+}
+function pruneHintEmissions(db, retentionDays = STATS_RETENTION_DAYS) {
+  try {
+    const cutoffMs = Date.now() - retentionDays * 86400 * 1e3;
+    db.prepare(`DELETE FROM hint_emissions WHERE emitted_at < ?`).run(cutoffMs);
+  } catch {
+  }
+}
+function pruneSemanticQueries(db, retentionDays = STATS_RETENTION_DAYS) {
+  try {
+    db.prepare(`DELETE FROM semantic_queries WHERE ts < ?`).run(Math.floor(Date.now() / 1e3) - retentionDays * 86400);
+  } catch {
+  }
+}
+var HOOK_STATS_RETENTION_DAYS = 7;
+var HOOK_PROBE_ENV = "TOKEN_GOAT_HOOK_PROBE";
+function pruneHookStats(db, retentionDays = HOOK_STATS_RETENTION_DAYS) {
+  try {
+    const cutoffTs = Math.floor(Date.now() / 1e3) - retentionDays * 86400;
+    db.prepare(`DELETE FROM stats WHERE kind LIKE 'hook:%' AND ts < ?`).run(cutoffTs);
+  } catch {
+  }
+}
+function maybeRunStatsMaintenance(db) {
+  try {
+    const now = Date.now();
+    const row = db.prepare(`SELECT last_rollup_ts FROM stats_maintenance WHERE id = 1`).get();
+    const last = row?.last_rollup_ts ?? 0;
+    if (now - last < STATS_ROLLUP_INTERVAL_MS) return;
+    db.prepare(
+      `INSERT INTO stats_maintenance (id, last_rollup_ts) VALUES (1, ?)
+       ON CONFLICT(id) DO UPDATE SET last_rollup_ts = excluded.last_rollup_ts`
+    ).run(now);
+    pruneHookStats(db);
+    rollupAndPruneStats(db);
+    pruneHintEmissions(db);
+    pruneSemanticQueries(db);
+    pruneTestIsolationLeakRows(db);
+    dropRetiredPythonTables(db);
+  } catch {
+  }
+}
+function noStatsMessage(windowDays, homeDir) {
+  if (windowDays <= 0) return "No stats recorded yet.";
+  const db = getGlobalDb(homeDir);
+  let total = db.prepare("SELECT COUNT(*) as c FROM stats").get().c;
+  try {
+    const rollupTable = db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'stats_daily_rollup'`).get();
+    if (rollupTable !== void 0) {
+      const rolledUp = db.prepare("SELECT COALESCE(SUM(events), 0) as c FROM stats_daily_rollup").get().c;
+      total += rolledUp;
+    }
+  } catch {
+  }
+  if (total === 0) return "No stats recorded yet.";
+  return `No stats in the last ${countNoun(windowDays, "day")} (${total} recorded outside this window; use --window-days 0 for all time).`;
+}
+var STATS_WRITE_FAILURE_LOG_MIN_INTERVAL_MS = 60 * 1e3;
+function statsWriteFailureMarkerPath(dir) {
+  return path.join(dir, "stats-write-failed.marker");
+}
+function statsWriteFailureLogPath(dir) {
+  return path.join(dir, "stats-write-failed.log");
+}
+function recordStatWriteFailure(kind, err, dir = dataDir()) {
+  try {
+    const markerPath = statsWriteFailureMarkerPath(dir);
+    try {
+      if (Date.now() - fs.statSync(markerPath).mtimeMs < STATS_WRITE_FAILURE_LOG_MIN_INTERVAL_MS) return;
+    } catch {
+    }
+    ensureDirSync(dir);
+    fs.writeFileSync(markerPath, "");
+    const line = `${(/* @__PURE__ */ new Date()).toISOString()} recordStat write failed for kind=${kind}: ${extractErrorMessage(err)}`;
+    fs.appendFileSync(statsWriteFailureLogPath(dir), displaySafeText(line.replace(/[\n\r]+$/, "")) + "\n");
+  } catch {
+  }
+}
+var STATS_WRITE_BUSY_TIMEOUT_MS = 200;
+function withTelemetryWriteDb(write) {
+  getGlobalDb();
+  const dbPath = path.join(dataDir(), "global.db");
+  if (isReadOnlyDb(dbPath)) return;
+  const db = new Database(dbPath, { timeout: STATS_WRITE_BUSY_TIMEOUT_MS });
+  try {
+    if (String(db.pragma("journal_mode", { simple: true })).toLowerCase() === "wal") db.pragma("synchronous = NORMAL");
+    write(db);
+  } finally {
+    try {
+      db.close();
+    } catch {
+    }
+  }
+}
+function recordStat(kind, bytesSaved = 0, tokensSaved = 0, _testDb, detail, traceparent, durationMs) {
+  const write = (db) => {
+    const ts = Math.floor(Date.now() / 1e3);
+    const tp = traceparent ?? process.env["TRACEPARENT"] ?? process.env["traceparent"] ?? null;
+    const cols = ["ts", "kind", "bytes_saved", "tokens_saved", "detail"];
+    const vals = [ts, kind, bytesSaved, tokensSaved, detail ?? null];
+    if (statsHasHarnessColumn(db)) {
+      cols.push("harness");
+      vals.push(getHarnessName());
+    }
+    if (statsHasTraceparentColumn(db)) {
+      cols.push("traceparent");
+      vals.push(tp);
+    }
+    if (statsHasVersionColumn(db)) {
+      cols.push("tg_version");
+      vals.push(VERSION);
+    }
+    if (durationMs !== void 0 && statsHasDurationColumn(db)) {
+      cols.push("duration_ms");
+      vals.push(Math.round(durationMs));
+    }
+    db.prepare(
+      `INSERT INTO stats (${cols.join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`
+    ).run(...vals);
+    maybeRunStatsMaintenance(db);
+  };
+  try {
+    if (_testDb) write(_testDb);
+    else withTelemetryWriteDb(write);
+  } catch (e) {
+    recordStatWriteFailure(kind, e);
+  }
+}
+var MAX_TOOL_NAME_CHARS = 200;
+function recordUnmappedTool(toolName, eventName, nearMiss, _testDb) {
+  try {
+    if (!toolName) return;
+    const db = _testDb ?? getGlobalDb();
+    const now = Math.floor(Date.now() / 1e3);
+    db.prepare(
+      `INSERT INTO unmapped_tools (harness, tool_name, event_name, near_miss, first_seen, last_seen, hits)
+       VALUES (?, ?, ?, ?, ?, ?, 1)
+       ON CONFLICT(harness, tool_name, event_name) DO UPDATE SET
+         hits = hits + 1,
+         last_seen = excluded.last_seen,
+         near_miss = excluded.near_miss`
+    ).run(getHarnessName(), toolName.slice(0, MAX_TOOL_NAME_CHARS), eventName, nearMiss, now, now);
+  } catch {
+  }
+}
+function readUnmappedTools(dbPath, homeDir) {
+  try {
+    const db = dbPath ? getDb(dbPath) : getGlobalDb(homeDir);
+    return db.prepare(
+      "SELECT harness, tool_name, event_name, near_miss, hits, last_seen FROM unmapped_tools ORDER BY hits DESC, tool_name ASC"
+    ).all();
+  } catch {
+    return [];
+  }
+}
+function pruneStalePatternCoveredUnmappedTools(db, patterns) {
+  if (patterns.length === 0) return;
+  const regexes = patterns.map((p) => new RegExp(p));
+  try {
+    const rows = db.prepare("SELECT DISTINCT tool_name FROM unmapped_tools").all();
+    const stale = rows.filter((r) => regexes.some((re) => re.test(r.tool_name)));
+    if (stale.length === 0) return;
+    const del = db.prepare("DELETE FROM unmapped_tools WHERE tool_name = ?");
+    for (const r of stale) del.run(r.tool_name);
+  } catch {
+  }
+}
+var FIRST_RECEIPT_FLAG = "first_receipt_shown";
+function allTimeTokensSaved(db) {
+  const kinds = [...COUNT_ONLY_KINDS];
+  const notCount = kinds.length > 0 ? `WHERE kind NOT IN (${kinds.map(() => "?").join(", ")})` : "";
+  const raw = db.prepare(`SELECT COALESCE(SUM(tokens_saved), 0) AS t FROM stats ${notCount}`).get(...kinds).t;
+  const rolled = db.prepare(`SELECT COALESCE(SUM(tokens_saved), 0) AS t FROM stats_daily_rollup ${notCount}`).get(...kinds).t;
+  return raw + rolled;
+}
+function claimFirstSavingsReceipt(testDb, homeDir, now = Date.now()) {
+  try {
+    const db = testDb ?? getGlobalDb(homeDir);
+    if (db.prepare("SELECT 1 FROM stats_flags WHERE name = ?").get(FIRST_RECEIPT_FLAG) !== void 0) return null;
+    const total = allTimeTokensSaved(db);
+    if (total <= 0) return null;
+    const claimed = db.prepare("INSERT OR IGNORE INTO stats_flags (name, set_ts) VALUES (?, ?)").run(FIRST_RECEIPT_FLAG, Math.floor(now / 1e3));
+    return claimed.changes === 1 ? total : null;
+  } catch {
+    return null;
+  }
+}
+function firstReceiptShownAt(testDb, homeDir) {
+  try {
+    const db = testDb ?? getGlobalDb(homeDir);
+    const row = db.prepare("SELECT set_ts FROM stats_flags WHERE name = ?").get(FIRST_RECEIPT_FLAG);
+    return row === void 0 ? null : row.set_ts * 1e3;
+  } catch {
+    return null;
+  }
+}
+function summarize(windowDays = 30, testDb, homeDir) {
+  const t0 = Date.now();
+  const sinceTs = windowDays > 0 ? Math.floor((Date.now() - windowDays * 24 * 60 * 60 * 1e3) / 1e3) : null;
+  const byKind = {};
+  const byDay = {};
+  const byHarness = {};
+  const byPricingVersion = {};
+  let totalEvents = 0;
+  let totalBytes = 0;
+  let totalTokens = 0;
+  const db = testDb ?? getGlobalDb(homeDir);
+  const hasHarness = statsHasHarnessColumn(db);
+  const hasVersion = statsHasVersionColumn(db);
+  const cols = [
+    "ts",
+    "kind",
+    "bytes_saved",
+    "tokens_saved",
+    ...hasHarness ? ["harness"] : [],
+    ...hasVersion ? ["tg_version"] : []
+  ].join(", ");
+  const query = sinceTs !== null ? `SELECT ${cols} FROM stats WHERE ts >= ? ORDER BY ts DESC` : `SELECT ${cols} FROM stats ORDER BY ts DESC`;
+  const stmt = db.prepare(query);
+  const rows = sinceTs !== null ? stmt.all(sinceTs) : stmt.all();
+  const tsToDateCache = {};
+  const counts = {};
+  for (const row of rows) {
+    const bytesSaved = row.bytes_saved ?? 0;
+    const recorded = row.tokens_saved ?? 0;
+    const kind = row.kind;
+    const isCount = COUNT_ONLY_KINDS.has(kind);
+    if (isCount) counts[kind] = (counts[kind] ?? 0) + recorded;
+    const tokensSaved = isCount ? 0 : recorded;
+    const tsRaw = row.ts;
+    if (tsRaw === void 0) continue;
+    const ts = tsRaw;
+    totalEvents += 1;
+    totalBytes += bytesSaved;
+    totalTokens += tokensSaved;
+    if (!byKind[kind]) {
+      byKind[kind] = zeroBucket();
+    }
+    incBucket(byKind[kind], bytesSaved, tokensSaved);
+    const dateKey = tsToDateCache[ts] || toLocalDateKey(new Date(ts * 1e3));
+    tsToDateCache[ts] = dateKey;
+    if (!byDay[dateKey]) {
+      byDay[dateKey] = zeroBucket();
+    }
+    incBucket(byDay[dateKey], bytesSaved, tokensSaved);
+    const harness = row.harness || HARNESS_UNRECORDED;
+    if (!byHarness[harness]) {
+      byHarness[harness] = zeroBucket();
+    }
+    incBucket(byHarness[harness], bytesSaved, tokensSaved);
+    const pricingVersion = row.tg_version || PRICING_VERSION_UNRECORDED;
+    if (!byPricingVersion[pricingVersion]) {
+      byPricingVersion[pricingVersion] = zeroBucket();
+    }
+    incBucket(byPricingVersion[pricingVersion], bytesSaved, tokensSaved);
+  }
+  try {
+    const rollupTable = db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'stats_daily_rollup'`).get();
+    if (rollupTable !== void 0) {
+      const sinceDayKey = sinceTs !== null ? toLocalDateKey(new Date(sinceTs * 1e3)) : null;
+      const rollupRows = sinceDayKey !== null ? db.prepare(`SELECT day, kind, harness, tg_version, events, bytes_saved, tokens_saved FROM stats_daily_rollup WHERE day >= ?`).all(sinceDayKey) : db.prepare(`SELECT day, kind, harness, tg_version, events, bytes_saved, tokens_saved FROM stats_daily_rollup`).all();
+      const addBucket = (bucket, events, bytesSaved, tokensSaved) => {
+        bucket.events += events;
+        bucket.bytes_saved += bytesSaved;
+        bucket.tokens_saved += tokensSaved;
+      };
+      for (const r of rollupRows) {
+        const isCount = COUNT_ONLY_KINDS.has(r.kind);
+        if (isCount) counts[r.kind] = (counts[r.kind] ?? 0) + r.tokens_saved;
+        const tokensSaved = isCount ? 0 : r.tokens_saved;
+        const bytesSaved = r.bytes_saved;
+        totalEvents += r.events;
+        totalBytes += bytesSaved;
+        totalTokens += tokensSaved;
+        if (!byKind[r.kind]) byKind[r.kind] = zeroBucket();
+        addBucket(byKind[r.kind], r.events, bytesSaved, tokensSaved);
+        if (!byDay[r.day]) byDay[r.day] = zeroBucket();
+        addBucket(byDay[r.day], r.events, bytesSaved, tokensSaved);
+        const harness = r.harness || HARNESS_UNRECORDED;
+        if (!byHarness[harness]) byHarness[harness] = zeroBucket();
+        addBucket(byHarness[harness], r.events, bytesSaved, tokensSaved);
+        const pricingVersion = r.tg_version || PRICING_VERSION_UNRECORDED;
+        if (!byPricingVersion[pricingVersion]) byPricingVersion[pricingVersion] = zeroBucket();
+        addBucket(byPricingVersion[pricingVersion], r.events, bytesSaved, tokensSaved);
+      }
+    }
+  } catch {
+  }
+  const bySourceDict = {};
+  for (const [kind, bucket] of Object.entries(byKind)) {
+    const source = kindToSource(kind);
+    if (!bySourceDict[source]) {
+      bySourceDict[source] = zeroBucket();
+    }
+    bySourceDict[source].events += bucket.events;
+    bySourceDict[source].bytes_saved += bucket.bytes_saved;
+    bySourceDict[source].tokens_saved += bucket.tokens_saved;
+  }
+  const byCommandDict = {};
+  for (const [cmd, kinds] of Object.entries(COMMAND_KINDS)) {
+    byCommandDict[cmd] = zeroBucket();
+    for (const kind of kinds) {
+      if (byKind[kind]) {
+        byCommandDict[cmd].events += byKind[kind].events;
+        byCommandDict[cmd].bytes_saved += byKind[kind].bytes_saved;
+        byCommandDict[cmd].tokens_saved += byKind[kind].tokens_saved;
+      }
+    }
+  }
+  const byDayList = Object.entries(byDay).map(([date, bucket]) => ({ ...bucket, date })).sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+  const byProjectList = [];
+  const t1 = Date.now();
+  if (t1 - t0 > 1e3) {
+    console.warn(`summarize took ${t1 - t0}ms (window=${windowDays}d, total=${totalEvents} rows)`);
+  }
+  return {
+    total_events: totalEvents,
+    total_bytes_saved: totalBytes,
+    total_tokens_saved: totalTokens,
+    by_kind: byKind,
+    by_day: byDayList,
+    by_project: byProjectList,
+    by_source: bySourceDict,
+    by_harness: byHarness,
+    by_pricing_version: byPricingVersion,
+    counts,
+    by_command: Object.entries(byCommandDict).map(([command, bucket]) => ({ ...bucket, command })).filter((r) => r.events > 0),
+    window_days: windowDays
+  };
+}
+
+export {
+  BYTES_PER_TOKEN,
+  guardDivisor,
+  classifyContent,
+  PRICING_VERSION_UNRECORDED,
+  hasMixedPricingEras,
+  SOURCE_HINT,
+  savedTokensFromBytes,
+  formatLocalTimestamp,
+  statsHasHarnessColumn,
+  statsHasDurationColumn,
+  getGlobalDb,
+  HOOK_STATS_RETENTION_DAYS,
+  HOOK_PROBE_ENV,
+  noStatsMessage,
+  withTelemetryWriteDb,
+  recordStat,
+  recordUnmappedTool,
+  readUnmappedTools,
+  pruneStalePatternCoveredUnmappedTools,
+  claimFirstSavingsReceipt,
+  firstReceiptShownAt,
+  summarize
+};