ccgauge 1.0.4 → 1.1.0

package/dist/report/index.mjs

@@ -1521,6 +1521,19 @@ function formatPct(n, frac = 1) {
   if (!Number.isFinite(n)) return "0%";
   return `${(n * 100).toFixed(frac)}%`;
 }
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const sec = Math.floor(ms / 1e3);
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) {
+    const s = sec % 60;
+    return s ? `${min}m ${s}s` : `${min}m`;
+  }
+  const hr = Math.floor(min / 60);
+  const m = min % 60;
+  return m ? `${hr}h ${m}m` : `${hr}h`;
+}
 function projectNameFromCwd(cwd) {
   if (!cwd) return "(unknown)";
   const trimmed = cwd.replace(/[/\\]+$/, "");
@@ -1528,6 +1541,69 @@ function projectNameFromCwd(cwd) {
   return parts[parts.length - 1] || cwd;
 }
 
+// lib/project-label.ts
+import { readFileSync, statSync } from "node:fs";
+import { basename } from "node:path";
+var cache = /* @__PURE__ */ new Map();
+var GITDIR_PATTERN = /^(.+?)[/\\]\.git[/\\]worktrees[/\\]([^/\\]+)[/\\]?$/;
+var CWD_WORKTREE_PATTERN = /^(.+?)[/\\](?:\.git|\.claude)[/\\]worktrees[/\\]([^/\\]+)(?:[/\\].*)?$/;
+function resolveRaw(cwd) {
+  const fallbackName = projectNameFromCwd(cwd);
+  if (!cwd) {
+    return { label: fallbackName, isWorktree: false, mainName: fallbackName, worktreeName: "", canonicalCwd: cwd };
+  }
+  const pathMatch = CWD_WORKTREE_PATTERN.exec(cwd);
+  if (pathMatch) {
+    const mainRepoPath = pathMatch[1];
+    const worktreeName = pathMatch[2];
+    const mainName = basename(mainRepoPath) || mainRepoPath;
+    return {
+      label: `${mainName} (${worktreeName})`,
+      isWorktree: true,
+      mainName,
+      worktreeName,
+      canonicalCwd: mainRepoPath
+    };
+  }
+  try {
+    const gitPath = `${cwd}/.git`;
+    const s = statSync(gitPath);
+    if (!s.isFile()) {
+      return { label: fallbackName, isWorktree: false, mainName: fallbackName, worktreeName: "", canonicalCwd: cwd };
+    }
+    const text = readFileSync(gitPath, "utf8").trim();
+    const firstLine = text.split(/\r?\n/, 1)[0] ?? "";
+    const m = /^gitdir:\s*(.+)$/.exec(firstLine);
+    if (!m) {
+      return { label: fallbackName, isWorktree: false, mainName: fallbackName, worktreeName: "", canonicalCwd: cwd };
+    }
+    const gitdir = m[1].trim();
+    const wt = GITDIR_PATTERN.exec(gitdir);
+    if (!wt) {
+      return { label: fallbackName, isWorktree: false, mainName: fallbackName, worktreeName: "", canonicalCwd: cwd };
+    }
+    const mainRepoPath = wt[1];
+    const worktreeName = wt[2];
+    const mainName = basename(mainRepoPath) || mainRepoPath;
+    return {
+      label: `${mainName} (${worktreeName})`,
+      isWorktree: true,
+      mainName,
+      worktreeName,
+      canonicalCwd: mainRepoPath
+    };
+  } catch {
+    return { label: fallbackName, isWorktree: false, mainName: fallbackName, worktreeName: "", canonicalCwd: cwd };
+  }
+}
+function resolveProjectLabel(cwd) {
+  const cached = cache.get(cwd);
+  if (cached) return cached.label;
+  const r = resolveRaw(cwd);
+  cache.set(cwd, r);
+  return r.label;
+}
+
 // lib/aggregator/index.ts
 var GRANULARITIES = ["hour", "day", "week", "month"];
 function isGranularity(v) {
@@ -1719,6 +1795,12 @@ function aggregateBySession(records, userRecords, opts) {
         source: rec.source,
         cwd: rec.cwd,
         projectName: projectNameFromCwd(rec.cwd),
+        // Worktree-aware label so the sessions table shows the same
+        // identifier the usage table does for the same record (e.g.
+        // `ai-self-web (playwright)` instead of just `playwright`).
+        // `resolveProjectLabel` caches per-cwd, so this is one fs.stat
+        // per unique cwd across the whole aggregation.
+        projectLabel: resolveProjectLabel(rec.cwd),
         startTime: rec.timestamp,
         endTime: rec.timestamp,
         durationMs: 0,
@@ -1803,13 +1885,13 @@ function aggregateTotals(records, opts) {
 }
 
 // lib/range.ts
-var USAGE_RANGES = ["1d", "7d", "30d", "90d", "all"];
+var USAGE_RANGES = ["1d", "7d", "30d", "90d", "all", "custom"];
 function isUsageRange(v) {
   return typeof v === "string" && USAGE_RANGES.includes(v);
 }
 function rangeToDates(range) {
   const now = /* @__PURE__ */ new Date();
-  if (range === "all") return {};
+  if (range === "all" || range === "custom") return {};
   if (range === "1d") {
     const from2 = new Date(now.getFullYear(), now.getMonth(), now.getDate());
     return { from: from2 };
@@ -1825,6 +1907,771 @@ function rangeToDates(range) {
   return { from };
 }
 
+// lib/turns.ts
+var MAX_PARENT_WALK = 5e3;
+function buildTurnIndex(assistants, users, parentMap) {
+  const userTextMap = /* @__PURE__ */ new Map();
+  for (const u of users) {
+    if (u.isSynthetic) continue;
+    if (u.textPreview && u.textPreview.trim()) userTextMap.set(u.uuid, u.textPreview);
+  }
+  const result = /* @__PURE__ */ new Map();
+  const memo = /* @__PURE__ */ new Map();
+  function resolve(startUuid) {
+    const path5 = [];
+    let cur = startUuid;
+    let answer = null;
+    let steps = 0;
+    const seen = /* @__PURE__ */ new Set();
+    while (cur && steps++ < MAX_PARENT_WALK) {
+      if (seen.has(cur)) break;
+      seen.add(cur);
+      const m = memo.get(cur);
+      if (m) {
+        answer = m;
+        break;
+      }
+      path5.push(cur);
+      if (userTextMap.has(cur)) {
+        answer = cur;
+        break;
+      }
+      cur = parentMap[cur] ?? null;
+    }
+    if (!answer) answer = startUuid;
+    for (const id of path5) memo.set(id, answer);
+    return answer;
+  }
+  for (const a of assistants) {
+    result.set(a.uuid, resolve(a.uuid));
+  }
+  return result;
+}
+function summarizeTurns(records, users, parentMap) {
+  const turnIndex = buildTurnIndex(records, users, parentMap);
+  const out = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    const turnId = turnIndex.get(r.uuid) ?? r.uuid;
+    const existing = out.get(turnId);
+    if (!existing || r.timestamp < existing.firstTimestamp) {
+      out.set(turnId, {
+        turnId,
+        firstTimestamp: r.timestamp,
+        firstModel: r.model,
+        cwd: r.cwd,
+        sessionId: r.sessionId,
+        source: r.source
+      });
+    }
+  }
+  return out;
+}
+
+// lib/blocks/compute.ts
+var DEFAULT_BLOCK_WINDOW_MS = 5 * 60 * 60 * 1e3;
+function computeBlocks(records, windowMs = DEFAULT_BLOCK_WINDOW_MS) {
+  if (records.length === 0) return [];
+  const sorted = [...records].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  const blocks = [];
+  let current = null;
+  let blockStartMs = 0;
+  const now = Date.now();
+  for (const rec of sorted) {
+    const t = new Date(rec.timestamp).getTime();
+    if (!current || t - blockStartMs >= windowMs) {
+      blockStartMs = t;
+      current = {
+        id: rec.timestamp,
+        startTime: rec.timestamp,
+        endTime: new Date(t + windowMs).toISOString(),
+        actualEndTime: rec.timestamp,
+        isActive: false,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        totalTokens: 0,
+        cost: 0,
+        saved: 0,
+        models: [],
+        requests: 0
+      };
+      blocks.push(current);
+    }
+    const cost = costOfRecord(rec);
+    current.inputTokens += rec.usage.input_tokens;
+    current.outputTokens += rec.usage.output_tokens;
+    current.cacheReadTokens += rec.usage.cache_read_input_tokens;
+    current.cacheCreationTokens += rec.usage.cache_creation_input_tokens;
+    current.totalTokens = current.inputTokens + current.outputTokens + current.cacheReadTokens + current.cacheCreationTokens;
+    current.cost += cost.total;
+    current.saved += cost.saved;
+    current.requests += 1;
+    current.actualEndTime = rec.timestamp;
+    if (!current.models.includes(rec.model)) current.models.push(rec.model);
+  }
+  for (const b of blocks) {
+    const endMs = new Date(b.endTime).getTime();
+    b.isActive = now < endMs;
+  }
+  return blocks;
+}
+function getActiveBlock(records, windowMs = DEFAULT_BLOCK_WINDOW_MS) {
+  const blocks = computeBlocks(records, windowMs);
+  const active = blocks.find((b) => b.isActive);
+  return active ?? null;
+}
+function blockProgress(records, windowMs = DEFAULT_BLOCK_WINDOW_MS) {
+  const block = getActiveBlock(records, windowMs);
+  if (!block) {
+    return {
+      block: null,
+      windowMs,
+      elapsedMs: 0,
+      remainingMs: 0,
+      progress: 0,
+      burnRatePerMin: 0,
+      costPerMin: 0,
+      projectedTotal: 0,
+      projectedCost: 0
+    };
+  }
+  const now = Date.now();
+  const startMs = new Date(block.startTime).getTime();
+  const endMs = new Date(block.endTime).getTime();
+  const elapsedMs = now - startMs;
+  const remainingMs = Math.max(0, endMs - now);
+  const progress = Math.min(1, elapsedMs / windowMs);
+  const elapsedMin = elapsedMs / 6e4;
+  const burnRatePerMin = elapsedMin > 0 ? block.totalTokens / elapsedMin : 0;
+  const costPerMin = elapsedMin > 0 ? block.cost / elapsedMin : 0;
+  const totalMin = windowMs / 6e4;
+  return {
+    block,
+    windowMs,
+    elapsedMs,
+    remainingMs,
+    progress,
+    burnRatePerMin,
+    costPerMin,
+    projectedTotal: burnRatePerMin * totalMin,
+    projectedCost: costPerMin * totalMin
+  };
+}
+
+// lib/aggregator/activity.ts
+var DAY_MS = 864e5;
+function computeActivityStats(records, opts) {
+  const filtered = opts.source === "all" ? records : records.filter((r) => r.source === opts.source);
+  if (filtered.length === 0) {
+    return {
+      sessions: 0,
+      messages: 0,
+      totalTokens: 0,
+      activeDays: 0,
+      currentStreak: 0,
+      longestStreak: 0,
+      peakHour: -1,
+      favoriteModel: null,
+      heatmap: emptyHeatmap(),
+      heatmapMax: 0,
+      tokenHeatmap: emptyHeatmap(),
+      tokensSummed: 0
+    };
+  }
+  const sessionSet = /* @__PURE__ */ new Set();
+  const dayKeys = /* @__PURE__ */ new Set();
+  const hourCounts = new Array(24).fill(0);
+  const modelCounts = /* @__PURE__ */ new Map();
+  const heatmap = emptyHeatmap();
+  const tokenHeatmap = emptyHeatmap();
+  let totalTokens2 = 0;
+  let messages = 0;
+  for (const r of filtered) {
+    if (r.sessionId) sessionSet.add(r.sessionId);
+    const d = new Date(r.timestamp);
+    if (Number.isNaN(d.getTime())) continue;
+    const dayKey = localDayKey(d);
+    dayKeys.add(dayKey);
+    const dow = d.getDay();
+    const hour = d.getHours();
+    hourCounts[hour] += 1;
+    heatmap[dow][hour] += 1;
+    modelCounts.set(r.model, (modelCounts.get(r.model) ?? 0) + 1);
+    const u = r.usage;
+    const recTokens = u.input_tokens + u.output_tokens + u.cache_read_input_tokens + u.cache_creation_input_tokens;
+    tokenHeatmap[dow][hour] += recTokens;
+    totalTokens2 += recTokens;
+    messages += 1;
+  }
+  const peakHour = argMax(hourCounts);
+  const favoriteModel = pickTopKey(modelCounts);
+  const { current, longest } = computeStreaks(dayKeys, opts.streakWindowDays ?? 365);
+  let heatmapMax = 0;
+  for (const row of heatmap) for (const v of row) if (v > heatmapMax) heatmapMax = v;
+  return {
+    sessions: sessionSet.size,
+    messages,
+    totalTokens: totalTokens2,
+    activeDays: dayKeys.size,
+    currentStreak: current,
+    longestStreak: longest,
+    peakHour,
+    favoriteModel,
+    heatmap,
+    heatmapMax,
+    tokenHeatmap,
+    tokensSummed: totalTokens2
+  };
+}
+function emptyHeatmap() {
+  return Array.from({ length: 7 }, () => new Array(24).fill(0));
+}
+function localDayKey(d) {
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+function argMax(arr) {
+  let bestIdx = -1;
+  let best = -1;
+  for (let i = 0; i < arr.length; i += 1) {
+    if (arr[i] > best) {
+      best = arr[i];
+      bestIdx = i;
+    }
+  }
+  return bestIdx;
+}
+function pickTopKey(m) {
+  let best = null;
+  let bestN = -1;
+  for (const [k, v] of m) {
+    if (v > bestN) {
+      best = k;
+      bestN = v;
+    }
+  }
+  return best;
+}
+function computeStreaks(dayKeys, windowDays) {
+  if (dayKeys.size === 0) return { current: 0, longest: 0 };
+  const days = Array.from(dayKeys).map((k) => (/* @__PURE__ */ new Date(k + "T00:00:00")).getTime()).filter((t) => Number.isFinite(t)).sort((a, b) => a - b);
+  let longest = 1;
+  let run = 1;
+  for (let i = 1; i < days.length; i += 1) {
+    if (days[i] - days[i - 1] === DAY_MS) {
+      run += 1;
+      if (run > longest) longest = run;
+    } else {
+      run = 1;
+    }
+  }
+  const todayMs = atMidnight(Date.now());
+  const lastDay = days[days.length - 1];
+  if (todayMs - lastDay > DAY_MS) {
+    return { current: 0, longest };
+  }
+  let cursor = lastDay;
+  let current = 0;
+  let scanned = 0;
+  const inSet = new Set(days);
+  while (scanned < windowDays && inSet.has(cursor)) {
+    current += 1;
+    cursor -= DAY_MS;
+    scanned += 1;
+  }
+  return { current, longest };
+}
+function atMidnight(ms) {
+  const d = new Date(ms);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+
+// lib/cli-report/ansi.ts
+var RGB = {
+  brand: [129, 140, 248],
+  // indigo-400
+  green: [34, 197, 94],
+  red: [239, 68, 68],
+  yellow: [234, 179, 8],
+  cyan: [34, 211, 238],
+  input: [96, 165, 250],
+  // blue-400
+  cacheWrite: [167, 139, 250],
+  // purple-400
+  cacheRead: [52, 211, 153],
+  // emerald-400
+  output: [251, 146, 60]
+  // orange-400
+};
+function fg(rgb, useColor) {
+  if (!useColor) return (s) => s;
+  const prefix = `\x1B[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+  return (s) => `${prefix}${s}\x1B[39m`;
+}
+function wrap(open, close, useColor) {
+  if (!useColor) return (s) => s;
+  return (s) => `${open}${s}${close}`;
+}
+function makePalette(useColor) {
+  return {
+    reset: useColor ? "\x1B[0m" : "",
+    bold: wrap("\x1B[1m", "\x1B[22m", useColor),
+    dim: wrap("\x1B[2m", "\x1B[22m", useColor),
+    brand: fg(RGB.brand, useColor),
+    green: fg(RGB.green, useColor),
+    red: fg(RGB.red, useColor),
+    yellow: fg(RGB.yellow, useColor),
+    cyan: fg(RGB.cyan, useColor),
+    input: fg(RGB.input, useColor),
+    cacheWrite: fg(RGB.cacheWrite, useColor),
+    cacheRead: fg(RGB.cacheRead, useColor),
+    output: fg(RGB.output, useColor)
+  };
+}
+var ANSI_RE = /\x1b\[[0-9;]*m/g;
+function visibleLen(s) {
+  return s.replace(ANSI_RE, "").length;
+}
+function padEnd(s, w, fill = " ") {
+  const need = w - visibleLen(s);
+  return need > 0 ? s + fill.repeat(need) : s;
+}
+function padStart(s, w, fill = " ") {
+  const need = w - visibleLen(s);
+  return need > 0 ? fill.repeat(need) + s : s;
+}
+function center(s, w, fill = " ") {
+  const need = w - visibleLen(s);
+  if (need <= 0) return s;
+  const l = Math.floor(need / 2);
+  const r = need - l;
+  return fill.repeat(l) + s + fill.repeat(r);
+}
+function truncate(s, w) {
+  if (visibleLen(s) <= w) return s;
+  return s.slice(0, Math.max(0, w - 1)) + "\u2026";
+}
+var HBAR_CHARS = ["", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589", "\u2588"];
+function hbar(ratio, width, color) {
+  if (width <= 0 || !Number.isFinite(ratio) || ratio <= 0) {
+    return " ".repeat(Math.max(0, width));
+  }
+  const r = Math.min(1, ratio);
+  const filledCells = r * width;
+  const fullCells = Math.floor(filledCells);
+  const remainder = filledCells - fullCells;
+  const subIdx = Math.round(remainder * 8);
+  let bar = "\u2588".repeat(fullCells);
+  if (subIdx > 0 && fullCells < width) bar += HBAR_CHARS[subIdx];
+  const out = padEnd(bar, width, " ");
+  return color ? color(out) : out;
+}
+var SPARK = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+function sparkline(values, width, color) {
+  if (width <= 0) return "";
+  if (values.length === 0) return color ? color("\u2500".repeat(width)) : "\u2500".repeat(width);
+  const sampled = [];
+  if (values.length === width) {
+    sampled.push(...values);
+  } else if (values.length > width) {
+    const step = values.length / width;
+    for (let i = 0; i < width; i += 1) {
+      const lo = Math.floor(i * step);
+      const hi = Math.floor((i + 1) * step);
+      let sum = 0;
+      let n = 0;
+      for (let j = lo; j < Math.min(hi, values.length); j += 1) {
+        sum += values[j];
+        n += 1;
+      }
+      sampled.push(n > 0 ? sum / n : 0);
+    }
+  } else {
+    const pad = width - values.length;
+    for (let i = 0; i < pad; i += 1) sampled.push(0);
+    sampled.push(...values);
+  }
+  const max = Math.max(...sampled, 0);
+  if (max <= 0) {
+    const flat = "\u2500".repeat(width);
+    return color ? color(flat) : flat;
+  }
+  const out = sampled.map((v) => SPARK[Math.min(7, Math.max(0, Math.round(v / max * 7)))]).join("");
+  return color ? color(out) : out;
+}
+var VBAR_CHARS = ["", "\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+function stackedColumn(segments, height, maxValue) {
+  const lines = new Array(height).fill(" ");
+  if (height <= 0 || maxValue <= 0) return lines;
+  const total = segments.reduce((s, x) => s + Math.max(0, x.value), 0);
+  if (total <= 0) return lines;
+  const totalUnits = total / maxValue * height * 8;
+  const cap = height * 8;
+  const used = Math.min(totalUnits, cap);
+  let remaining = used;
+  let cursorUnits = 0;
+  for (const seg of segments) {
+    if (seg.value <= 0 || remaining <= 0) continue;
+    const segUnits = Math.min(remaining, seg.value / total * used);
+    const startUnits = cursorUnits;
+    const endUnits = cursorUnits + segUnits;
+    const startRow = Math.floor(startUnits / 8);
+    const endRow = Math.min(height - 1, Math.floor((endUnits - 1e-4) / 8));
+    for (let row = startRow; row <= endRow; row += 1) {
+      const rowBottom = row * 8;
+      const rowTop = (row + 1) * 8;
+      const fillBottom = Math.max(0, startUnits - rowBottom);
+      const fillTop = Math.min(8, endUnits - rowBottom);
+      let ch;
+      if (fillTop >= 8) {
+        ch = "\u2588";
+      } else if (fillBottom <= 0) {
+        const idx = Math.max(1, Math.round(fillTop));
+        ch = VBAR_CHARS[Math.min(8, idx)] || "\u2581";
+      } else {
+        ch = "\u2588";
+      }
+      lines[height - 1 - row] = seg.color ? seg.color(ch) : ch;
+    }
+    remaining -= segUnits;
+    cursorUnits = endUnits;
+  }
+  return lines;
+}
+function box(title, contentLines, innerWidth, c) {
+  const titleStr = title ? ` ${title} ` : "";
+  const tLen = visibleLen(titleStr);
+  const beforeLen = Math.max(1, Math.floor((innerWidth - tLen) / 2));
+  const afterLen = Math.max(1, innerWidth - tLen - beforeLen);
+  const top = c.dim("\u250C" + "\u2500".repeat(beforeLen)) + (title ? c.bold(titleStr) : "\u2500".repeat(tLen)) + c.dim("\u2500".repeat(afterLen) + "\u2510");
+  const bot = c.dim("\u2514" + "\u2500".repeat(innerWidth) + "\u2518");
+  const body = contentLines.map((line) => c.dim("\u2502") + " " + padEnd(line, innerWidth - 2) + " " + c.dim("\u2502")).join("\n");
+  return [top, body, bot].join("\n");
+}
+function twoColumns(left, right, gap = 2) {
+  const ls = left.split("\n");
+  const rs = right.split("\n");
+  const h = Math.max(ls.length, rs.length);
+  const lw = Math.max(0, ...ls.map(visibleLen));
+  const sep = " ".repeat(Math.max(1, gap));
+  const out = [];
+  for (let i = 0; i < h; i += 1) {
+    const L = padEnd(ls[i] ?? "", lw);
+    const R = rs[i] ?? "";
+    out.push(L + sep + R);
+  }
+  return out.join("\n");
+}
+
+// lib/cli-report/dash.ts
+function renderDash(scan, data, opts, filteredRecords) {
+  const width = opts.width ?? process.stdout.columns ?? 100;
+  const useColor = opts.color !== false;
+  const c = makePalette(useColor);
+  if (width < 80) {
+    return [
+      `[ccgauge] terminal width (${width}) is below the dashboard's 80-column floor.`,
+      `Resize wider for the rich layout, or omit --dashboard for the standard report.`,
+      "",
+      ...renderText(data, opts).split("\n")
+    ].join("\n");
+  }
+  const inner = width - 4;
+  const lines = [];
+  if (opts.banner !== false) {
+    lines.push(...renderBanner(c, inner, data));
+    lines.push("");
+  }
+  lines.push(...renderKpiTiles(c, inner, scan, data));
+  lines.push("");
+  if (opts.compact !== true && data.trend.length > 0) {
+    lines.push(...renderTrend(c, inner, data));
+    lines.push("");
+  }
+  lines.push(...renderBreakdowns(c, inner, data));
+  lines.push("");
+  lines.push(...renderHeatmap(c, inner, filteredRecords));
+  lines.push("");
+  lines.push(...renderFooter(c, inner, filteredRecords, data, opts));
+  return lines.map((l) => "  " + l).join("\n");
+}
+function renderBanner(c, w, data) {
+  const title = `${c.brand(c.bold("ccgauge"))} ${c.bold("dashboard")}`;
+  const meta = c.dim(
+    [
+      `range: ${data.range}`,
+      `source: ${data.source}`,
+      `by: ${data.by}`,
+      `generated ${new Date(data.generatedAt).toLocaleString()}`
+    ].join("  \xB7  ")
+  );
+  const titlePart = ` ${title} `;
+  const metaPart = ` ${meta} `;
+  const fillLen = Math.max(0, w - visibleLen(titlePart) - visibleLen(metaPart) - 2);
+  const dash = c.dim("\u2500");
+  const left = c.dim("\u256D") + dash + titlePart + dash.repeat(Math.floor(fillLen / 2));
+  const right = dash.repeat(fillLen - Math.floor(fillLen / 2)) + metaPart + dash + c.dim("\u256E");
+  return [left + right];
+}
+function pickActiveBlock(records, source) {
+  function compute(provider) {
+    return blockProgress(
+      records.filter((r) => r.source === provider),
+      getProvider(provider).capabilities.blockWindowMs
+    );
+  }
+  if (source === "claude") return compute("claude");
+  if (source === "codex") return compute("codex");
+  const c = compute("claude");
+  if (c.block) return c;
+  const x = compute("codex");
+  return x.block ? x : c;
+}
+function renderKpiTiles(c, w, scan, data) {
+  const t = data.totals;
+  const sparkTokens = data.trend.map((b) => b.tokens);
+  const sparkCost = data.trend.map((b) => b.cost);
+  const sparkSaved = data.trend.map((b) => Math.max(0, b.cost - b.cost * 0.95));
+  const sparkConvos = data.trend.map((b) => b.turns);
+  const cacheIn = t.input + t.cacheRead + t.cacheWrite;
+  const cacheHit = cacheIn > 0 ? t.cacheRead / cacheIn : 0;
+  const activeBlock = pickActiveBlock(scan.records, data.source);
+  const tiles = [
+    {
+      label: "Total tokens",
+      value: c.bold(formatTokensCompact(t.total)),
+      sub: `${t.requests.toLocaleString()} reqs \xB7 ${t.turns.toLocaleString()} convs`,
+      spark: sparkline(sparkTokens, 12, c.input)
+    },
+    {
+      label: "Cost",
+      value: c.bold(formatUSD(t.cost)),
+      sub: t.cost > 0 ? `${formatUSD(t.cost / Math.max(1, t.requests))} / req` : "\u2014",
+      spark: sparkline(sparkCost, 12, c.output)
+    },
+    {
+      label: "Cache saved",
+      value: c.bold(c.green(formatUSD(t.saved))),
+      sub: `vs full input pricing`,
+      spark: sparkline(sparkSaved, 12, c.green)
+    },
+    {
+      label: "Cache hit",
+      value: c.bold(c.green(formatPct(cacheHit, 0))),
+      // Render the progress bar in the sparkline slot so this tile's
+      // row layout matches the others; the sub line then carries the
+      // raw ratio for users who care about the exact number.
+      spark: hbar(cacheHit, 12, c.green),
+      sub: `${formatTokensCompact(t.cacheRead)} cached`
+    },
+    {
+      label: "Conversations",
+      value: c.bold(t.turns.toLocaleString()),
+      sub: t.requests > 0 ? `${(t.requests / Math.max(1, t.turns)).toFixed(1)} reqs/turn` : "\u2014",
+      spark: sparkline(sparkConvos, 12, c.cacheRead)
+    },
+    {
+      label: "Active 5h block",
+      value: activeBlock?.block ? c.bold(formatDuration(activeBlock.remainingMs)) : c.dim("idle"),
+      spark: activeBlock?.block ? hbar(activeBlock.progress, 12, c.yellow) : void 0,
+      sub: activeBlock?.block ? `${formatPct(activeBlock.progress, 0)} elapsed` : "no active window"
+    }
+  ];
+  return layoutTiles(tiles, c, w);
+}
+function layoutTiles(tiles, c, w) {
+  const tileInner = 24;
+  const tileOuter = tileInner + 2;
+  const gap = 1;
+  const perRow = Math.max(1, Math.floor((w + gap) / (tileOuter + gap)));
+  const out = [];
+  for (let i = 0; i < tiles.length; i += perRow) {
+    const slice = tiles.slice(i, i + perRow);
+    const blocks = slice.map((t) => renderTile(t, tileInner, c));
+    out.push(...mergeHorizontally(blocks, gap).split("\n"));
+    if (i + perRow < tiles.length) out.push("");
+  }
+  return out;
+}
+function renderTile(t, inner, c) {
+  const cap = inner - 2;
+  const body = [""];
+  body.push(truncate(t.value, cap));
+  body.push(t.spark ? truncate(t.spark, cap) : "");
+  body.push(c.dim(truncate(t.sub, cap)));
+  return box(t.label, body, inner, c);
+}
+function mergeHorizontally(blocks, gap) {
+  const rows = blocks.map((b) => b.split("\n"));
+  const h = Math.max(...rows.map((r) => r.length));
+  const widths = rows.map((r) => Math.max(...r.map(visibleLen)));
+  const sep = " ".repeat(gap);
+  const lines = [];
+  for (let i = 0; i < h; i += 1) {
+    const cells = rows.map((r, idx) => padEnd(r[i] ?? "", widths[idx]));
+    lines.push(cells.join(sep));
+  }
+  return lines.join("\n");
+}
+function renderTrend(c, w, data) {
+  const trend = data.trend;
+  const height = 10;
+  const cellWidth = Math.max(4, Math.min(8, Math.floor((w - 8) / Math.max(1, trend.length))));
+  const max = Math.max(...trend.map((b) => b.input + b.output + b.cacheRead + b.cacheWrite), 1);
+  const heading = `${c.brand("\u25B8")} ${c.bold("Token usage trend")} ${c.dim(
+    `(${data.gran} \xD7 stacked: input / cache-w / cache-r / output)`
+  )}`;
+  const colsPerBucket = trend.map(
+    (b) => stackedColumn(
+      [
+        { value: b.input, color: c.input },
+        { value: b.cacheWrite, color: c.cacheWrite },
+        { value: b.cacheRead, color: c.cacheRead },
+        { value: b.output, color: c.output }
+      ],
+      height,
+      max
+    )
+  );
+  const yLabels = [
+    padStart(formatTokensCompact(max), 7),
+    padStart(formatTokensCompact(max / 2), 7),
+    padStart("0", 7)
+  ];
+  const yLabelRow = (row) => {
+    if (row === 0) return yLabels[0];
+    if (row === Math.floor((height - 1) / 2)) return yLabels[1];
+    if (row === height - 1) return yLabels[2];
+    return " ".repeat(7);
+  };
+  const lines = [heading, ""];
+  for (let row = 0; row < height; row += 1) {
+    const cells = colsPerBucket.map((col) => center(col[row], cellWidth));
+    lines.push(`${c.dim(yLabelRow(row))} ${c.dim("\u2502")} ${cells.join("")}`);
+  }
+  const baseline = "\u2500".repeat(Math.min(w - 9, cellWidth * trend.length));
+  lines.push(`${" ".repeat(7)} ${c.dim("\u2514")}${c.dim(baseline)}`);
+  const sampleLabel = trend[0]?.label ?? "";
+  const labelStep = Math.max(1, Math.ceil((sampleLabel.length + 1) / cellWidth));
+  const xCells = trend.map((b, i) => {
+    if (i % labelStep !== 0) return " ".repeat(cellWidth);
+    const span = cellWidth * Math.min(labelStep, trend.length - i);
+    return center(b.label, span);
+  });
+  let xLine = "";
+  for (let i = 0; i < xCells.length; i += 1) {
+    if (i % labelStep === 0) xLine += xCells[i];
+  }
+  lines.push(`${" ".repeat(8)} ${c.dim(xLine)}`);
+  lines.push("");
+  lines.push(
+    `${" ".repeat(8)}${c.input("\u25CF")} input    ${c.cacheWrite("\u25CF")} cache-write    ${c.cacheRead("\u25CF")} cache-read    ${c.output("\u25CF")} output`
+  );
+  return lines;
+}
+function renderBreakdowns(c, w, data) {
+  const primary = data.breakdown.slice(0, 10);
+  const left = renderBreakdownColumn(
+    c,
+    Math.floor((w - 2) / 2),
+    `Top ${data.by}s (by cost)`,
+    primary,
+    data.totals.cost
+  );
+  const right = renderBreakdownColumn(
+    c,
+    Math.floor((w - 2) / 2),
+    `Top ${data.by}s (by conversations)`,
+    primary.slice().sort((a, b) => b.turns - a.turns).slice(0, 10),
+    Math.max(1, ...primary.map((r) => r.turns)),
+    "turns"
+  );
+  return twoColumns(left, right, 2).split("\n");
+}
+function renderBreakdownColumn(c, innerWidth, title, rows, scale, metric = "cost") {
+  const labelW = Math.max(10, Math.min(22, innerWidth - 30));
+  const headers = [
+    padEnd("#", 2),
+    padEnd(metric === "cost" ? "Item" : "Item", labelW),
+    padStart("Conv", 5),
+    padStart("Reqs", 6),
+    padStart("Tokens", 8),
+    padStart(metric === "cost" ? "Cost" : "Cost", 8)
+  ];
+  const bodyLines = [];
+  bodyLines.push(c.dim(headers.join(" ")));
+  bodyLines.push(c.dim("\u2500".repeat(Math.min(innerWidth - 2, headers.join(" ").length))));
+  if (rows.length === 0) {
+    bodyLines.push(c.dim("(no data in this window)"));
+  }
+  rows.forEach((r, i) => {
+    const lbl = truncate(r.label, labelW);
+    bodyLines.push(
+      [
+        padEnd(String(i + 1), 2),
+        padEnd(lbl, labelW),
+        padStart(r.turns.toLocaleString(), 5),
+        padStart(r.requests.toLocaleString(), 6),
+        padStart(formatTokensCompact(r.tokens), 8),
+        padStart(formatUSD(r.cost), 8)
+      ].join(" ")
+    );
+    const ratio = metric === "cost" ? r.cost / Math.max(1e-9, scale) : r.turns / Math.max(1e-9, scale);
+    const barW = innerWidth - 4 - 2 - labelW;
+    bodyLines.push(`${" ".repeat(3)}${hbar(ratio, Math.max(8, Math.min(40, barW)), c.brand)}`);
+  });
+  return box(title, bodyLines, innerWidth, c);
+}
+function renderHeatmap(c, w, records) {
+  const stats = computeActivityStats(records, { source: "all" });
+  const heat = stats.heatmap;
+  const max = stats.heatmapMax;
+  if (max === 0) {
+    return [`${c.brand("\u25B8")} ${c.bold("Activity heatmap")}`, "", c.dim("  (no activity yet \u2014 start a session and re-run)")];
+  }
+  const dayLabels = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+  const density = ["\xB7", "\u25A2", "\u25A3", "\u25A4", "\u25A5", "\u25A6"];
+  const cell = (v) => {
+    if (v === 0) return c.dim("\xB7");
+    const idx = Math.min(density.length - 1, Math.max(1, Math.ceil(v / max * (density.length - 1))));
+    const ch = density[idx];
+    return idx < 3 ? c.input(ch) : idx < 5 ? c.cacheRead(ch) : c.output(ch);
+  };
+  const heading = `${c.brand("\u25B8")} ${c.bold("Activity heatmap")} ${c.dim("(local time, day-of-week \xD7 hour)")}`;
+  const hourHeader = "    " + Array.from({ length: 24 }, (_, h) => padStart(String(h), 2)).join(" ");
+  const lines = [heading, "", c.dim(hourHeader)];
+  for (let dow = 0; dow < 7; dow += 1) {
+    const sourceDow = (dow + 1) % 7;
+    const row = heat[sourceDow] ?? new Array(24).fill(0);
+    const cells = row.map((v) => padStart(cell(v), 2)).join(" ");
+    lines.push(`${c.dim(padEnd(dayLabels[dow], 4))}${cells}`);
+  }
+  return lines;
+}
+function renderFooter(c, w, records, data, opts) {
+  const filters = [];
+  if (opts.model) filters.push(`model~${opts.model}`);
+  if (opts.project) filters.push(`project~${opts.project}`);
+  if (data.fromIso || data.untilIso) {
+    const range = `${data.fromIso?.slice(0, 10) ?? "\u2026"} \u2192 ${data.untilIso?.slice(0, 10) ?? "\u2026"}`;
+    filters.push(range);
+  }
+  const scope = [
+    `range: ${data.range}`,
+    `source: ${data.source}`,
+    `scope: ${records.length.toLocaleString()} records \xB7 ${data.totals.turns.toLocaleString()} conversations`
+  ];
+  if (filters.length > 0) scope.push(`filters: ${filters.join(", ")}`);
+  return [
+    c.dim(scope.join("  \xB7  ")),
+    c.dim(`Use \`ccgauge report\` for a CI-friendly text summary, or \`ccgauge report -d --json\` to pipe.`)
+  ];
+}
+
 // lib/cli-report/index.ts
 var REPORT_RANGES = ["today", "1d", "7d", "30d", "90d", "all"];
 var DIMS = ["model", "project", "session"];
@@ -1838,16 +2685,43 @@ var DEFAULT_REPORT = {
   json: false,
   color: true,
   showTrend: true,
-  showBreakdown: true
+  showBreakdown: true,
+  dashboard: false,
+  compact: false,
+  banner: true
 };
 async function runReport(opts) {
   const filled = normalizeReportOptions(opts);
   const scan = await getCachedScan();
   const sources = filled.source === "all" ? ALL_PROVIDER_IDS : [filled.source];
-  const data = computeReportData(scan.records, sources, filled);
+  const data = computeReportData(scan, sources, filled);
   if (filled.json) return JSON.stringify(data, null, 2);
+  if (filled.dashboard) {
+    const filteredRecords = filterRecordsForReport(scan, sources, filled);
+    return renderDash(scan, data, filled, filteredRecords);
+  }
   return renderText(data, filled);
 }
+function filterRecordsForReport(scan, sources, o) {
+  const dates = resolveRange(o);
+  const fromIso = dates.from?.toISOString();
+  const toIso = dates.until?.toISOString();
+  const sourceSet = new Set(sources);
+  const modelNeedle = o.model?.toLowerCase();
+  const projectNeedle = o.project?.toLowerCase();
+  return scan.records.filter((r) => {
+    if (!sourceSet.has(r.source)) return false;
+    if (fromIso && r.timestamp < fromIso) return false;
+    if (toIso && r.timestamp > toIso) return false;
+    if (modelNeedle && !r.model.toLowerCase().includes(modelNeedle)) return false;
+    if (projectNeedle) {
+      const cwd = (r.cwd || "").toLowerCase();
+      const leaf = cwd.split(/[/\\]+/).pop() ?? "";
+      if (!cwd.includes(projectNeedle) && !leaf.includes(projectNeedle)) return false;
+    }
+    return true;
+  });
+}
 function normalizeReportOptions(opts) {
   const filled = { ...DEFAULT_REPORT, ...opts };
   if (!isReportRange(filled.range)) {
@@ -1879,14 +2753,15 @@ function isDim(v) {
 function invalidOptionMessage(name, value, expected) {
   return `invalid ${name}: ${JSON.stringify(value)}. Expected one of: ${expected.join(", ")}`;
 }
-function computeReportData(allRecords, sources, o) {
+function computeReportData(scan, sources, o) {
+  const allRecords = scan.records;
   const dates = resolveRange(o);
   const baseOpts = {
     from: dates.from ?? void 0,
-    to: dates.until ?? void 0,
-    models: o.model ? void 0 : void 0,
-    // handled post-filter
-    projects: o.project ? void 0 : void 0
+    to: dates.until ?? void 0
+    // `o.model` / `o.project` are substring patterns, not exact matches —
+    // they're applied per-record by `withinSrcAndFilters` below, so we
+    // deliberately leave the aggregator's exact-match filters unset.
   };
   const totals = {
     input: 0,
@@ -1897,7 +2772,8 @@ function computeReportData(allRecords, sources, o) {
     total: 0,
     cost: 0,
     saved: 0,
-    requests: 0
+    requests: 0,
+    turns: 0
   };
   const trendBuckets = /* @__PURE__ */ new Map();
   for (const source of sources) {
@@ -1913,19 +2789,41 @@ function computeReportData(allRecords, sources, o) {
     totals.saved += t.saved;
     totals.requests += t.requests;
     for (const r of sourceRecs) totals.reasoning += r.usage.reasoning_tokens ?? 0;
+    const turnSummaries = summarizeTurns(sourceRecs, scan.userRecords, scan.parentMap);
+    totals.turns += turnSummaries.size;
+    const turnsByKey = /* @__PURE__ */ new Map();
+    for (const tn of turnSummaries.values()) {
+      const { key } = bucketKey(tn.firstTimestamp, o.gran);
+      turnsByKey.set(key, (turnsByKey.get(key) ?? 0) + 1);
+    }
     const buckets = aggregateByTime(sourceRecs, o.gran, opts);
     for (const b of buckets) {
       const ex = trendBuckets.get(b.key);
+      const tnCount = turnsByKey.get(b.key) ?? 0;
       if (ex) {
         ex.cost += b.cost;
         ex.tokens += b.totalTokens;
+        ex.turns += tnCount;
+        ex.input += b.inputTokens;
+        ex.output += b.outputTokens;
+        ex.cacheRead += b.cacheReadTokens;
+        ex.cacheWrite += b.cacheCreationTokens;
       } else {
-        trendBuckets.set(b.key, { label: b.label, cost: b.cost, tokens: b.totalTokens });
+        trendBuckets.set(b.key, {
+          label: b.label,
+          cost: b.cost,
+          tokens: b.totalTokens,
+          turns: tnCount,
+          input: b.inputTokens,
+          output: b.outputTokens,
+          cacheRead: b.cacheReadTokens,
+          cacheWrite: b.cacheCreationTokens
+        });
       }
     }
   }
   const trend = Array.from(trendBuckets.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([, v]) => v);
-  const breakdown = buildBreakdown(allRecords, sources, baseOpts, o);
+  const breakdown = buildBreakdown(scan, sources, baseOpts, o);
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     range: o.range,
@@ -1939,7 +2837,8 @@ function computeReportData(allRecords, sources, o) {
     breakdown
   };
 }
-function buildBreakdown(allRecords, sources, base, o) {
+function buildBreakdown(scan, sources, base, o) {
+  const allRecords = scan.records;
   if (o.by === "model") {
     const rows2 = [];
     for (const source of sources) {
@@ -1947,11 +2846,16 @@ function buildBreakdown(allRecords, sources, base, o) {
       const filtered = allRecords.filter((r) => withinSrcAndFilters(r, opts, o));
       const models = aggregateByModel(filtered, opts);
       const provider = getProvider(source);
+      const turnsByModel = /* @__PURE__ */ new Map();
+      for (const tn of summarizeTurns(filtered, scan.userRecords, scan.parentMap).values()) {
+        turnsByModel.set(tn.firstModel, (turnsByModel.get(tn.firstModel) ?? 0) + 1);
+      }
       for (const m of models) {
         rows2.push({
           key: `${source}::${m.model}`,
           label: provider.shortenModel(m.model),
           requests: m.requests,
+          turns: turnsByModel.get(m.model) ?? 0,
           tokens: m.totalTokens,
           cost: m.cost,
           share: 0,
@@ -1968,11 +2872,17 @@ function buildBreakdown(allRecords, sources, base, o) {
       const opts = { ...base, source };
       const filtered = allRecords.filter((r) => withinSrcAndFilters(r, opts, o));
       const projects = aggregateByProject(filtered, opts);
+      const turnsByCwd = /* @__PURE__ */ new Map();
+      for (const tn of summarizeTurns(filtered, scan.userRecords, scan.parentMap).values()) {
+        const key = tn.cwd || "(unknown)";
+        turnsByCwd.set(key, (turnsByCwd.get(key) ?? 0) + 1);
+      }
       for (const p of projects) {
         rows2.push({
           key: `${source}::${p.cwd}`,
           label: p.projectName,
           requests: p.requests,
+          turns: turnsByCwd.get(p.cwd) ?? 0,
           tokens: p.totalTokens,
           cost: p.cost,
           share: 0,
@@ -1987,15 +2897,23 @@ function buildBreakdown(allRecords, sources, base, o) {
     const opts = { ...base, source };
     const filtered = allRecords.filter((r) => withinSrcAndFilters(r, opts, o));
     const sessions = aggregateBySession(filtered, [], opts);
+    const turnsBySession = /* @__PURE__ */ new Map();
+    for (const tn of summarizeTurns(filtered, scan.userRecords, scan.parentMap).values()) {
+      turnsBySession.set(tn.sessionId, (turnsBySession.get(tn.sessionId) ?? 0) + 1);
+    }
     for (const s of sessions) {
       rows.push({
         key: `${source}::${s.sessionId}`,
         label: s.title ?? s.sessionId.slice(0, 8),
         requests: s.requests,
+        turns: turnsBySession.get(s.sessionId) ?? 0,
         tokens: s.totalTokens,
         cost: s.cost,
         share: 0,
-        sub: s.projectName
+        // Worktree-aware so the breakdown reads
+        // `ai-self-web (playwright)` instead of just `playwright`,
+        // matching the dashboard's usage / sessions tables.
+        sub: s.projectLabel
       });
     }
   }
@@ -2054,17 +2972,17 @@ function parseReportDate(raw, boundary) {
   return date;
 }
 function makeColors(enabled) {
-  const wrap = (code) => (s) => enabled ? `\x1B[${code}m${s}\x1B[0m` : String(s);
+  const wrap2 = (code) => (s) => enabled ? `\x1B[${code}m${s}\x1B[0m` : String(s);
   return {
-    bold: wrap("1"),
-    dim: wrap("2"),
-    cyan: wrap("36"),
-    green: wrap("32"),
-    yellow: wrap("33"),
-    red: wrap("31"),
-    blue: wrap("34"),
-    magenta: wrap("35"),
-    brand: wrap("38;2;129;140;248")
+    bold: wrap2("1"),
+    dim: wrap2("2"),
+    cyan: wrap2("36"),
+    green: wrap2("32"),
+    yellow: wrap2("33"),
+    red: wrap2("31"),
+    blue: wrap2("34"),
+    magenta: wrap2("35"),
+    brand: wrap2("38;2;129;140;248")
   };
 }
 function renderText(d, o) {
@@ -2097,21 +3015,15 @@ function renderText(d, o) {
     ]
   ];
   if (t.reasoning > 0) {
-    tokenRows.push([
-      "Reasoning",
-      c.dim(formatTokensCompact(t.reasoning)),
-      "Requests",
-      t.requests.toLocaleString()
-    ]);
-    tokenRows.push(["Total", c.bold(formatTokensCompact(t.total)), "", ""]);
-  } else {
-    tokenRows.push([
-      "Total",
-      c.bold(formatTokensCompact(t.total)),
-      "Requests",
-      t.requests.toLocaleString()
-    ]);
-  }
+    tokenRows.push(["Reasoning", c.dim(formatTokensCompact(t.reasoning)), "", ""]);
+  }
+  tokenRows.push(["Total", c.bold(formatTokensCompact(t.total)), "", ""]);
+  tokenRows.push([
+    "Convos",
+    c.bold(t.turns.toLocaleString()),
+    "Requests",
+    t.requests.toLocaleString()
+  ]);
   lines.push(renderPairedKv(tokenRows, c));
   lines.push("");
   lines.push(c.brand("\u25B8") + " " + c.bold("Cost"));
@@ -2147,16 +3059,17 @@ function renderText(d, o) {
     lines.push(
       c.brand("\u25B8") + " " + c.bold(`Top ${d.breakdown.length} ${dimLabel}s`) + " " + c.dim("(by cost)")
     );
-    const headers = ["#", dimLabel, "Reqs", "Tokens", "Cost", "Share"];
+    const headers = ["#", dimLabel, "Convos", "Reqs", "Tokens", "Cost", "Share"];
     const rows = d.breakdown.map((r, i) => [
       String(i + 1),
-      truncate(r.label, 28),
+      truncate2(r.label, 28),
+      r.turns.toLocaleString(),
       r.requests.toLocaleString(),
       formatTokensCompact(r.tokens),
       formatUSD(r.cost),
       formatPct(r.share, 1)
     ]);
-    lines.push(renderTable(headers, rows, c, [false, false, true, true, true, true]));
+    lines.push(renderTable(headers, rows, c, [false, false, true, true, true, true, true]));
     lines.push("");
   }
   return lines.join("\n");
@@ -2165,24 +3078,24 @@ function renderPairedKv(rows, c) {
   const w = [0, 0, 0, 0];
   for (const r of rows) for (let i = 0; i < 4; i += 1) {
     const cell = r[i];
-    if (visibleLen(cell) > w[i]) w[i] = visibleLen(cell);
+    if (visibleLen2(cell) > w[i]) w[i] = visibleLen2(cell);
   }
   const lines = [];
   for (const [lk, lv, rk, rv] of rows) {
-    const left = `${c.dim(padEnd(lk, w[0]))}  ${padEnd(lv, w[1])}`;
-    const right = rk ? `${c.dim(padEnd(rk, w[2]))}  ${rv}` : "";
+    const left = `${c.dim(padEnd2(lk, w[0]))}  ${padEnd2(lv, w[1])}`;
+    const right = rk ? `${c.dim(padEnd2(rk, w[2]))}  ${rv}` : "";
     lines.push(`  ${left}    ${right}`.replace(/\s+$/, ""));
   }
   return lines.join("\n");
 }
 function renderTable(headers, rows, c, rightAlign) {
   const widths = headers.map(
-    (h, i) => Math.max(h.length, ...rows.map((r) => visibleLen(r[i] ?? "")))
+    (h, i) => Math.max(h.length, ...rows.map((r) => visibleLen2(r[i] ?? "")))
   );
-  const headLine = "  " + headers.map((h, i) => rightAlign[i] ? padStart(h, widths[i]) : padEnd(h, widths[i])).map((s) => c.dim(s)).join("  ");
+  const headLine = "  " + headers.map((h, i) => rightAlign[i] ? padStart2(h, widths[i]) : padEnd2(h, widths[i])).map((s) => c.dim(s)).join("  ");
   const sepLine = "  " + widths.map((w) => "\u2500".repeat(w)).map((s) => c.dim(s)).join("  ");
   const bodyLines = rows.map(
-    (row) => "  " + row.map((cell, i) => rightAlign[i] ? padStart(cell, widths[i]) : padEnd(cell, widths[i])).join("  ")
+    (row) => "  " + row.map((cell, i) => rightAlign[i] ? padStart2(cell, widths[i]) : padEnd2(cell, widths[i])).join("  ")
   );
   return [headLine, sepLine, ...bodyLines].join("\n");
 }
@@ -2192,21 +3105,23 @@ function barString(ratio, width) {
   return "\u2587".repeat(filled) + "\u2500".repeat(width - filled);
 }
 var ESC = String.fromCharCode(27);
-var ANSI_RE = new RegExp(ESC + "\\[[0-9;]*m", "g");
-function visibleLen(s) {
-  return s.replace(ANSI_RE, "").length;
+var ANSI_RE2 = new RegExp(ESC + "\\[[0-9;]*m", "g");
+function visibleLen2(s) {
+  return s.replace(ANSI_RE2, "").length;
 }
-function padEnd(s, w) {
-  return s + " ".repeat(Math.max(0, w - visibleLen(s)));
+function padEnd2(s, w) {
+  return s + " ".repeat(Math.max(0, w - visibleLen2(s)));
 }
-function padStart(s, w) {
-  return " ".repeat(Math.max(0, w - visibleLen(s))) + s;
+function padStart2(s, w) {
+  return " ".repeat(Math.max(0, w - visibleLen2(s))) + s;
 }
-function truncate(s, max) {
+function truncate2(s, max) {
   if (s.length <= max) return s;
   return s.slice(0, max - 1) + "\u2026";
 }
 export {
   DEFAULT_REPORT,
+  filterRecordsForReport,
+  renderText,
   runReport
 };