llm-usage-metrics 0.5.2 → 0.6.0

package/dist/index.js

@@ -889,9 +889,6 @@ ${noData}
 import { markdownTable } from "markdown-table";
 import pc4 from "picocolors";
 
-// src/render/report-header.ts
-import pc from "picocolors";
-
 // src/render/table-text-layout.ts
 var ansiEscapePattern = new RegExp(String.raw`\u001B\[[0-9;]*m`, "gu");
 var combiningMarkPattern = /\p{Mark}/u;
@@ -1065,7 +1062,30 @@ function wrapTableColumn(rows, options) {
   });
 }
 
+// src/render/markdown-safe-cell.ts
+var markdownSpecialCharacterPattern = /[\\`*_~[\]()!|]/gu;
+var bareUrlPattern = /\bhttps?:\/\/[^\s<]+|\bwww\.[^\s<]+/giu;
+var bareEmailPattern = /(^|[^\w.+-])([\w.+-]+@[\w.-]+\.[a-z]{2,})(?=$|[^\w.-])/giu;
+function escapeBareAutolinks(value) {
+  const withoutBareUrls = value.replace(
+    bareUrlPattern,
+    (match) => match.startsWith("www.") ? match.replace("www.", "www\\.") : match.replace("://", "\\://")
+  );
+  return withoutBareUrls.replace(
+    bareEmailPattern,
+    (_, prefix, email) => `${prefix}${email.replace("@", "\\@")}`
+  );
+}
+function escapeMarkdownText(value) {
+  const escapedMarkdownText = value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replace(markdownSpecialCharacterPattern, "\\$&");
+  return escapeBareAutolinks(escapedMarkdownText);
+}
+function toMarkdownSafeCell(value) {
+  return splitCellLines(value).map((line) => escapeMarkdownText(line)).join("<br>");
+}
+
 // src/render/report-header.ts
+import pc from "picocolors";
 function getBoxWidth(content) {
   return visibleWidth(content) + 4;
 }
@@ -1188,12 +1208,68 @@ var defaultTerminalStylePalette = {
   dim: pc2.dim
 };
 var passthroughStyler = (text) => text;
+var periodColumnIndex = 0;
+var sourceColumnIndex = 1;
+var modelsColumnIndex = 2;
+var totalColumnIndex = 8;
+var packedModelStartPattern = /(^| {2,})(?=• )/gu;
 function styleCellLines(cell, styler) {
-  return cell.split("\n").map((line) => line.length === 0 ? "" : styler(line)).join("\n");
+  return splitCellLines(cell).map((line) => line.length === 0 ? "" : styler(line)).join("\n");
+}
+function styleModelsCell(cell, palette, options = {}) {
+  const emphasizePrimaryWhenSingleLine = options.emphasizePrimaryWhenSingleLine ?? false;
+  const primaryStyler = options.primaryStyler ?? palette.bold;
+  const secondaryStyler = options.secondaryStyler ?? passthroughStyler;
+  const totalStyler = options.totalStyler ?? ((text) => palette.bold(palette.green(text)));
+  const lines = splitCellLines(cell);
+  const modelEntryCount = lines.reduce((count, line) => {
+    if (line === "\u03A3 TOTAL") {
+      return count;
+    }
+    const segmentStarts = [...line.matchAll(packedModelStartPattern)];
+    return count + segmentStarts.length;
+  }, 0);
+  const shouldEmphasizePrimary = emphasizePrimaryWhenSingleLine || modelEntryCount > 1;
+  let currentStyler = shouldEmphasizePrimary ? primaryStyler : passthroughStyler;
+  let modelLineCount = 0;
+  return lines.map((line) => {
+    if (line.length === 0) {
+      return "";
+    }
+    if (line === "\u03A3 TOTAL") {
+      currentStyler = totalStyler;
+      return totalStyler(line);
+    }
+    const segmentStarts = [...line.matchAll(packedModelStartPattern)].map((match) => match.index);
+    if (segmentStarts.length === 0) {
+      return currentStyler(line);
+    }
+    const prefix = segmentStarts[0] > 0 ? currentStyler(line.slice(0, segmentStarts[0])) : "";
+    let nextContinuationStyler = currentStyler;
+    const renderedSegments = segmentStarts.map((segmentStart, segmentIndex) => {
+      const segmentStyler = modelLineCount === 0 && shouldEmphasizePrimary ? primaryStyler : secondaryStyler;
+      modelLineCount += 1;
+      nextContinuationStyler = segmentStyler;
+      const segmentEnd = segmentStarts[segmentIndex + 1] ?? line.length;
+      return segmentStyler(line.slice(segmentStart, segmentEnd));
+    }).join("");
+    currentStyler = nextContinuationStyler;
+    return prefix + renderedSegments;
+  }).join("\n");
+}
+function styleCellAtIndex(cells, index, styler) {
+  if (index < 0 || index >= cells.length) {
+    return cells;
+  }
+  const styledCells = [...cells];
+  styledCells[index] = styleCellLines(styledCells[index], styler);
+  return styledCells;
 }
 var sourceStylePolicies = /* @__PURE__ */ new Map([
   ["pi", (palette) => palette.cyan],
   ["codex", (palette) => palette.magenta],
+  ["gemini", (palette) => palette.yellow],
+  ["droid", (palette) => palette.green],
   ["opencode", (palette) => palette.blue]
 ]);
 function resolveSourceStyler(source, palette = defaultTerminalStylePalette) {
@@ -1203,28 +1279,98 @@ function resolveSourceStyler(source, palette = defaultTerminalStylePalette) {
   }
   return stylePolicy(palette);
 }
+function getTrailingColumnIndex(cells) {
+  return cells.length === 0 ? void 0 : cells.length - 1;
+}
 var rowTypeStylePolicies = {
   period_source: (cells, palette) => {
-    const styledCells = [...cells];
-    const costColumnIndex2 = styledCells.length - 1;
-    styledCells[costColumnIndex2] = styleCellLines(styledCells[costColumnIndex2], palette.yellow);
+    let styledCells = [...cells];
+    const trailingColumnIndex = getTrailingColumnIndex(styledCells);
+    if (modelsColumnIndex < styledCells.length) {
+      styledCells[modelsColumnIndex] = styleModelsCell(styledCells[modelsColumnIndex], palette, {
+        secondaryStyler: palette.dim
+      });
+    }
+    styledCells = styleCellAtIndex(styledCells, totalColumnIndex, palette.green);
+    if (trailingColumnIndex !== void 0) {
+      styledCells = styleCellAtIndex(
+        styledCells,
+        trailingColumnIndex,
+        (line) => palette.bold(palette.yellow(line))
+      );
+    }
+    return styledCells;
+  },
+  period_combined: (cells, palette) => {
+    let styledCells = [...cells];
+    const trailingColumnIndex = getTrailingColumnIndex(styledCells);
+    styledCells = styleCellAtIndex(styledCells, periodColumnIndex, palette.white);
+    styledCells = styleCellAtIndex(
+      styledCells,
+      sourceColumnIndex,
+      (line) => palette.bold(palette.yellow(line))
+    );
+    if (modelsColumnIndex < styledCells.length) {
+      styledCells[modelsColumnIndex] = styleModelsCell(styledCells[modelsColumnIndex], palette, {
+        secondaryStyler: palette.dim
+      });
+    }
+    styledCells = styleCellAtIndex(
+      styledCells,
+      totalColumnIndex,
+      (line) => palette.bold(palette.green(line))
+    );
+    if (trailingColumnIndex !== void 0) {
+      styledCells = styleCellAtIndex(
+        styledCells,
+        trailingColumnIndex,
+        (line) => palette.bold(palette.yellow(line))
+      );
+    }
     return styledCells;
   },
-  period_combined: (cells, palette) => cells.map((cell, cellIndex) => {
-    if (cellIndex === 1) {
-      return styleCellLines(cell, (line) => palette.bold(palette.yellow(line)));
+  grand_total: (cells, palette) => {
+    const styledCells = cells.map((cell, cellIndex) => {
+      if (cellIndex === modelsColumnIndex) {
+        return cell;
+      }
+      return styleCellLines(cell, palette.bold);
+    });
+    if (periodColumnIndex < styledCells.length) {
+      styledCells[periodColumnIndex] = styleCellLines(
+        cells[periodColumnIndex],
+        (line) => palette.bold(palette.white(line))
+      );
     }
-    return styleCellLines(cell, palette.dim);
-  }),
-  grand_total: (cells, palette) => cells.map((cell, cellIndex) => {
-    if (cellIndex === 0) {
-      return styleCellLines(cell, (line) => palette.bold(palette.white(line)));
+    if (sourceColumnIndex < styledCells.length) {
+      styledCells[sourceColumnIndex] = styleCellLines(
+        cells[sourceColumnIndex],
+        (line) => palette.bold(palette.green(line))
+      );
+    }
+    if (modelsColumnIndex < styledCells.length) {
+      styledCells[modelsColumnIndex] = styleModelsCell(styledCells[modelsColumnIndex], palette, {
+        emphasizePrimaryWhenSingleLine: true,
+        primaryStyler: (line) => palette.bold(palette.white(line)),
+        secondaryStyler: palette.dim,
+        totalStyler: (line) => palette.bold(palette.green(line))
+      });
     }
-    if (cellIndex === 1) {
-      return styleCellLines(cell, (line) => palette.bold(palette.green(line)));
+    if (totalColumnIndex < styledCells.length) {
+      styledCells[totalColumnIndex] = styleCellLines(
+        cells[totalColumnIndex],
+        (line) => palette.bold(palette.green(line))
+      );
+    }
+    const trailingColumnIndex = getTrailingColumnIndex(styledCells);
+    if (trailingColumnIndex !== void 0) {
+      styledCells[trailingColumnIndex] = styleCellLines(
+        cells[trailingColumnIndex],
+        (line) => palette.bold(palette.yellow(line))
+      );
     }
-    return styleCellLines(cell, palette.bold);
-  })
+    return styledCells;
+  }
 };
 function applyRowTypeStyle(rowType, cells, palette = defaultTerminalStylePalette) {
   return rowTypeStylePolicies[rowType](cells, palette);
@@ -1244,8 +1390,9 @@ function colorizeUsageBodyRows(bodyRows, rows, options) {
   }
   const palette = options.palette ?? defaultTerminalStylePalette;
   return rows.map((row, index) => {
+    const bodyRow = bodyRows[index] ?? [];
     const sourceStyler = row.rowType === "period_source" ? resolveSourceStyler(String(row.source), palette) : passthroughStyler;
-    const baseStyledCells = applyBaseCellStyle(bodyRows[index], palette, sourceStyler);
+    const baseStyledCells = row.rowType === "period_source" ? applyBaseCellStyle(bodyRow, palette, sourceStyler) : [...bodyRow];
     return applyRowTypeStyle(row.rowType, baseStyledCells, palette);
   });
 }
@@ -1348,7 +1495,7 @@ function getColumnAlignment(columnIndex, multilineColumnIndex) {
   return "right";
 }
 function getVerticalAlignment(columnIndex, layout, multilineColumnIndex) {
-  if (columnIndex === multilineColumnIndex) {
+  if (columnIndex <= multilineColumnIndex) {
     return "top";
   }
   return layout === "top_aligned" ? "top" : "middle";
@@ -1406,7 +1553,7 @@ function shouldDrawBodySeparator(index, rowMetas) {
   }
   const previousRow = rowMetas[index];
   const nextRow = rowMetas[index + 1];
-  return previousRow.rowKind === "combined" || nextRow.rowKind === "total" || previousRow.periodKey !== nextRow.periodKey;
+  return previousRow.rowKind === "detail" && (nextRow.rowKind === "detail" || nextRow.rowKind === "combined") && previousRow.periodKey === nextRow.periodKey || previousRow.rowKind === "combined" || nextRow.rowKind === "total" || previousRow.periodKey !== nextRow.periodKey;
 }
 function getRowKindWeight(rowKind) {
   switch (rowKind) {
@@ -1566,9 +1713,10 @@ function renderUnicodeTable(options) {
 }
 
 // src/render/terminal-table.ts
-var modelsColumnIndex = 2;
+var modelsColumnIndex2 = 2;
 var defaultModelsColumnWidth = 32;
 var minimumModelsColumnWidth = 12;
+var compactModelsColumnGap = 2;
 function shouldUseColorByDefault() {
   if (process.env.NO_COLOR !== void 0) {
     return false;
@@ -1584,7 +1732,28 @@ function colorizeHeader(useColor) {
   if (!useColor) {
     return headerCells;
   }
-  return headerCells.map((header) => pc3.bold(pc3.white(header)));
+  return headerCells.map((header, index) => {
+    switch (index) {
+      case 1:
+        return pc3.bold(pc3.cyan(header));
+      case 2:
+        return pc3.bold(pc3.magenta(header));
+      case 3:
+      case 6:
+        return pc3.bold(pc3.blue(header));
+      case 4:
+      case 7:
+        return pc3.bold(pc3.cyan(header));
+      case 5:
+        return pc3.bold(pc3.magenta(header));
+      case 8:
+        return pc3.bold(pc3.green(header));
+      case 9:
+        return pc3.bold(pc3.yellow(header));
+      default:
+        return pc3.bold(pc3.white(header));
+    }
+  });
 }
 function isValidTerminalWidth(width) {
   return typeof width === "number" && Number.isFinite(width) && width > 0;
@@ -1598,12 +1767,119 @@ function resolveTerminalWidth(override) {
 function measureTableWidth(tableOutput) {
   return tableOutput.trimEnd().split("\n").reduce((maxWidth, line) => Math.max(maxWidth, visibleWidth(line)), 0);
 }
-function renderTableWithModelsWidth(rows, tableLayout, useColor, modelsColumnWidth) {
-  const uncoloredBodyRows = toUsageTableCells(rows, { layout: tableLayout });
-  const wrappedBodyRows = wrapTableColumn(uncoloredBodyRows, {
-    columnIndex: modelsColumnIndex,
+function padVisibleEnd(value, width) {
+  return `${value}${" ".repeat(Math.max(0, width - visibleWidth(value)))}`;
+}
+function formatCompactModelsCell(value, width) {
+  const modelLines = splitCellLines(value);
+  if (modelLines.length < 2) {
+    return value;
+  }
+  const longestLineWidth = modelLines.reduce(
+    (maxWidth, line) => Math.max(maxWidth, visibleWidth(line)),
+    0
+  );
+  const maxColumnCount = Math.floor(
+    (width + compactModelsColumnGap) / (longestLineWidth + compactModelsColumnGap)
+  );
+  if (maxColumnCount <= 1) {
+    return value;
+  }
+  const columnCount = Math.min(modelLines.length, maxColumnCount);
+  const rowCount = Math.ceil(modelLines.length / columnCount);
+  const compactLines = [];
+  for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+    const rowStart = rowIndex * columnCount;
+    const cells = modelLines.slice(rowStart, rowStart + columnCount);
+    compactLines.push(
+      cells.map(
+        (cell, columnIndex) => columnIndex === cells.length - 1 ? cell : padVisibleEnd(cell, longestLineWidth)
+      ).join(" ".repeat(compactModelsColumnGap))
+    );
+  }
+  return compactLines.join("\n");
+}
+function layoutModelsColumn(bodyRows, tableLayout, modelsColumnWidth) {
+  if (tableLayout !== "compact" || modelsColumnWidth <= defaultModelsColumnWidth) {
+    return bodyRows.map((row) => [...row]);
+  }
+  return bodyRows.map((row) => {
+    const nextRow = [...row];
+    nextRow[modelsColumnIndex2] = formatCompactModelsCell(
+      nextRow[modelsColumnIndex2],
+      modelsColumnWidth
+    );
+    return nextRow;
+  });
+}
+function prepareWrappedBodyRows(bodyRows, tableLayout, modelsColumnWidth) {
+  const laidOutRows = layoutModelsColumn(bodyRows, tableLayout, modelsColumnWidth);
+  return wrapTableColumn(laidOutRows, {
+    columnIndex: modelsColumnIndex2,
     width: modelsColumnWidth
   });
+}
+function measureCompactBodyHeight(bodyRows, modelsColumnWidth) {
+  return prepareWrappedBodyRows(bodyRows, "compact", modelsColumnWidth).reduce(
+    (totalHeight, row) => totalHeight + splitCellLines(row[modelsColumnIndex2] ?? "").length,
+    0
+  );
+}
+function resolveExpandedModelsColumnWidth(bodyRows, tableLayout, currentWidth, maximumWidth) {
+  if (maximumWidth <= currentWidth) {
+    return currentWidth;
+  }
+  if (tableLayout === "per_model_columns") {
+    const longestModelLineWidth = bodyRows.reduce((maxWidth, row) => {
+      const cellMaxWidth = splitCellLines(row[modelsColumnIndex2] ?? "").reduce(
+        (lineMaxWidth, line) => Math.max(lineMaxWidth, visibleWidth(line)),
+        0
+      );
+      return Math.max(maxWidth, cellMaxWidth);
+    }, currentWidth);
+    const preferredWidth = Math.max(
+      currentWidth,
+      defaultModelsColumnWidth + 16,
+      longestModelLineWidth
+    );
+    return Math.min(maximumWidth, preferredWidth);
+  }
+  const candidateWidths = /* @__PURE__ */ new Set([currentWidth]);
+  for (const row of bodyRows) {
+    const modelLines = splitCellLines(row[modelsColumnIndex2] ?? "");
+    const longestLineWidth = modelLines.reduce(
+      (maxLineWidth, line) => Math.max(maxLineWidth, visibleWidth(line)),
+      0
+    );
+    if (longestLineWidth > currentWidth && longestLineWidth <= maximumWidth) {
+      candidateWidths.add(longestLineWidth);
+    }
+    if (modelLines.length < 2) {
+      continue;
+    }
+    for (let columnCount = 2; columnCount <= modelLines.length; columnCount += 1) {
+      const candidateWidth = columnCount * longestLineWidth + (columnCount - 1) * compactModelsColumnGap;
+      if (candidateWidth > maximumWidth) {
+        break;
+      }
+      if (candidateWidth > currentWidth) {
+        candidateWidths.add(candidateWidth);
+      }
+    }
+  }
+  let bestWidth = currentWidth;
+  let bestHeight = measureCompactBodyHeight(bodyRows, currentWidth);
+  for (const candidateWidth of Array.from(candidateWidths).sort((left, right) => left - right)) {
+    const candidateHeight = measureCompactBodyHeight(bodyRows, candidateWidth);
+    if (candidateHeight < bestHeight) {
+      bestHeight = candidateHeight;
+      bestWidth = candidateWidth;
+    }
+  }
+  return bestWidth;
+}
+function renderTableWithModelsWidth(rows, uncoloredBodyRows, tableLayout, useColor, modelsColumnWidth) {
+  const wrappedBodyRows = prepareWrappedBodyRows(uncoloredBodyRows, tableLayout, modelsColumnWidth);
   const bodyRows = colorizeUsageBodyRows(wrappedBodyRows, rows, { useColor });
   const rowMetas = rows.map((row) => ({
     periodKey: row.periodKey,
@@ -1617,7 +1893,7 @@ function renderTableWithModelsWidth(rows, tableLayout, useColor, modelsColumnWid
     measureBodyRows: wrappedBodyRows,
     rowMetas,
     layout: tableLayout === "per_model_columns" ? "top_aligned" : "compact",
-    multilineColumnIndex: modelsColumnIndex,
+    multilineColumnIndex: modelsColumnIndex2,
     multilineColumnWidth: modelsColumnWidth
   });
 }
@@ -1626,8 +1902,15 @@ function renderTerminalTable(rows, options = {}) {
   const tableLayout = options.tableLayout ?? "compact";
   const hasExplicitTerminalWidth = isValidTerminalWidth(options.terminalWidth);
   const terminalWidth = resolveTerminalWidth(options.terminalWidth);
+  const uncoloredBodyRows = toUsageTableCells(rows, { layout: tableLayout });
   let modelsColumnWidth = defaultModelsColumnWidth;
-  let renderedTable = renderTableWithModelsWidth(rows, tableLayout, useColor, modelsColumnWidth);
+  let renderedTable = renderTableWithModelsWidth(
+    rows,
+    uncoloredBodyRows,
+    tableLayout,
+    useColor,
+    modelsColumnWidth
+  );
   if (terminalWidth !== void 0) {
     let renderedTableWidth = measureTableWidth(renderedTable);
     while (renderedTableWidth > terminalWidth && modelsColumnWidth > minimumModelsColumnWidth) {
@@ -1640,9 +1923,35 @@ function renderTerminalTable(rows, options = {}) {
         break;
       }
       modelsColumnWidth = nextModelsColumnWidth;
-      renderedTable = renderTableWithModelsWidth(rows, tableLayout, useColor, modelsColumnWidth);
+      renderedTable = renderTableWithModelsWidth(
+        rows,
+        uncoloredBodyRows,
+        tableLayout,
+        useColor,
+        modelsColumnWidth
+      );
       renderedTableWidth = measureTableWidth(renderedTable);
     }
+    if (renderedTableWidth < terminalWidth) {
+      const maximumWidth = modelsColumnWidth + (terminalWidth - renderedTableWidth);
+      const expandedWidth = resolveExpandedModelsColumnWidth(
+        uncoloredBodyRows,
+        tableLayout,
+        modelsColumnWidth,
+        maximumWidth
+      );
+      if (expandedWidth > modelsColumnWidth) {
+        modelsColumnWidth = expandedWidth;
+        renderedTable = renderTableWithModelsWidth(
+          rows,
+          uncoloredBodyRows,
+          tableLayout,
+          useColor,
+          modelsColumnWidth
+        );
+        renderedTableWidth = measureTableWidth(renderedTable);
+      }
+    }
     if (hasExplicitTerminalWidth && renderedTableWidth > terminalWidth) {
       throw new Error(
         `Configured terminal width (${terminalWidth}) is too narrow for table rendering (minimum ${renderedTableWidth}).`
@@ -1653,7 +1962,7 @@ function renderTerminalTable(rows, options = {}) {
 }
 
 // src/render/render-efficiency-report.ts
-var periodColumnIndex = 0;
+var periodColumnIndex2 = 0;
 var minimumEfficiencyColumnWidth = 1;
 var commitsColumnIndex = 1;
 var linesAddedColumnIndex = 2;
@@ -1793,8 +2102,8 @@ function styleEfficiencyTerminalRows(rows, bodyRows, options) {
     }
     const row = rows[rowIndex];
     const styledCells = [...cells];
-    const periodCell = styledCells[periodColumnIndex];
-    styledCells[periodColumnIndex] = row.rowType === "grand_total" ? pc4.bold(pc4.cyan(periodCell)) : pc4.bold(periodCell);
+    const periodCell = styledCells[periodColumnIndex2];
+    styledCells[periodColumnIndex2] = row.rowType === "grand_total" ? pc4.bold(pc4.cyan(periodCell)) : pc4.bold(periodCell);
     styledCells[commitsColumnIndex] = pc4.bold(styledCells[commitsColumnIndex]);
     styledCells[linesAddedColumnIndex] = styleDeltaCell(
       row.linesAdded,
@@ -1844,13 +2153,10 @@ function renderTerminalEfficiencyTable(rows, options) {
     measureBodyRows: fittedCells.bodyRows,
     rowMetas,
     layout: "compact",
-    multilineColumnIndex: periodColumnIndex,
-    multilineColumnWidth: fittedCells.widths[periodColumnIndex] ?? efficiencyTableHeaders[periodColumnIndex].length
+    multilineColumnIndex: periodColumnIndex2,
+    multilineColumnWidth: fittedCells.widths[periodColumnIndex2] ?? efficiencyTableHeaders[periodColumnIndex2].length
   });
 }
-function toMarkdownSafeCell(value) {
-  return value.replace(/\r?\n/gu, "<br>");
-}
 function renderMarkdownEfficiencyTable(rows) {
   const bodyRows = toEfficiencyTableCells(rows).map(
     (row) => row.map((cell) => toMarkdownSafeCell(cell))
@@ -1908,52 +2214,6 @@ var logger = {
   }
 };
 
-// src/domain/normalization.ts
-function normalizeNonNegativeInteger(value) {
-  if (value === null || value === void 0) {
-    return 0;
-  }
-  const parsed = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(parsed)) {
-    return 0;
-  }
-  return Math.max(0, Math.trunc(parsed));
-}
-function normalizeUsdCost(value) {
-  if (value === null || value === void 0) {
-    return void 0;
-  }
-  if (typeof value === "string" && value.trim() === "") {
-    return void 0;
-  }
-  const parsed = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(parsed)) {
-    return void 0;
-  }
-  return Math.max(0, parsed);
-}
-function normalizeTimestamp(value) {
-  const date = value instanceof Date ? value : new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    throw new Error(`Invalid timestamp: ${String(value)}`);
-  }
-  return date.toISOString();
-}
-function normalizeModelList(models) {
-  const deduplicated = /* @__PURE__ */ new Set();
-  for (const model of models) {
-    if (!model) {
-      continue;
-    }
-    const normalized = model.trim();
-    if (!normalized) {
-      continue;
-    }
-    deduplicated.add(normalized);
-  }
-  return [...deduplicated].sort(compareByCodePoint);
-}
-
 // src/utils/time-buckets.ts
 var formatterCache = /* @__PURE__ */ new Map();
 function getDateFormatter(timezone) {
@@ -2138,15 +2398,29 @@ function mergeModelTotals(targetModelTotals, sourceModelTotals) {
     targetModelTotals.set(model, targetTotals);
   }
 }
-function toModelUsageBreakdown(modelTotals) {
-  const sortedModels = normalizeModelList(modelTotals.keys());
-  return sortedModels.map((model) => {
-    const totals = modelTotals.get(model) ?? createEmptyTotals();
-    return {
-      model,
-      ...totals
-    };
-  });
+function compareModelUsageBreakdown(left, right) {
+  if (left.totalTokens !== right.totalTokens) {
+    return right.totalTokens - left.totalTokens;
+  }
+  const leftCost = left.costUsd ?? Number.NEGATIVE_INFINITY;
+  const rightCost = right.costUsd ?? Number.NEGATIVE_INFINITY;
+  if (leftCost !== rightCost) {
+    return rightCost - leftCost;
+  }
+  if (left.inputTokens !== right.inputTokens) {
+    return right.inputTokens - left.inputTokens;
+  }
+  return compareByCodePoint(left.model, right.model);
+}
+function toRankedModelUsage(modelTotals) {
+  const modelBreakdown = [...modelTotals.entries()].map(([model, totals]) => ({
+    model,
+    ...totals
+  })).sort(compareModelUsageBreakdown);
+  return {
+    models: modelBreakdown.map((modelUsage) => modelUsage.model),
+    modelBreakdown
+  };
 }
 function sourceSortComparator(left, right, sourceWeightMap) {
   const leftWeight = sourceWeightMap.get(left) ?? Number.MAX_SAFE_INTEGER;
@@ -2190,12 +2464,13 @@ function aggregateUsage(events, options) {
       if (!accumulator) {
         continue;
       }
+      const rankedModelUsage = includeModelBreakdown && accumulator.modelTotals ? toRankedModelUsage(accumulator.modelTotals) : { models: [], modelBreakdown: [] };
       const sourceRow = {
         rowType: "period_source",
         periodKey,
         source,
-        models: includeModelBreakdown && accumulator.modelTotals ? normalizeModelList(accumulator.modelTotals.keys()) : [],
-        modelBreakdown: includeModelBreakdown && accumulator.modelTotals ? toModelUsageBreakdown(accumulator.modelTotals) : [],
+        models: rankedModelUsage.models,
+        modelBreakdown: rankedModelUsage.modelBreakdown,
         ...accumulator.totals
       };
       rows.push(sourceRow);
@@ -2207,24 +2482,26 @@ function aggregateUsage(events, options) {
       }
     }
     if (sortedSources.length > 1) {
+      const rankedCombinedModels = includeModelBreakdown ? toRankedModelUsage(periodCombinedModelTotals) : { models: [], modelBreakdown: [] };
       const combinedRow = {
         rowType: "period_combined",
         periodKey,
         source: "combined",
-        models: includeModelBreakdown ? normalizeModelList(periodCombinedModelTotals.keys()) : [],
-        modelBreakdown: includeModelBreakdown ? toModelUsageBreakdown(periodCombinedModelTotals) : [],
+        models: rankedCombinedModels.models,
+        modelBreakdown: rankedCombinedModels.modelBreakdown,
         ...periodCombinedTotals
       };
       rows.push(combinedRow);
     }
   }
   const finalizedGrandTotals = events.length === 0 && grandTotals.costUsd === void 0 && grandTotals.costIncomplete !== true ? { ...grandTotals, costUsd: 0 } : grandTotals;
+  const rankedGrandModels = includeModelBreakdown ? toRankedModelUsage(grandModelTotals) : { models: [], modelBreakdown: [] };
   const grandTotalRow = {
     rowType: "grand_total",
     periodKey: "ALL",
     source: "combined",
-    models: includeModelBreakdown ? normalizeModelList(grandModelTotals.keys()) : [],
-    modelBreakdown: includeModelBreakdown ? toModelUsageBreakdown(grandModelTotals) : [],
+    models: rankedGrandModels.models,
+    modelBreakdown: rankedGrandModels.modelBreakdown,
     ...finalizedGrandTotals
   };
   rows.push(grandTotalRow);
@@ -2858,6 +3135,38 @@ async function attributeUsageEventsToRepo(events, repoDir, resolveRepoRoot3 = re
   };
 }
 
+// src/domain/normalization.ts
+function normalizeNonNegativeInteger(value) {
+  if (value === null || value === void 0) {
+    return 0;
+  }
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) {
+    return 0;
+  }
+  return Math.max(0, Math.trunc(parsed));
+}
+function normalizeUsdCost(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return void 0;
+  }
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  return Math.max(0, parsed);
+}
+function normalizeTimestamp(value) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid timestamp: ${String(value)}`);
+  }
+  return date.toISOString();
+}
+
 // src/domain/provider-normalization.ts
 var billingProviderAliases = /* @__PURE__ */ new Map([
   ["openai-codex", "openai"],
@@ -7529,9 +7838,6 @@ function toTableCells(optimizeData, options) {
     return options.includeNotesColumn ? [...candidateCells, styleNotesCell(row.notes, notesCell, options.useColor)] : candidateCells;
   });
 }
-function toMarkdownSafeCell2(value) {
-  return value.replace(/\r?\n/gu, "<br>");
-}
 function toTableRowMeta2(row) {
   return {
     periodKey: row.periodKey,
@@ -7587,7 +7893,7 @@ function renderMarkdownOptimizeReport(optimizeData) {
   const bodyRows = toTableCells(optimizeData, {
     useColor: false,
     includeNotesColumn
-  }).map((row) => row.map((cell) => toMarkdownSafeCell2(cell)));
+  }).map((row) => row.map((cell) => toMarkdownSafeCell(cell)));
   const tableRows = [headerCells, ...bodyRows];
   const alignment2 = headerCells.map((_, index) => index <= 1 ? "l" : "r");
   return markdownTable2(tableRows, { align: alignment2 });
@@ -8916,13 +9222,59 @@ async function buildUsageData(granularity, options, deps = {}) {
 // src/render/markdown-table.ts
 import { markdownTable as markdownTable3 } from "markdown-table";
 var alignment = ["l", "l", "l", "r", "r", "r", "r", "r", "r", "r"];
-function toMarkdownSafeCell3(value) {
-  return value.replace(/\r?\n/gu, "<br>");
+function boldMarkdownText(value) {
+  const safeValue = toMarkdownSafeCell(value);
+  return safeValue.length === 0 ? safeValue : `**${safeValue}**`;
+}
+function emphasizeMarkdownModelsCell(value) {
+  const lines = splitCellLines(value);
+  return lines.map((line, index) => {
+    if (line.length === 0) {
+      return "";
+    }
+    if (line === "\u03A3 TOTAL") {
+      return boldMarkdownText(line);
+    }
+    if (index === 0 && lines.length > 1) {
+      return boldMarkdownText(line);
+    }
+    return toMarkdownSafeCell(line);
+  }).join("<br>");
+}
+function emphasizeMarkdownSummaryMetricCell(value) {
+  const lines = splitCellLines(value);
+  if (lines.length <= 1) {
+    return boldMarkdownText(value);
+  }
+  return lines.map(
+    (line, index) => index === lines.length - 1 ? boldMarkdownText(line) : toMarkdownSafeCell(line)
+  ).join("<br>");
+}
+function emphasizeMarkdownRow(row, cells) {
+  const styledCells = cells.map((cell) => toMarkdownSafeCell(cell));
+  if (styledCells.length > 2) {
+    styledCells[2] = emphasizeMarkdownModelsCell(cells[2]);
+  }
+  if (row.rowType !== "period_source") {
+    if (styledCells.length > 1) {
+      styledCells[1] = boldMarkdownText(cells[1]);
+    }
+    if (styledCells.length > 8) {
+      styledCells[8] = emphasizeMarkdownSummaryMetricCell(cells[8]);
+    }
+    if (styledCells.length > 9) {
+      styledCells[9] = emphasizeMarkdownSummaryMetricCell(cells[9]);
+    }
+  }
+  if (row.rowType === "grand_total" && styledCells.length > 0) {
+    styledCells[0] = boldMarkdownText(cells[0]);
+  }
+  return styledCells;
 }
 function renderMarkdownTable(rows, options = {}) {
   const tableLayout = options.tableLayout ?? "compact";
   const bodyRows = toUsageTableCells(rows, { layout: tableLayout }).map(
-    (row) => row.map((cell) => toMarkdownSafeCell3(cell))
+    (cells, index) => emphasizeMarkdownRow(rows[index], cells)
   );
   const tableRows = [Array.from(usageTableHeaders), ...bodyRows];
   return markdownTable3(tableRows, {