llm-usage-metrics 0.5.2 → 0.7.0

package/dist/index.js

@@ -694,7 +694,8 @@ var knownSourceColors = {
   codex: "#22c55e",
   gemini: "#eab308",
   droid: "#3b82f6",
-  opencode: "#a855f7"
+  opencode: "#a855f7",
+  claude: "#d97757"
 };
 var fallbackColors = ["#f97316", "#06b6d4", "#ef4444", "#84cc16", "#f43f5e"];
 function getSourceColor(source, index) {
@@ -889,9 +890,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 +1063,36 @@ 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 escapeHtmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeMarkdownText(value) {
+  const escapedMarkdownText = escapeHtmlText(value).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,13 +1215,70 @@ 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],
-  ["opencode", (palette) => palette.blue]
+  ["gemini", (palette) => palette.yellow],
+  ["droid", (palette) => palette.green],
+  ["opencode", (palette) => palette.blue],
+  ["claude", (palette) => palette.cyan]
 ]);
 function resolveSourceStyler(source, palette = defaultTerminalStylePalette) {
   const stylePolicy = sourceStylePolicies.get(source);
@@ -1203,28 +1287,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))
+      );
+    }
+    if (sourceColumnIndex < styledCells.length) {
+      styledCells[sourceColumnIndex] = styleCellLines(
+        cells[sourceColumnIndex],
+        (line) => palette.bold(palette.green(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 (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 (totalColumnIndex < styledCells.length) {
+      styledCells[totalColumnIndex] = styleCellLines(
+        cells[totalColumnIndex],
+        (line) => palette.bold(palette.green(line))
+      );
     }
-    if (cellIndex === 1) {
-      return styleCellLines(cell, (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 +1398,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 +1503,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 +1561,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 +1721,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 +1740,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 +1775,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 +1901,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 +1910,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 +1931,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 +1970,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 +2110,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 +2161,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 +2222,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 +2406,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 +2472,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 +2490,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 +3143,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"],
@@ -3122,7 +3439,7 @@ function formatEnvVarOverrides(overrides) {
   return lines;
 }
 
-// src/sources/codex/codex-source-adapter.ts
+// src/sources/claude/claude-source-adapter.ts
 import os2 from "os";
 import path6 from "path";
 
@@ -3257,11 +3574,6 @@ async function discoverFiles(rootDir, options) {
   return toCanonicalFiles(files, resolvedOptions);
 }
 
-// src/utils/discover-jsonl-files.ts
-async function discoverJsonlFiles(rootDir) {
-  return discoverFiles(rootDir, { extension: ".jsonl" });
-}
-
 // src/utils/fs-helpers.ts
 import { access as access2, constants as constants2, stat as stat3 } from "fs/promises";
 async function pathExists(filePath) {
@@ -3343,6 +3655,22 @@ async function* readJsonlObjects(filePath, options = {}) {
   }
 }
 
+// src/sources/parse-diagnostics.ts
+function incrementSkippedReason(reasons, reason) {
+  const current = reasons.get(reason) ?? 0;
+  reasons.set(reason, current + 1);
+}
+function toSkippedRowReasonStats(reasons) {
+  return [...reasons.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right) => compareByCodePoint(left.reason, right.reason));
+}
+function toParseDiagnostics(events, skippedRows, skippedRowReasons) {
+  return {
+    events,
+    skippedRows,
+    skippedRowReasons: toSkippedRowReasonStats(skippedRowReasons)
+  };
+}
+
 // src/sources/parsing-utils.ts
 var MIN_PLAUSIBLE_UNIX_SECONDS_ABS = 1e8;
 var UNIX_SECONDS_ABS_CUTOFF = 1e10;
@@ -3395,8 +3723,180 @@ function normalizeTimestampCandidate(candidate) {
   return date.toISOString();
 }
 
+// src/sources/claude/claude-source-adapter.ts
+var defaultClaudeProjectsDir = path6.join(os2.homedir(), ".claude", "projects");
+var CLAUDE_ASSISTANT_LINE_PATTERN = /"type"\s*:\s*"assistant"/u;
+var CLAUDE_USAGE_LINE_PATTERN = /"usage"\s*:/u;
+function shouldParseClaudeJsonlLine(lineText) {
+  return CLAUDE_ASSISTANT_LINE_PATTERN.test(lineText) && CLAUDE_USAGE_LINE_PATTERN.test(lineText);
+}
+function getFallbackSessionId(filePath) {
+  return path6.basename(filePath, ".jsonl");
+}
+function resolveProvider(message, model) {
+  const explicitProvider = asTrimmedText(message.provider);
+  if (explicitProvider) {
+    return explicitProvider;
+  }
+  if (model?.toLowerCase().startsWith("claude-")) {
+    return "anthropic";
+  }
+  return void 0;
+}
+function parseUsage(usage) {
+  const inputTokens = normalizeNonNegativeInteger(toNumberLike(usage.input_tokens));
+  const outputTokens = normalizeNonNegativeInteger(toNumberLike(usage.output_tokens));
+  const cacheReadTokens = normalizeNonNegativeInteger(toNumberLike(usage.cache_read_input_tokens));
+  const cacheWriteTokens = normalizeNonNegativeInteger(
+    toNumberLike(usage.cache_creation_input_tokens)
+  );
+  const totalTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+  if (totalTokens === 0) {
+    return void 0;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    reasoningTokens: 0,
+    cacheReadTokens,
+    cacheWriteTokens,
+    totalTokens
+  };
+}
+function createDedupKey(filePath, line, message) {
+  const messageId = asTrimmedText(message.id);
+  if (messageId) {
+    return `${filePath}\0${messageId}`;
+  }
+  const uuid = asTrimmedText(line.uuid);
+  return uuid ? `${filePath}\0${uuid}` : void 0;
+}
+function comparePendingEvents(left, right) {
+  if (left.timestamp !== right.timestamp) {
+    return compareByCodePoint(left.timestamp, right.timestamp);
+  }
+  return left.sequence - right.sequence;
+}
+var ClaudeSourceAdapter = class {
+  id = "claude";
+  projectsDir;
+  requireProjectsDir;
+  constructor(options = {}) {
+    this.projectsDir = options.projectsDir ?? defaultClaudeProjectsDir;
+    this.requireProjectsDir = options.requireProjectsDir ?? false;
+  }
+  getNormalizedProjectsDir() {
+    if (isBlankText(this.projectsDir)) {
+      throw new Error("Claude projects directory must be a non-empty path");
+    }
+    return this.projectsDir.trim();
+  }
+  async discoverFiles() {
+    const normalizedProjectsDir = this.getNormalizedProjectsDir();
+    if (this.requireProjectsDir && !await pathReadable(normalizedProjectsDir)) {
+      throw new Error(
+        `Claude projects directory is missing or unreadable: ${normalizedProjectsDir}`
+      );
+    }
+    if (this.requireProjectsDir && !await pathIsDirectory(normalizedProjectsDir)) {
+      throw new Error(`Claude projects directory is not a directory: ${normalizedProjectsDir}`);
+    }
+    return discoverFiles(normalizedProjectsDir, { extension: ".jsonl" });
+  }
+  async parseFile(filePath) {
+    const { events } = await this.parseFileWithDiagnostics(filePath);
+    return events;
+  }
+  async parseFileWithDiagnostics(filePath) {
+    const eventsByDedupKey = /* @__PURE__ */ new Map();
+    let skippedRows = 0;
+    let sequence = 0;
+    const skippedRowReasons = /* @__PURE__ */ new Map();
+    for await (const line of readJsonlObjects(filePath, {
+      shouldParseLine: shouldParseClaudeJsonlLine
+    })) {
+      if (asTrimmedText(line.type) !== "assistant") {
+        continue;
+      }
+      const message = asRecord(line.message);
+      if (!message || asTrimmedText(message.role) !== "assistant") {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "invalid_assistant_message");
+        continue;
+      }
+      const model = asTrimmedText(message.model);
+      if (model === "<synthetic>") {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "synthetic_message");
+        continue;
+      }
+      const usage = parseUsage(asRecord(message.usage) ?? {});
+      if (!usage) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "no_token_usage");
+        continue;
+      }
+      const timestamp = normalizeTimestampCandidate(line.timestamp);
+      if (!timestamp) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
+        continue;
+      }
+      const dedupKey = createDedupKey(filePath, line, message);
+      if (!dedupKey) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "missing_message_id");
+        continue;
+      }
+      const sessionId = asTrimmedText(line.sessionId) ?? getFallbackSessionId(filePath);
+      const repoRoot = asTrimmedText(line.cwd);
+      const provider = resolveProvider(message, model);
+      sequence += 1;
+      eventsByDedupKey.set(dedupKey, {
+        sessionId,
+        timestamp,
+        repoRoot,
+        provider,
+        model,
+        usage,
+        sequence
+      });
+    }
+    const events = [];
+    for (const pendingEvent of [...eventsByDedupKey.values()].sort(comparePendingEvents)) {
+      try {
+        events.push(
+          createUsageEvent({
+            source: this.id,
+            sessionId: pendingEvent.sessionId,
+            timestamp: pendingEvent.timestamp,
+            repoRoot: pendingEvent.repoRoot,
+            provider: pendingEvent.provider,
+            model: pendingEvent.model,
+            ...pendingEvent.usage,
+            costMode: "estimated"
+          })
+        );
+      } catch {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "event_creation_failed");
+      }
+    }
+    return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+  }
+};
+
+// src/sources/codex/codex-source-adapter.ts
+import os3 from "os";
+import path7 from "path";
+
+// src/utils/discover-jsonl-files.ts
+async function discoverJsonlFiles(rootDir) {
+  return discoverFiles(rootDir, { extension: ".jsonl" });
+}
+
 // src/sources/codex/codex-source-adapter.ts
-var defaultSessionsDir = path6.join(os2.homedir(), ".codex", "sessions");
+var defaultSessionsDir = path7.join(os3.homedir(), ".codex", "sessions");
 var LEGACY_CODEX_MODEL_FALLBACK = "legacy-codex-unknown";
 var SESSION_META_LINE_PATTERN = /"type"\s*:\s*"session_meta"/u;
 var TURN_CONTEXT_LINE_PATTERN = /"type"\s*:\s*"turn_context"/u;
@@ -3490,8 +3990,8 @@ function createLastUsageOnlyKey(timestamp, usage) {
     usage.totalTokens
   ].join(":");
 }
-function getFallbackSessionId(filePath) {
-  return path6.basename(filePath, ".jsonl");
+function getFallbackSessionId2(filePath) {
+  return path7.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromPayload(payload) {
   if (!payload) {
@@ -3531,7 +4031,7 @@ var CodexSourceAdapter = class {
   async parseFile(filePath) {
     const events = [];
     const state = {
-      sessionId: getFallbackSessionId(filePath),
+      sessionId: getFallbackSessionId2(filePath),
       provider: "openai"
     };
     for await (const line of readJsonlObjects(filePath, {
@@ -3623,37 +4123,19 @@ var CodexSourceAdapter = class {
 
 // src/sources/droid/droid-source-adapter.ts
 import { readFile as readFile2 } from "fs/promises";
-import os3 from "os";
-import path7 from "path";
-
-// src/sources/parse-diagnostics.ts
-function incrementSkippedReason(reasons, reason) {
-  const current = reasons.get(reason) ?? 0;
-  reasons.set(reason, current + 1);
-}
-function toSkippedRowReasonStats(reasons) {
-  return [...reasons.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right) => compareByCodePoint(left.reason, right.reason));
-}
-function toParseDiagnostics(events, skippedRows, skippedRowReasons) {
-  return {
-    events,
-    skippedRows,
-    skippedRowReasons: toSkippedRowReasonStats(skippedRowReasons)
-  };
-}
-
-// src/sources/droid/droid-source-adapter.ts
-var defaultSessionsDir2 = path7.join(os3.homedir(), ".factory", "sessions");
+import os4 from "os";
+import path8 from "path";
+var defaultSessionsDir2 = path8.join(os4.homedir(), ".factory", "sessions");
 var DROID_SESSION_START_LINE_PATTERN = /"type"\s*:\s*"session_start"/u;
 var DROID_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 function shouldParseDroidJsonlLine(lineText) {
   return DROID_SESSION_START_LINE_PATTERN.test(lineText) || DROID_MESSAGE_LINE_PATTERN.test(lineText);
 }
 function getSettingsSessionId(filePath) {
-  return path7.basename(filePath, ".settings.json");
+  return path8.basename(filePath, ".settings.json");
 }
 function getSiblingJsonlPath(settingsPath) {
-  return path7.join(path7.dirname(settingsPath), `${getSettingsSessionId(settingsPath)}.jsonl`);
+  return path8.join(path8.dirname(settingsPath), `${getSettingsSessionId(settingsPath)}.jsonl`);
 }
 function isSessionStartRecord(line) {
   return asTrimmedText(line.type) === "session_start";
@@ -3797,11 +4279,11 @@ var DroidSourceAdapter = class {
 
 // src/sources/gemini/gemini-source-adapter.ts
 import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-import os4 from "os";
-import path8 from "path";
-var defaultGeminiDir = path8.join(os4.homedir(), ".gemini");
+import os5 from "os";
+import path9 from "path";
+var defaultGeminiDir = path9.join(os5.homedir(), ".gemini");
 function getProjectsJsonPath(geminiDir) {
-  return path8.join(geminiDir, "projects.json");
+  return path9.join(geminiDir, "projects.json");
 }
 function parseProjectsJson(data) {
   const mapping = /* @__PURE__ */ new Map();
@@ -3836,7 +4318,7 @@ async function loadProjectsJson(geminiDir) {
   }
 }
 async function discoverSessionFiles(geminiDir) {
-  const tmpDir = path8.join(geminiDir, "tmp");
+  const tmpDir = path9.join(geminiDir, "tmp");
   let projectEntries;
   try {
     projectEntries = await readdir2(tmpDir, { withFileTypes: true, encoding: "utf8" });
@@ -3853,7 +4335,7 @@ async function discoverSessionFiles(geminiDir) {
     if (!projectEntry.isDirectory() && !projectEntry.isSymbolicLink()) {
       continue;
     }
-    const chatsDir = path8.join(tmpDir, projectEntry.name, "chats");
+    const chatsDir = path9.join(tmpDir, projectEntry.name, "chats");
     const discoveredChatFiles = await discoverFiles(chatsDir, { extension: ".json" });
     allSessionFiles.push(...discoveredChatFiles);
   }
@@ -3867,9 +4349,9 @@ function resolveRepoRoot(filePath, sessionData, projectMapping) {
       return mappedRoot;
     }
   }
-  const chatsDir = path8.dirname(filePath);
-  const projectDir = path8.dirname(chatsDir);
-  const projectIdentifier = path8.basename(projectDir);
+  const chatsDir = path9.dirname(filePath);
+  const projectDir = path9.dirname(chatsDir);
+  const projectIdentifier = path9.basename(projectDir);
   return projectMapping.get(projectIdentifier);
 }
 function toFiniteNumber(value) {
@@ -3978,7 +4460,7 @@ var GeminiSourceAdapter = class {
       incrementSkippedReason(skippedRowReasons, "invalid_session_data");
       return toParseDiagnostics(events, skippedRows, skippedRowReasons);
     }
-    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path8.basename(filePath, ".json");
+    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path9.basename(filePath, ".json");
     const projectMapping = await this.getProjectMappingForParse();
     const repoRoot = resolveRepoRoot(filePath, sessionDataRecord, projectMapping);
     if (!Array.isArray(sessionDataRecord.messages)) {
@@ -4035,8 +4517,8 @@ var GeminiSourceAdapter = class {
 };
 
 // src/sources/opencode/opencode-db-path-resolver.ts
-import os5 from "os";
-import path9 from "path";
+import os6 from "os";
+import path10 from "path";
 function deduplicate(paths) {
   return [...new Set(paths)];
 }
@@ -4048,39 +4530,39 @@ function normalizeEnvPath(value) {
   return normalized || void 0;
 }
 function getLinuxLikeCandidates(homeDir, env) {
-  const xdgDataHome = normalizeEnvPath(env.XDG_DATA_HOME) ?? path9.join(homeDir, ".local", "share");
+  const xdgDataHome = normalizeEnvPath(env.XDG_DATA_HOME) ?? path10.join(homeDir, ".local", "share");
   return [
-    path9.join(xdgDataHome, "opencode", "opencode.db"),
-    path9.join(xdgDataHome, "opencode", "db.sqlite"),
-    path9.join(homeDir, ".opencode", "opencode.db"),
-    path9.join(homeDir, ".opencode", "db.sqlite")
+    path10.join(xdgDataHome, "opencode", "opencode.db"),
+    path10.join(xdgDataHome, "opencode", "db.sqlite"),
+    path10.join(homeDir, ".opencode", "opencode.db"),
+    path10.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getMacOsCandidates(homeDir) {
-  const appSupportDir = path9.join(homeDir, "Library", "Application Support");
+  const appSupportDir = path10.join(homeDir, "Library", "Application Support");
   return [
-    path9.join(appSupportDir, "opencode", "opencode.db"),
-    path9.join(appSupportDir, "opencode", "db.sqlite"),
-    path9.join(homeDir, ".opencode", "opencode.db"),
-    path9.join(homeDir, ".opencode", "db.sqlite")
+    path10.join(appSupportDir, "opencode", "opencode.db"),
+    path10.join(appSupportDir, "opencode", "db.sqlite"),
+    path10.join(homeDir, ".opencode", "opencode.db"),
+    path10.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getWindowsCandidates(homeDir, env) {
   const userProfile = normalizeEnvPath(env.USERPROFILE);
-  const roamingBase = normalizeEnvPath(env.APPDATA) ?? normalizeEnvPath(env.LOCALAPPDATA) ?? (userProfile ? path9.join(userProfile, "AppData", "Roaming") : void 0);
+  const roamingBase = normalizeEnvPath(env.APPDATA) ?? normalizeEnvPath(env.LOCALAPPDATA) ?? (userProfile ? path10.join(userProfile, "AppData", "Roaming") : void 0);
   const roamingCandidates = roamingBase ? [
-    path9.join(roamingBase, "opencode", "opencode.db"),
-    path9.join(roamingBase, "opencode", "db.sqlite")
+    path10.join(roamingBase, "opencode", "opencode.db"),
+    path10.join(roamingBase, "opencode", "db.sqlite")
   ] : [];
   return [
     ...roamingCandidates,
-    path9.join(homeDir, ".opencode", "opencode.db"),
-    path9.join(homeDir, ".opencode", "db.sqlite")
+    path10.join(homeDir, ".opencode", "opencode.db"),
+    path10.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getDefaultOpenCodeDbPathCandidates(options = {}) {
   const platform = options.platform ?? process.platform;
-  const homeDir = options.homeDir ?? os5.homedir();
+  const homeDir = options.homeDir ?? os6.homedir();
   const env = options.env ?? process.env;
   switch (platform) {
     case "win32":
@@ -4569,9 +5051,9 @@ var OpenCodeSourceAdapter = class {
 };
 
 // src/sources/pi/pi-source-adapter.ts
-import os6 from "os";
-import path10 from "path";
-var defaultSessionsDir3 = path10.join(os6.homedir(), ".pi", "agent", "sessions");
+import os7 from "os";
+import path11 from "path";
+var defaultSessionsDir3 = path11.join(os7.homedir(), ".pi", "agent", "sessions");
 var PI_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 var PI_SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
 var PI_MODEL_CHANGE_LINE_PATTERN = /"type"\s*:\s*"model_change"/u;
@@ -4644,8 +5126,8 @@ function extractUsage(line, message) {
   }
   return extractUsageFromRecord(messageUsage);
 }
-function getFallbackSessionId2(filePath) {
-  return path10.basename(filePath, ".jsonl");
+function getFallbackSessionId3(filePath) {
+  return path11.basename(filePath, ".jsonl");
 }
 function resolveRepoRootFromRecord(record) {
   if (!record) {
@@ -4677,7 +5159,7 @@ var PiSourceAdapter = class {
   }
   async parseFile(filePath) {
     const events = [];
-    const state = { sessionId: getFallbackSessionId2(filePath) };
+    const state = { sessionId: getFallbackSessionId3(filePath) };
     for await (const line of readJsonlObjects(filePath, {
       shouldParseLine: shouldParsePiJsonlLine
     })) {
@@ -4816,6 +5298,21 @@ var sourceRegistrations = [
     create: (options) => new OpenCodeSourceAdapter({
       dbPath: options.opencodeDb
     })
+  },
+  {
+    id: "claude",
+    sourceDirOverride: { kind: "directory" },
+    create: (options, sourceDirectoryOverrides) => {
+      const directoryConfig = resolveDirectoryConfig(
+        "claude",
+        options.claudeDir,
+        sourceDirectoryOverrides
+      );
+      return new ClaudeSourceAdapter({
+        projectsDir: directoryConfig.path,
+        requireProjectsDir: directoryConfig.requireExistingPath
+      });
+    }
   }
 ];
 var sourceDirUnsupportedFlags = new Map(
@@ -4892,6 +5389,7 @@ function createDefaultAdapters(options) {
   validateDirectoryOverride("--codex-dir", options.codexDir);
   validateDirectoryOverride("--gemini-dir", options.geminiDir);
   validateDirectoryOverride("--droid-dir", options.droidDir);
+  validateDirectoryOverride("--claude-dir", options.claudeDir);
   const sourceDirectoryOverrides = parseSourceDirectoryOverrides(options.sourceDir);
   validateSourceDirectoryOverrideIds(sourceDirectoryOverrides);
   return sourceRegistrations.map((source) => source.create(options, sourceDirectoryOverrides));
@@ -5007,6 +5505,9 @@ function resolveExplicitSourceIds(options, sourceFilter) {
   if (options.droidDir) {
     explicitSourceIds.add("droid");
   }
+  if (options.claudeDir) {
+    explicitSourceIds.add("claude");
+  }
   if (options.opencodeDb) {
     explicitSourceIds.add("opencode");
   }
@@ -5135,7 +5636,7 @@ function normalizeSkippedRowReasons(value) {
 
 // src/cli/parse-file-cache.ts
 import { mkdir as mkdir2, readFile as readFile4, rename, rm, stat as stat4, writeFile as writeFile2 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 var PARSE_FILE_CACHE_VERSION = 5;
 var CACHE_KEY_SEPARATOR = "\0";
 function createCacheKey(source, filePath) {
@@ -5362,7 +5863,7 @@ function normalizeCacheEntry(value) {
   };
 }
 function getDefaultParseFileCachePath() {
-  return path11.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
+  return path12.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
 }
 function normalizeCacheShardSource(source) {
   const normalizedSource = normalizeCacheSource(source);
@@ -5372,12 +5873,12 @@ function normalizeCacheShardSource(source) {
   return normalizedSource.replace(/[^a-z0-9._-]/gu, "_");
 }
 function getSourceShardedParseFileCachePath(cacheFilePath, source) {
-  const parsedPath = path11.parse(cacheFilePath);
+  const parsedPath = path12.parse(cacheFilePath);
   const sourceShard = normalizeCacheShardSource(source);
   if (parsedPath.ext.length > 0) {
-    return path11.join(parsedPath.dir, `${parsedPath.name}.${sourceShard}${parsedPath.ext}`);
+    return path12.join(parsedPath.dir, `${parsedPath.name}.${sourceShard}${parsedPath.ext}`);
   }
-  return path11.join(parsedPath.dir, `${parsedPath.base}.${sourceShard}`);
+  return path12.join(parsedPath.dir, `${parsedPath.base}.${sourceShard}`);
 }
 var ParseFileCache = class _ParseFileCache {
   constructor(cacheFilePath, limits, now) {
@@ -5385,6 +5886,9 @@ var ParseFileCache = class _ParseFileCache {
     this.limits = limits;
     this.now = now;
   }
+  cacheFilePath;
+  limits;
+  now;
   entriesByKey = /* @__PURE__ */ new Map();
   dirty = false;
   static async load(options) {
@@ -5471,7 +5975,7 @@ var ParseFileCache = class _ParseFileCache {
       keptEntries.length = bestCount;
       payloadText = bestPayloadText;
     }
-    await mkdir2(path11.dirname(this.cacheFilePath), { recursive: true });
+    await mkdir2(path12.dirname(this.cacheFilePath), { recursive: true });
     const temporaryPath = `${this.cacheFilePath}.${process.pid}.${this.now()}.tmp`;
     try {
       await writeFile2(temporaryPath, payloadText, "utf8");
@@ -5960,7 +6464,7 @@ function applyPricingToEvents(events, pricingSource) {
 
 // src/pricing/litellm-pricing-fetcher.ts
 import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 
 // src/pricing/litellm-model-map.json
 var litellm_model_map_default = {
@@ -6144,7 +6648,7 @@ function normalizeLitellmPricingPayload(payload) {
   return normalizedPricing;
 }
 function getDefaultLiteLLMPricingCachePath() {
-  return path12.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
+  return path13.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
 }
 function stripProviderPrefix(model) {
   const slashIndex = model.lastIndexOf("/");
@@ -6538,7 +7042,7 @@ var LiteLLMPricingFetcher = class {
     };
   }
   async writeCache() {
-    const directoryPath = path12.dirname(this.cacheFilePath);
+    const directoryPath = path13.dirname(this.cacheFilePath);
     await mkdir3(directoryPath, { recursive: true });
     const payload = {
       fetchedAt: this.now(),
@@ -6649,6 +7153,7 @@ var RuntimeProfileCollector = class {
   constructor(now = () => performance.now()) {
     this.now = now;
   }
+  now;
   sourceSelection;
   sourceStats = /* @__PURE__ */ new Map();
   stageDurations = /* @__PURE__ */ new Map();
@@ -6942,6 +7447,9 @@ function resolveScopeNote(options) {
   if (hasActiveTextOption(options.droidDir)) {
     activeFilters.push("--droid-dir");
   }
+  if (hasActiveTextOption(options.claudeDir)) {
+    activeFilters.push("--claude-dir");
+  }
   if (hasActiveTextOption(options.opencodeDb)) {
     activeFilters.push("--opencode-db");
   }
@@ -7127,10 +7635,11 @@ function emitEnvVarOverrides(activeEnvOverrides, diagnosticsLogger) {
 
 // src/cli/share-artifact.ts
 import { spawn as spawn4 } from "child_process";
-import { writeFile as writeFile4 } from "fs/promises";
-import path13 from "path";
+import { constants as constants3 } from "fs";
+import { access as access3, writeFile as writeFile4 } from "fs/promises";
+import path14 from "path";
 async function writeShareSvgFile(fileName, svgContent) {
-  const outputPath = path13.resolve(process.cwd(), fileName);
+  const outputPath = path14.resolve(process.cwd(), fileName);
   await writeFile4(outputPath, svgContent, "utf8");
   return outputPath;
 }
@@ -7140,21 +7649,68 @@ function stringifyError(error) {
   }
   return String(error);
 }
-function resolveOpenCommand(filePath, platform) {
+var WINDOWS_OPEN_COMMAND = "C:\\Windows\\System32\\rundll32.exe";
+var DARWIN_OPEN_COMMAND = "/usr/bin/open";
+var UNIX_OPEN_COMMAND = "/usr/bin/xdg-open";
+var WINDOWS_FALLBACK_COMMANDS = ["rundll32.exe"];
+var DARWIN_FALLBACK_COMMANDS = ["open"];
+var UNIX_FALLBACK_COMMANDS = ["xdg-open"];
+async function fileExists(filePath) {
+  try {
+    await access3(filePath, constants3.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveBinaryPath(primaryPath, fallbackNames) {
+  if (await fileExists(primaryPath)) {
+    return primaryPath;
+  }
+  const pathDirs = (process.env.PATH ?? "").split(path14.delimiter).filter(Boolean);
+  for (const fallbackName of fallbackNames) {
+    for (const dir of pathDirs) {
+      const candidate = path14.join(dir, fallbackName);
+      if (await fileExists(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+async function resolveOpenCommand(filePath, platform) {
   if (platform === "win32") {
+    const resolvedPath2 = await resolveBinaryPath(WINDOWS_OPEN_COMMAND, WINDOWS_FALLBACK_COMMANDS);
+    if (!resolvedPath2) {
+      throw new Error(
+        "Could not find rundll32.exe. Please ensure Windows System32 is accessible or rundll32.exe is available on PATH."
+      );
+    }
     return {
-      command: "cmd",
-      args: ["/c", "start", "", filePath]
+      command: resolvedPath2,
+      args: ["shell32.dll,ShellExec_RunDLL", filePath]
     };
   }
   if (platform === "darwin") {
+    const resolvedPath2 = await resolveBinaryPath(DARWIN_OPEN_COMMAND, DARWIN_FALLBACK_COMMANDS);
+    if (!resolvedPath2) {
+      throw new Error(
+        "Could not find open command. Please ensure macOS is properly configured or open is available on PATH."
+      );
+    }
     return {
-      command: "open",
+      command: resolvedPath2,
       args: [filePath]
     };
   }
+  const resolvedPath = await resolveBinaryPath(UNIX_OPEN_COMMAND, UNIX_FALLBACK_COMMANDS);
+  if (!resolvedPath) {
+    throw new Error(
+      "Could not find xdg-open. Please install xdg-utils or ensure it is in your PATH."
+    );
+  }
   return {
-    command: "xdg-open",
+    command: resolvedPath,
     args: [filePath]
   };
 }
@@ -7185,7 +7741,7 @@ async function spawnDetached(command, args) {
 async function openShareSvgFile(filePath, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const runDetached = deps.spawnDetached ?? spawnDetached;
-  const { command, args } = resolveOpenCommand(filePath, platform);
+  const { command, args } = await resolveOpenCommand(filePath, platform);
   await runDetached(command, args);
 }
 async function writeAndOpenShareSvgFile(fileName, svgContent, deps = {}) {
@@ -7473,7 +8029,7 @@ function resolveTerminalContextLines(optimizeData, options) {
     const bestRow = rowsWithSavings.length > 0 ? rowsWithSavings.reduce(
       (best, current) => (current.savingsUsd ?? Number.NEGATIVE_INFINITY) > (best.savingsUsd ?? Number.NEGATIVE_INFINITY) ? current : best
     ) : void 0;
-    if (!bestRow || bestRow.savingsUsd === void 0) {
+    if (bestRow?.savingsUsd === void 0) {
       lines.push("ALL best candidate: unavailable (missing baseline or candidate pricing)");
     } else if (bestRow.savingsUsd > 0) {
       lines.push(
@@ -7529,9 +8085,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 +8140,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 +9469,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, {
@@ -9302,7 +9901,7 @@ function registerSharedReportOptions(command, profile) {
   const allowedSourcesLabel = getAllowedSourcesLabel(supportedSourceIds);
   const supportedSourcesSummary = `(${supportedSourceIds.length}): ${allowedSourcesLabel}`;
   const profileConfig = sharedOptionProfileConfig[profile];
-  const configuredCommand = command.option("--pi-dir <path>", "Path to .pi sessions directory").option("--codex-dir <path>", "Path to .codex sessions directory").option("--gemini-dir <path>", "Path to .gemini directory").option("--droid-dir <path>", "Path to Droid sessions directory").option("--opencode-db <path>", "Path to OpenCode SQLite DB").option(
+  const configuredCommand = command.option("--pi-dir <path>", "Path to .pi sessions directory").option("--codex-dir <path>", "Path to .codex sessions directory").option("--gemini-dir <path>", "Path to .gemini directory").option("--droid-dir <path>", "Path to Droid sessions directory").option("--claude-dir <path>", "Path to Claude projects directory").option("--opencode-db <path>", "Path to OpenCode SQLite DB").option(
     "--source-dir <source-id=path>",
     "Override source directory for directory-backed sources (repeatable)",
     collectRepeatedOption