llm-usage-metrics 0.10.2 → 0.11.0

package/dist/index.js

@@ -48,12 +48,16 @@ function normalizeSkippedRowReasons(value) {
 }
 
 // src/domain/normalization.ts
+import { stripVTControlCharacters } from "util";
 var CONTROL_CHARACTER_CLASS = String.raw`[\u0000-\u001F\u007F-\u009F\u061C\u200E\u200F\u2028-\u202E\u2066-\u2069]`;
 var CONTROL_CHARACTERS_PATTERN = new RegExp(CONTROL_CHARACTER_CLASS, "gu");
 var CONTROL_CHARACTER_TEST_PATTERN = new RegExp(CONTROL_CHARACTER_CLASS, "u");
 function stripControlCharacters(value) {
   return value.replace(CONTROL_CHARACTERS_PATTERN, "");
 }
+function toTerminalLine(value) {
+  return stripControlCharacters(stripVTControlCharacters(value).replaceAll(/\s+/gu, " ")).trim();
+}
 function hasControlCharacters(value) {
   return CONTROL_CHARACTER_TEST_PATTERN.test(value);
 }
@@ -764,6 +768,9 @@ CREATE TEMP TABLE IF NOT EXISTS history_departed_files (
   file_path TEXT NOT NULL,
   PRIMARY KEY (source, file_path)
 );
+CREATE TEMP TABLE IF NOT EXISTS history_departed_hashes (
+  content_hash TEXT PRIMARY KEY
+);
 CREATE TEMP TABLE IF NOT EXISTS history_served_files (
   source TEXT NOT NULL,
   file_path TEXT NOT NULL,
@@ -773,6 +780,7 @@ CREATE TEMP TABLE IF NOT EXISTS history_served_files (
 DELETE FROM history_selected_sources;
 DELETE FROM history_discovered_files;
 DELETE FROM history_departed_files;
+DELETE FROM history_departed_hashes;
 DELETE FROM history_served_files;
 `);
 }
@@ -849,6 +857,36 @@ function addHashCount(target, hash, count) {
   target.set(hash, (target.get(hash) ?? 0) + count);
 }
 function readLiveHashCounts(store) {
+  store.database.prepare(
+    [
+      "INSERT OR IGNORE INTO history_departed_hashes (content_hash)",
+      "SELECT events.content_hash",
+      "FROM history_departed_files AS departed",
+      "CROSS JOIN events",
+      "WHERE events.source = departed.source",
+      "  AND events.file_path = departed.file_path",
+      "  AND events.content_hash IS NOT NULL"
+    ].join("\n")
+  ).run();
+  store.database.prepare(
+    [
+      "INSERT OR IGNORE INTO history_departed_hashes (content_hash)",
+      "SELECT events.content_hash",
+      "FROM history_discovered_files AS discovered",
+      "CROSS JOIN events",
+      "WHERE events.source = discovered.source",
+      "  AND events.file_path = discovered.file_path",
+      "  AND discovered.counted = 1",
+      "  AND events.content_hash IS NOT NULL",
+      "  AND EXISTS (",
+      "    SELECT 1 FROM history_departed_files AS departed",
+      "    CROSS JOIN events AS departed_events",
+      "    WHERE departed_events.source = departed.source",
+      "      AND departed_events.file_path = departed.file_path",
+      "      AND departed_events.content_hash IS NULL",
+      "  )"
+    ].join("\n")
+  ).run();
   const rows = store.database.prepare(
     [
       "SELECT content_hash,",
@@ -857,15 +895,16 @@ function readLiveHashCounts(store) {
       "FROM (",
       "  SELECT events.content_hash AS content_hash,",
       "    selected.repeats_events AS repeats_events, COUNT(*) AS file_count",
-      "  FROM history_discovered_files AS discovered",
-      "  JOIN history_selected_sources AS selected",
-      "    ON discovered.source = selected.source",
+      "  FROM history_departed_hashes AS departed",
       "  CROSS JOIN events",
-      "  WHERE discovered.counted = 1",
-      "    AND events.source = discovered.source",
-      "    AND events.file_path = discovered.file_path",
-      "    AND events.content_hash IS NOT NULL",
-      "  GROUP BY discovered.source, discovered.file_path, events.content_hash",
+      "  JOIN history_discovered_files AS discovered",
+      "    ON discovered.source = events.source",
+      "    AND discovered.file_path = events.file_path",
+      "  JOIN history_selected_sources AS selected",
+      "    ON selected.source = events.source",
+      "  WHERE events.content_hash = departed.content_hash",
+      "    AND discovered.counted = 1",
+      "  GROUP BY events.source, events.file_path, events.content_hash",
       ")",
       "GROUP BY content_hash"
     ].join("\n")
@@ -1056,10 +1095,10 @@ function classifyAgainstLiveFiles(store, input) {
   if (selectedSources.size === 0) {
     return { classifiedFiles: [], liveHashCounts: /* @__PURE__ */ new Map() };
   }
-  const liveHashCounts = readLiveHashCounts(store);
-  const servedHashCounts = new Map(liveHashCounts);
   const departedFiles = readDepartedFiles(store);
   const departedHashMultisets = readDepartedHashMultisets(store);
+  const liveHashCounts = readLiveHashCounts(store);
+  const servedHashCounts = new Map(liveHashCounts);
   const classifiedFiles = [];
   for (const departedFile of departedFiles) {
     const fileHashCounts = departedHashMultisets.get(
@@ -1147,8 +1186,22 @@ CREATE TABLE IF NOT EXISTS events (
 );
 CREATE INDEX IF NOT EXISTS events_file ON events(source, file_path, event_index);
 CREATE INDEX IF NOT EXISTS events_content_hash ON events(content_hash);
+${createOverrideOnlyFilesSql()}
 `;
 }
+function createOverrideOnlyFilesSql() {
+  return `
+CREATE TABLE IF NOT EXISTS override_only_files (
+  source TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  PRIMARY KEY (source, file_path)
+);`;
+}
+function ensureOverrideOnlyFilesTable(database) {
+  if (!listUserTableNames(database).includes("override_only_files")) {
+    database.exec(createOverrideOnlyFilesSql());
+  }
+}
 function listUserTableNames(database) {
   return database.prepare(
     [
@@ -1267,6 +1320,10 @@ function assertSupportedSchemaVersion(database) {
   }
 }
 function initializeSchema(database) {
+  createOrMigrateSchema(database);
+  ensureOverrideOnlyFilesTable(database);
+}
+function createOrMigrateSchema(database) {
   if (listUserTableNames(database).length === 0) {
     const createdSchema = runTransaction(database, () => {
       if (listUserTableNames(database).length > 0) {
@@ -1602,6 +1659,21 @@ function readMetaValues(database) {
   }
   return meta;
 }
+var WIDE_WINDOW_ROW_SHARE = 0.15;
+function isWideWindow(database, fromTimestamp, toTimestamp) {
+  const rowCount = toNonNegativeInteger(
+    database.prepare("SELECT count(*) AS count FROM events").get()?.count
+  );
+  const threshold = Math.ceil((rowCount ?? 0) * WIDE_WINDOW_ROW_SHARE);
+  const row = database.prepare(
+    [
+      "SELECT count(*) AS count FROM (",
+      "  SELECT 1 FROM events WHERE timestamp >= ? AND timestamp < ? LIMIT ?",
+      ")"
+    ].join("\n")
+  ).get(fromTimestamp, toTimestamp, threshold);
+  return (toNonNegativeInteger(row?.count) ?? 0) >= threshold;
+}
 async function readEventStoreEvents(filePath, window = {}, loadSqliteModule = loadEventStoreSqliteModule) {
   const sqliteModule = await loadSqliteModule();
   if (!isEventStoreSqliteModule(sqliteModule)) {
@@ -1615,21 +1687,20 @@ async function readEventStoreEvents(filePath, window = {}, loadSqliteModule = lo
     assertSupportedSchemaVersion(database);
     const meta = readMetaValues(database);
     const cacheWrite1hColumn = meta.get("schemaVersion") === EVENT_STORE_SCHEMA_VERSION ? "cache_write_1h_tokens" : "0 AS cache_write_1h_tokens";
+    const fromTimestamp = window.fromTimestamp ?? "";
+    const toTimestamp = window.toTimestamp ?? "\uFFFF";
     const statement = database.prepare(
       [
         "SELECT source, session_id, timestamp, model, provider, repo_root,",
         "  input_tokens, output_tokens, reasoning_tokens, cache_read_tokens,",
         `  cache_write_tokens, ${cacheWrite1hColumn}, total_tokens, cost_usd, cost_mode`,
-        "FROM events",
+        isWideWindow(database, fromTimestamp, toTimestamp) ? "FROM events INDEXED BY events_file" : "FROM events",
         "WHERE timestamp >= ? AND timestamp < ?",
         "ORDER BY source, file_path, event_index"
       ].join("\n")
     );
     statement.setReturnArrays(true);
-    const rows = statement.all(
-      window.fromTimestamp ?? "",
-      window.toTimestamp ?? "\uFFFF"
-    );
+    const rows = statement.all(fromTimestamp, toTimestamp);
     const events = [];
     for (const row of rows) {
       const event = normalizeStoredEventTuple(row);
@@ -1776,11 +1847,15 @@ function deleteStoredFiles(store, files) {
     const deleteFile = store.database.prepare(
       "DELETE FROM files WHERE source = ? AND file_path = ?"
     );
+    const deleteOverrideOnlyFile = store.database.prepare(
+      "DELETE FROM override_only_files WHERE source = ? AND file_path = ?"
+    );
     for (const file of normalizedFiles) {
       result.deletedEventCount += countMatchingRows(store, "events", file.source, file.filePath);
       result.deletedFileCount += countMatchingRows(store, "files", file.source, file.filePath);
       deleteEvents.run(file.source, file.filePath);
       deleteFile.run(file.source, file.filePath);
+      deleteOverrideOnlyFile.run(file.source, file.filePath);
     }
   });
   return result;
@@ -1799,7 +1874,8 @@ function replaceFilesEvents(store, inputs) {
     skippedRows: toNonNegativeInteger(input.skippedRows) ?? 0,
     skippedRowReasons: stringifySkippedRowReasons(input.skippedRowReasons),
     ingestedAt: Math.max(0, Math.trunc(input.now)),
-    events: input.events.map((event) => createUsageEvent(event))
+    events: input.events.map((event) => createUsageEvent(event)),
+    overrideOnly: input.overrideOnly === true
   }));
   const deleteFileEvents = store.statements.deleteFileEvents ??= store.database.prepare(
     "DELETE FROM events WHERE source = ? AND file_path = ?"
@@ -1826,10 +1902,19 @@ function replaceFilesEvents(store, inputs) {
       "  ingested_at = excluded.ingested_at"
     ].join("\n")
   );
+  const markOverrideOnlyFile = store.statements.markOverrideOnlyFile ??= store.database.prepare(
+    [
+      "INSERT OR IGNORE INTO override_only_files (source, file_path)",
+      "SELECT ?, ? WHERE NOT EXISTS (SELECT 1 FROM files WHERE source = ? AND file_path = ?)"
+    ].join("\n")
+  );
   runTransaction(store.database, () => {
     for (const write of writes) {
       const { source, filePath } = write;
       deleteFileEvents.run(source, filePath);
+      if (write.overrideOnly) {
+        markOverrideOnlyFile.run(source, filePath, source, filePath);
+      }
       write.events.forEach((event, eventIndex) => {
         insertEvent.run(
           source,
@@ -1863,6 +1948,41 @@ function replaceFilesEvents(store, inputs) {
     }
   });
 }
+function readOverrideOnlyFiles(store) {
+  const rows = store.database.prepare("SELECT source, file_path FROM override_only_files ORDER BY source, file_path").all();
+  const files = [];
+  for (const row of rows) {
+    const source = toText(row.source);
+    const filePath = toText(row.file_path);
+    if (source && filePath) {
+      files.push({ source, filePath });
+    }
+  }
+  return files;
+}
+function claimOverrideOnlyFiles(store, files) {
+  const overrideOnlyKeys = new Set(
+    readOverrideOnlyFiles(store).map((file) => `${file.source}\0${file.filePath}`)
+  );
+  if (overrideOnlyKeys.size === 0) {
+    return;
+  }
+  const claimedFiles = files.map((file) => ({
+    source: normalizeStoreSource(file.source),
+    filePath: normalizeStoreFilePath(file.filePath)
+  })).filter((file) => overrideOnlyKeys.has(`${file.source}\0${file.filePath}`));
+  if (claimedFiles.length === 0) {
+    return;
+  }
+  runTransaction(store.database, () => {
+    const deleteOverrideOnlyFile = store.database.prepare(
+      "DELETE FROM override_only_files WHERE source = ? AND file_path = ?"
+    );
+    for (const file of claimedFiles) {
+      deleteOverrideOnlyFile.run(file.source, file.filePath);
+    }
+  });
+}
 function closeEventStore(store) {
   store.database.close();
 }
@@ -3820,7 +3940,7 @@ function exitQuietlyOnBrokenPipe(stream, exit = () => process.exit()) {
 }
 
 // src/cli/create-cli.ts
-import { Command as Command6 } from "commander";
+import { Command as Command6, Help } from "commander";
 
 // src/utils/suggest-closest.ts
 function editDistance(left, right4) {
@@ -3863,7 +3983,7 @@ function suggestClosest(input, candidates) {
 }
 
 // src/cli/report-definitions/report-definitions.ts
-import { Command } from "commander";
+import { Argument, Command, Option as Option2 } from "commander";
 
 // src/utils/time-buckets.ts
 var DAY_MS3 = 24 * 60 * 60 * 1e3;
@@ -3888,7 +4008,7 @@ function getDateTimeFormatter(timezone) {
   dateTimeFormatterCache.set(timezone, formatter);
   return formatter;
 }
-var MAX_MEMOIZED_TIMESTAMPS = 1e5;
+var MAX_MEMOIZED_TIMESTAMPS = 1e6;
 var localDatePartsByTimestamp = /* @__PURE__ */ new Map();
 function extractLocalDateParts(timestampIso, timezone) {
   let partsByTimestamp = localDatePartsByTimestamp.get(timezone);
@@ -3951,7 +4071,8 @@ function coversTimestamp(window, timestampMs) {
 function createLocalDateWindow(dayIndex, timestampMs, offsetMs, timezone, localDateTime) {
   const startMs = dayIndex * DAY_MS3 - offsetMs;
   const endMs = startMs + DAY_MS3;
-  const parts = toLocalDateParts(localDateTime);
+  const localDate = toLocalDateParts(localDateTime);
+  const parts = { ...localDate, dateKey: formatLocalDateParts(localDate) };
   if (hasStableOffsetWindow(startMs, endMs, offsetMs, timezone)) {
     return { startMs, endMs, parts };
   }
@@ -4056,7 +4177,7 @@ function getIsoWeekParts(localDate) {
 function getPeriodKey(timestampIso, granularity, timezone) {
   const localDate = extractLocalDateParts(timestampIso, timezone);
   if (granularity === "daily") {
-    return formatLocalDateParts(localDate);
+    return localDate.dateKey;
   }
   if (granularity === "monthly") {
     return `${localDate.year}-${String(localDate.month).padStart(2, "0")}`;
@@ -4075,15 +4196,13 @@ function getIsoDayOfWeekFromDateKey(localDateKey) {
   return toIsoDayOfWeek(createUtcDate(parseLocalDateKey(localDateKey)));
 }
 function getCurrentLocalDateKey(timezone, now = /* @__PURE__ */ new Date()) {
-  return formatLocalDateParts(extractLocalDateParts(now.toISOString(), timezone));
+  return extractLocalDateParts(now.toISOString(), timezone).dateKey;
 }
 function shiftLocalDateKey(localDateKey, days) {
-  return formatLocalDateParts(
-    extractLocalDateParts(
-      addDays(createUtcDate(parseLocalDateKey(localDateKey)), days).toISOString(),
-      "UTC"
-    )
-  );
+  return extractLocalDateParts(
+    addDays(createUtcDate(parseLocalDateKey(localDateKey)), days).toISOString(),
+    "UTC"
+  ).dateKey;
 }
 function getLocalDateKeyRange(from, to) {
   if (from > to) {
@@ -5765,7 +5884,10 @@ function comparePendingEvents(left, right4) {
 var ClaudeSourceAdapter = class {
   id = "claude";
   parserVersion = 4;
-  capabilities = { eventsPrecedeFileMtime: true };
+  capabilities = {
+    eventsPrecedeFileMtime: true,
+    sessionsCopyEvents: true
+  };
   rootDirs;
   requireDir;
   // Sibling forks share a parent; read its message keys once per parent version.
@@ -9487,7 +9609,7 @@ function createDefaultAdapters(options) {
 // src/cli/build-usage-data-inputs.ts
 function validateDateInput(value, flagName) {
   if (!/^\d{4}-\d{2}-\d{2}$/u.test(value)) {
-    throw new Error(`${flagName} must use format YYYY-MM-DD`);
+    throw new Error(`${flagName} "${value}" is not a date; use YYYY-MM-DD`);
   }
   const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
   if (Number.isNaN(parsed.getTime()) || parsed.toISOString().slice(0, 10) !== value) {
@@ -9781,6 +9903,101 @@ function formatEnvVarOverrides(overrides) {
   return lines;
 }
 
+// src/render/format-model-list.ts
+function limitNamedModels(models, limit) {
+  if (models.length <= limit) {
+    return [...models];
+  }
+  return [...models.slice(0, limit), `+${models.length - limit} more`];
+}
+
+// src/cli/count-copied-session-events-once.ts
+function getCopyIdentity(event) {
+  return [
+    event.timestamp,
+    event.provider ?? "",
+    event.model ?? "",
+    event.inputTokens,
+    event.outputTokens,
+    event.reasoningTokens,
+    event.cacheReadTokens,
+    event.cacheWriteTokens,
+    event.cacheWrite1hTokens,
+    event.totalTokens
+  ].join("\0");
+}
+function isCopyOf(left, right4) {
+  return left.totalTokens === right4.totalTokens && left.timestamp === right4.timestamp && left.model === right4.model && left.provider === right4.provider && left.inputTokens === right4.inputTokens && left.outputTokens === right4.outputTokens && left.reasoningTokens === right4.reasoningTokens && left.cacheReadTokens === right4.cacheReadTokens && left.cacheWriteTokens === right4.cacheWriteTokens && left.cacheWrite1hTokens === right4.cacheWrite1hTokens;
+}
+function findEventsOtherSessionsHold(events) {
+  const firstByTimestamp = /* @__PURE__ */ new Map();
+  const sameTimestampGroups = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const first = firstByTimestamp.get(event.timestamp);
+    if (first === void 0) {
+      firstByTimestamp.set(event.timestamp, event);
+      continue;
+    }
+    const group = sameTimestampGroups.get(event.timestamp);
+    if (group) {
+      group.push(event);
+    } else {
+      sameTimestampGroups.set(event.timestamp, [first, event]);
+    }
+  }
+  const candidates = /* @__PURE__ */ new Set();
+  for (const group of sameTimestampGroups.values()) {
+    for (let left = 0; left < group.length; left += 1) {
+      for (let right4 = left + 1; right4 < group.length; right4 += 1) {
+        if (group[left].sessionId !== group[right4].sessionId && isCopyOf(group[left], group[right4])) {
+          candidates.add(group[left]);
+          candidates.add(group[right4]);
+        }
+      }
+    }
+  }
+  return candidates;
+}
+function countCopiedSessionEventsOnce(events) {
+  const candidates = findEventsOtherSessionsHold(events);
+  if (candidates.size === 0) {
+    return [...events];
+  }
+  const sessionStarts = /* @__PURE__ */ new Map();
+  const candidatesBySession = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const start = sessionStarts.get(event.sessionId);
+    if (start === void 0 || compareByCodePoint(event.timestamp, start) < 0) {
+      sessionStarts.set(event.sessionId, event.timestamp);
+    }
+    if (candidates.has(event)) {
+      const sessionCandidates = candidatesBySession.get(event.sessionId) ?? [];
+      sessionCandidates.push(event);
+      candidatesBySession.set(event.sessionId, sessionCandidates);
+    }
+  }
+  const sessionsOldestFirst = [...candidatesBySession.keys()].sort(
+    (left, right4) => compareByCodePoint(sessionStarts.get(left) ?? "", sessionStarts.get(right4) ?? "") || compareByCodePoint(left, right4)
+  );
+  const countedIdentities = /* @__PURE__ */ new Map();
+  const copies = /* @__PURE__ */ new Set();
+  for (const sessionId of sessionsOldestFirst) {
+    const sessionCounts = /* @__PURE__ */ new Map();
+    for (const event of candidatesBySession.get(sessionId) ?? []) {
+      const identity = getCopyIdentity(event);
+      const seen = (sessionCounts.get(identity) ?? 0) + 1;
+      sessionCounts.set(identity, seen);
+      if (seen <= (countedIdentities.get(identity) ?? 0)) {
+        copies.add(event);
+      }
+    }
+    for (const [identity, count] of sessionCounts) {
+      countedIdentities.set(identity, Math.max(count, countedIdentities.get(identity) ?? 0));
+    }
+  }
+  return events.filter((event) => !copies.has(event));
+}
+
 // src/cli/history-live-files.ts
 import { stat as stat4 } from "fs/promises";
 var MAX_CONCURRENT_STATS = 32;
@@ -9882,12 +10099,33 @@ function writeParsedFilesToEventStore(context, files) {
     const now = context.now();
     context.replaceFilesEvents(
       context.store,
-      files.map((file) => ({ ...file, now }))
+      files.map((file) => ({
+        ...file,
+        now,
+        overrideOnly: context.overrideSourceIds.has(file.source.toLowerCase())
+      }))
     );
   } catch (error) {
     recordEventStoreFailure(context.failureState, error);
   }
 }
+function claimFilesInUsualLocations(context, files) {
+  if (context.failureState.disabled) {
+    return void 0;
+  }
+  const usualLocationFiles = files.filter(
+    (file) => !context.overrideSourceIds.has(file.source.toLowerCase())
+  );
+  if (usualLocationFiles.length === 0) {
+    return void 0;
+  }
+  try {
+    context.claimOverrideOnlyFiles(context.store, usualLocationFiles);
+    return void 0;
+  } catch (error) {
+    return `Event store could not record files found in their usual location: ${getErrorReason(error)}`;
+  }
+}
 
 // src/cli/parse/parse-budget.ts
 function createParseBudget(maxParallelFileParsing) {
@@ -10588,14 +10826,17 @@ async function parseSelectedAdapters(adaptersToParse, maxParallelFileParsing, op
         getFileEntry: options.eventStoreDeps?.getFileEntry ?? getFileEntry,
         readFileEvents: options.eventStoreDeps?.readFileEvents ?? readFileEvents,
         replaceFilesEvents: options.eventStoreDeps?.replaceFilesEvents ?? replaceFilesEvents,
+        claimOverrideOnlyFiles: options.eventStoreDeps?.claimOverrideOnlyFiles ?? claimOverrideOnlyFiles,
         now: options.now ?? Date.now,
-        failureState: eventStoreFailureState
+        failureState: eventStoreFailureState,
+        overrideSourceIds: options.overrideSourceIds ?? /* @__PURE__ */ new Set()
       };
     } catch (error) {
       recordEventStoreFailure(eventStoreFailureState, error);
     }
   }
   let parseResults;
+  let claimWarning;
   try {
     parseResults = await Promise.allSettled(
       adaptersToParse.map(
@@ -10621,6 +10862,17 @@ async function parseSelectedAdapters(adaptersToParse, maxParallelFileParsing, op
         )
       )
     );
+    if (eventStoreContext) {
+      claimWarning = claimFilesInUsualLocations(
+        eventStoreContext,
+        parseResults.flatMap(
+          (parseResult) => parseResult.status === "fulfilled" ? parseResult.value.filePaths.map((filePath) => ({
+            source: parseResult.value.source,
+            filePath
+          })) : []
+        )
+      );
+    }
   } finally {
     if (eventStoreContext && ownsEventStore) {
       try {
@@ -10655,7 +10907,9 @@ async function parseSelectedAdapters(adaptersToParse, maxParallelFileParsing, op
     failedFiles,
     eventStoreAvailable: Boolean(options.eventStore?.enabled) && !eventStoreFailureState.disabled,
     sourceFailures,
-    warnings: eventStoreFailureState.warning ? [eventStoreFailureState.warning] : []
+    warnings: [eventStoreFailureState.warning, claimWarning].filter(
+      (warning) => warning !== void 0
+    )
   };
 }
 function throwOnExplicitSourceFailures(sourceFailures, explicitSourceIds) {
@@ -10707,16 +10961,46 @@ function filterByModelRules(events, modelFilter) {
   const modelFilterRules = resolveModelFilterRules(events, modelFilter);
   return events.filter((event) => matchesModel(event.model, modelFilterRules));
 }
+function shiftUtcDate(date, days) {
+  const shifted = /* @__PURE__ */ new Date(`${date}T00:00:00.000Z`);
+  shifted.setUTCDate(shifted.getUTCDate() + days);
+  return shifted.toISOString();
+}
+function createDateWindowPrefilter(since, until) {
+  const outsideBefore = since ? shiftUtcDate(since, -1) : void 0;
+  const insideFrom = since ? shiftUtcDate(since, 1) : void 0;
+  const insideBefore = until ? shiftUtcDate(until, 0) : void 0;
+  const outsideFrom = until ? shiftUtcDate(until, 2) : void 0;
+  if ([outsideBefore, insideFrom, insideBefore, outsideFrom].some(
+    (bound) => bound !== void 0 && bound.length !== 24
+  )) {
+    return () => "near-edge";
+  }
+  return (timestamp) => {
+    if (timestamp.length !== 24) {
+      return "near-edge";
+    }
+    if (outsideBefore && timestamp < outsideBefore || outsideFrom && timestamp >= outsideFrom) {
+      return "outside";
+    }
+    return (!insideFrom || timestamp >= insideFrom) && (!insideBefore || timestamp < insideBefore) ? "inside" : "near-edge";
+  };
+}
 function collectProviderAndDateFilteredEvents(eventGroups, options) {
   const filteredEvents = [];
   const hasDateRange = Boolean(options.since ?? options.until);
+  const prefilterDate = createDateWindowPrefilter(options.since, options.until);
   const dateByTimestamp = /* @__PURE__ */ new Map();
   for (const events of eventGroups) {
     for (const event of events) {
       if (!matchesCanonicalProviderFilter(event.provider, options.providerFilter)) {
         continue;
       }
-      if (hasDateRange) {
+      const datePosition = hasDateRange ? prefilterDate(event.timestamp) : "inside";
+      if (datePosition === "outside") {
+        continue;
+      }
+      if (datePosition === "near-edge") {
         let eventDate = dateByTimestamp.get(event.timestamp);
         if (!eventDate) {
           eventDate = getPeriodKey(event.timestamp, "daily", options.timezone);
@@ -11077,6 +11361,9 @@ function applyMachineExport(cache, bundle, now) {
 function recordMachineSyncFailure(cache, reason, now) {
   writeEventStoreMeta(cache, { attemptedAt: String(now), lastError: reason });
 }
+function toStoredError(value) {
+  return value === void 0 ? void 0 : toTerminalLine(value);
+}
 function toEpochMs(value) {
   const parsed = value === void 0 ? Number.NaN : Number(value);
   return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
@@ -11087,7 +11374,7 @@ function toSyncState(readMeta) {
     cliVersion: readMeta("cliVersion"),
     syncedAt: toEpochMs(readMeta("syncedAt")),
     attemptedAt: toEpochMs(readMeta("attemptedAt")),
-    lastError: readMeta("lastError")
+    lastError: toStoredError(readMeta("lastError"))
   };
 }
 function readMachineSyncState(cache) {
@@ -11268,7 +11555,7 @@ async function loadMachineUsage(params) {
 // src/machines/machine-ssh.ts
 import { spawn } from "child_process";
 import { createInterface } from "readline";
-import { stripVTControlCharacters } from "util";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
 var DEFAULT_MACHINE_COMMAND = "llm-usage";
 var MACHINE_EXPORT_TIMEOUT_MARK = "timed out";
 var STDERR_TAIL_BYTES = 4096;
@@ -11361,7 +11648,7 @@ async function detectRemoteCommand(target, options = {}) {
 }
 function readStderrTail(chunks) {
   const text2 = Buffer.concat(chunks).toString("utf8").slice(-STDERR_TAIL_BYTES);
-  return stripControlCharacters(stripVTControlCharacters(text2).replaceAll(/\s+/gu, " ")).trim();
+  return toTerminalLine(text2);
 }
 function describeExportFailure(machine, exitCode, stderr) {
   const command = machine.command ?? DEFAULT_MACHINE_COMMAND;
@@ -11455,11 +11742,15 @@ async function fetchMachineExport(machine, knownFiles, options = {}) {
       cause: readError
     });
   }
-  const remoteWarnings = Buffer.concat(stderrChunks).toString("utf8").slice(-STDERR_TAIL_BYTES).split("\n").map((line) => stripControlCharacters(stripVTControlCharacters(line)).trim()).filter((line) => line.length > 0);
+  const remoteWarnings = Buffer.concat(stderrChunks).toString("utf8").slice(-STDERR_TAIL_BYTES).split("\n").map((line) => stripControlCharacters(stripVTControlCharacters2(line)).trim()).filter((line) => line.length > 0);
   return { bundle, remoteWarnings };
 }
 
 // src/render/render-machines.ts
+var MAX_REASON_LENGTH = 300;
+function formatReason(error) {
+  return error.length > MAX_REASON_LENGTH ? `${error.slice(0, MAX_REASON_LENGTH)}\u2026` : error;
+}
 var integerFormat = new Intl.NumberFormat("en-US");
 function formatAge(ageMs) {
   const minutes = Math.floor(Math.max(0, ageMs) / 6e4);
@@ -11494,7 +11785,7 @@ function renderSyncOutcome(outcome, now) {
     ];
   }
   const cacheNote = outcome.state.syncedAt === void 0 ? "nothing cached yet" : `reports keep its usage from ${formatAge(now - outcome.state.syncedAt)}`;
-  return [`\u2717 ${outcome.name}: ${outcome.error} (${cacheNote})`];
+  return [`\u2717 ${outcome.name}: ${formatReason(outcome.error)} (${cacheNote})`];
 }
 function describeMachineStatus(entry, now) {
   const { state } = entry;
@@ -11502,11 +11793,11 @@ function describeMachineStatus(entry, now) {
     return "disabled (cached usage stays in reports)";
   }
   if (state?.syncedAt === void 0) {
-    return state?.lastError ? `never synced: ${state.lastError}` : "never synced";
+    return state?.lastError ? `never synced: ${formatReason(state.lastError)}` : "never synced";
   }
   const synced = `synced ${formatAge(now - state.syncedAt)}, ${formatCachedTotals(entry.fileCount, entry.eventCount)}`;
   if (state.lastError && (state.attemptedAt ?? 0) >= state.syncedAt) {
-    return `${synced}; last attempt failed ${formatAge(now - (state.attemptedAt ?? 0))}: ${state.lastError}`;
+    return `${synced}; last attempt failed ${formatAge(now - (state.attemptedAt ?? 0))}: ${formatReason(state.lastError)}`;
   }
   return synced;
 }
@@ -11526,12 +11817,9 @@ function describeIncludedMachine(machine, now, localVersion) {
     return state?.syncedAt === void 0 ? `${machine.name} (disabled, nothing cached)` : `${machine.name} (disabled, usage from ${formatAge(now - state.syncedAt)})`;
   }
   if (state?.syncedAt === void 0) {
-    return `${machine.name} (never synced; run llm-usage sync ${machine.name})`;
+    return state?.lastError === void 0 ? `${machine.name} (never synced; run llm-usage sync ${machine.name})` : `${machine.name} (never synced)`;
   }
   const details = [`synced ${formatAge(now - state.syncedAt)}`];
-  if (state.lastError !== void 0 && (state.attemptedAt ?? 0) >= state.syncedAt) {
-    details.push("last sync failed");
-  }
   if (state.cliVersion && state.cliVersion !== localVersion) {
     details.push(
       `llm-usage-metrics ${state.cliVersion} there; shared sessions may count twice until both run the same version`
@@ -11552,16 +11840,35 @@ function formatRefreshFailure(outcome, now) {
   const { syncedAt } = outcome.state;
   if (syncedAt === void 0) {
     return {
-      text: `Could not sync ${outcome.name} (${outcome.error}); it has no usage cached yet.`,
+      text: `Could not sync ${outcome.name} (${formatReason(outcome.error)}); it has no usage cached yet.`,
       stale: true
     };
   }
   const hint = outcome.error.endsWith(`(${MACHINE_EXPORT_TIMEOUT_MARK})`) ? ` Run llm-usage sync ${outcome.name} to wait for it.` : "";
   return {
-    text: `Could not sync ${outcome.name} (${outcome.error}); using its usage from ${formatAge(now - syncedAt)}.${hint}`,
+    text: `Could not sync ${outcome.name} (${formatReason(outcome.error)}); using its usage from ${formatAge(now - syncedAt)}.${hint}`,
     stale: now - syncedAt >= STALE_CACHE_MS
   };
 }
+function formatStoredSyncFailure(machine, now) {
+  const { state } = machine;
+  if (!machine.enabled || state?.lastError === void 0) {
+    return void 0;
+  }
+  if (state.syncedAt === void 0) {
+    return {
+      text: `${machine.name}: never synced (${formatReason(state.lastError)}). Run llm-usage sync ${machine.name} to retry.`,
+      stale: true
+    };
+  }
+  if ((state.attemptedAt ?? 0) < state.syncedAt) {
+    return void 0;
+  }
+  return {
+    text: `${machine.name}: last sync failed (${formatReason(state.lastError)}); using its usage from ${formatAge(now - state.syncedAt)}. Run llm-usage sync ${machine.name} to retry.`,
+    stale: now - state.syncedAt >= STALE_CACHE_MS
+  };
+}
 
 // src/machines/sync-machine.ts
 async function syncMachine(name, machine, options = {}) {
@@ -11592,7 +11899,7 @@ async function syncMachine(name, machine, options = {}) {
     const result = applyMachineExport(cache, bundle, now());
     return { name, ok: true, result, remoteWarnings, state: readMachineSyncState(cache) };
   } catch (error) {
-    const reason = getErrorReason(error);
+    const reason = toTerminalLine(getErrorReason(error));
     let state = {};
     try {
       if (!options.signal?.aborted) {
@@ -31437,6 +31744,11 @@ async function resolveAndApplyPricingToEvents(events, options, runtimeConfig = g
 }
 
 // src/sources/source-adapter.ts
+function getSessionCopyingSourceIds(adapters) {
+  return new Set(
+    adapters.filter((adapter) => adapter.capabilities?.sessionsCopyEvents).map((adapter) => adapter.id)
+  );
+}
 function getRepeatingSourceIds(adapters) {
   return adapters.filter((adapter) => adapter.capabilities?.eventsRepeatAcrossFiles).map((adapter) => adapter.id);
 }
@@ -31510,6 +31822,23 @@ function findUnmatchedFilterWarnings(input) {
     ...findUnmatchedModelWarnings(eventsInRange, input.modelFilter, scope)
   ];
 }
+function hasValue(value) {
+  return Array.isArray(value) ? value.length > 0 : Boolean(value);
+}
+function hasCliFilters(options) {
+  return [
+    options.source,
+    options.provider,
+    options.model,
+    options.machine,
+    options.since,
+    options.until,
+    options.last,
+    options.vsSince,
+    options.vsUntil,
+    options.id
+  ].some(hasValue);
+}
 
 // src/cli/runtime-profile.ts
 var RUNTIME_PROFILE_ENV_VAR = "LLM_USAGE_PROFILE_RUNTIME";
@@ -31863,6 +32192,7 @@ async function buildUsageEventDataset(options, deps = {}) {
         return parseSelectedAdapters(adaptersToParse, parsingRuntimeConfig.maxParallelFileParsing, {
           eventStore: parseEventStoreRuntimeConfig,
           openedStore: openedEventStore,
+          overrideSourceIds: cliDirectorySourceIds,
           since: configuredOptions.since,
           parseWorkers: {
             workerCount: parsingRuntimeConfig.parseWorkers,
@@ -31875,7 +32205,12 @@ async function buildUsageEventDataset(options, deps = {}) {
     const parseWarnings = eventStoreOpenWarning ? [eventStoreOpenWarning, ...warnings] : warnings;
     throwOnExplicitSourceFailures(sourceFailures, normalizedInputs.explicitSourceIds);
     let parseResultsForFiltering = successfulParseResults;
-    const ledger = eventStoreAvailable ? { path: eventStoreRuntimeConfig.path, parsedFiles: [...parsedFiles], historyFiles: [] } : void 0;
+    const ledger = eventStoreAvailable ? {
+      path: eventStoreRuntimeConfig.path,
+      parsedFiles: [...parsedFiles],
+      historyFiles: [],
+      copiedEventCount: 0
+    } : void 0;
     const historyWarnings = [];
     const historyNotes = [];
     const historyStore = openedEventStore;
@@ -31900,7 +32235,14 @@ async function buildUsageEventDataset(options, deps = {}) {
                 discoveredFiles: discoveredFiles.filter(
                   (file) => !failedFileKeys.has(`${file.source}\0${file.filePath}`)
                 ),
-                presentFiles: failedFiles,
+                // Files only ever found under a custom directory never departed from
+                // their source's usual location, so a run there leaves them out.
+                presentFiles: [
+                  ...failedFiles,
+                  ...readOverrideOnlyFiles(historyStore).filter(
+                    (file) => !cliDirectorySourceIds.has(file.source)
+                  )
+                ],
                 repeatingSources: getRepeatingSourceIds(adaptersToParse)
               },
               { unverifiable: "treat-as-departed" }
@@ -31961,6 +32303,13 @@ async function buildUsageEventDataset(options, deps = {}) {
       );
       parseResultsForFiltering = appendMachineEvents(parseResultsForFiltering, machineUsage.events);
       machineWarnings.push(...machineUsage.warnings);
+      const refreshedNames = new Set(refreshOutcomes.map((outcome) => outcome.name));
+      for (const machine of machineUsage.machines) {
+        const failure = refreshedNames.has(machine.name) ? void 0 : formatStoredSyncFailure(machine, nowMs());
+        if (failure) {
+          (failure.stale ? machineWarnings : machineNotes).push(failure.text);
+        }
+      }
       machineNotes.push(
         formatMachinesNote(
           machineUsage.machines,
@@ -31969,6 +32318,21 @@ async function buildUsageEventDataset(options, deps = {}) {
         )
       );
     }
+    const sessionCopyingSources = getSessionCopyingSourceIds(adaptersToParse);
+    parseResultsForFiltering = measureRuntimeProfileStageSync(
+      runtimeProfile,
+      "usage.dataset.count_copies",
+      () => parseResultsForFiltering.map((result) => {
+        if (!sessionCopyingSources.has(result.source)) {
+          return result;
+        }
+        const events = countCopiedSessionEventsOnce(result.events);
+        if (ledger) {
+          ledger.copiedEventCount += result.events.length - events.length;
+        }
+        return { ...result, events };
+      })
+    );
     const filteredEvents = measureRuntimeProfileStageSync(
       runtimeProfile,
       "usage.dataset.filter_events",
@@ -32042,6 +32406,22 @@ async function applyPricingToUsageEventDataset(dataset, deps = {}, pricingLoadMo
     )
   );
 }
+var MAX_NAMED_UNPRICED_MODELS = 5;
+function describeUnpricedEvents(events) {
+  const unpricedEvents = events.filter((event) => event.costUsd === void 0);
+  if (unpricedEvents.length === 0) {
+    return void 0;
+  }
+  const models = [...new Set(unpricedEvents.map((event) => event.model ?? "unknown"))].sort();
+  const eventCount = new Intl.NumberFormat("en-US").format(unpricedEvents.length);
+  const eventLabel = unpricedEvents.length === 1 ? "event" : "events";
+  const modelList = limitNamedModels(models, MAX_NAMED_UNPRICED_MODELS).join(", ");
+  return `~ marks costs that leave out ${eventCount} ${eventLabel} with no known price (models: ${modelList})`;
+}
+function withUnpricedEventsNote(notes, events) {
+  const note = describeUnpricedEvents(events);
+  return note ? [...notes, note] : [...notes];
+}
 
 // src/cli/build-usage-data.ts
 var REPORT_PERIOD_NAMES = {
@@ -32054,14 +32434,14 @@ var DEFAULT_REPORT_WINDOWS = {
   weekly: { periods: 8, period: "week" }
 };
 var MAX_LAST_PERIODS = 1e4;
-function parseLastOption(last) {
+function parseLastOption(last, flag = "--last") {
   if (last === void 0) {
     return void 0;
   }
   const normalized = last.trim();
   const periods = Number.parseInt(normalized, 10);
   if (!/^[1-9]\d*$/u.test(normalized) || periods > MAX_LAST_PERIODS) {
-    throw new Error(`--last must be a whole number from 1 to ${String(MAX_LAST_PERIODS)}`);
+    throw new Error(`${flag} must be a whole number from 1 to ${String(MAX_LAST_PERIODS)}`);
   }
   return periods;
 }
@@ -32148,7 +32528,7 @@ async function buildUsageData(granularity, commandOptions, commandDeps = {}) {
     pricingOrigin,
     pricingWarning,
     warnings: dataset.warnings,
-    notes: dataset.notes,
+    notes: options.cost === false ? dataset.notes : withUnpricedEventsNote(dataset.notes, pricedEvents),
     activeEnvOverrides: dataset.readEnvVarOverrides(),
     activeConfig: dataset.activeConfig,
     timezone: dataset.normalizedInputs.timezone,
@@ -32415,6 +32795,10 @@ function padLine(content, width) {
 function renderReportHeader(options) {
   const { title, useColor = true } = options;
   const boxWidth = getBoxWidth(title);
+  const terminalWidth = options.terminalWidth ?? resolveTtyColumns(process.stdout);
+  if (terminalWidth !== void 0 && boxWidth > terminalWidth) {
+    return useColor ? pc2.bold(pc2.white(title)) : title;
+  }
   const lines = [];
   const topBorder = drawBoxLine(boxWidth, "\u250C", "\u2500", "\u2510");
   lines.push(useColor ? pc2.gray(topBorder) : topBorder);
@@ -32424,6 +32808,9 @@ function renderReportHeader(options) {
   lines.push(useColor ? pc2.gray(bottomBorder) : bottomBorder);
   return lines.join("\n");
 }
+function formatNoUsageMessage(filtered) {
+  return filtered ? "No usage data found for the selected filters." : "No usage data found.";
+}
 
 // src/render/terminal-table.ts
 import pc4 from "picocolors";
@@ -32901,6 +33288,75 @@ function computeColumnWidths(measureRows, options) {
   }
   return widths;
 }
+function measureBoxedTableWidth(widths) {
+  return widths.reduce((total, width) => total + width + 3, 1);
+}
+function measureLinesWidth(cell) {
+  return splitCellLines(cell).reduce((maxWidth, line) => Math.max(maxWidth, visibleWidth(line)), 0);
+}
+function joinCellLines(cell) {
+  return splitCellLines(cell).join(" ");
+}
+function wrapAtNameBreaks(line, width) {
+  const lines = [];
+  for (const piece of line.split(/(?<=[\s/-])/u)) {
+    const lastLine = lines.at(-1);
+    if (lastLine !== void 0 && visibleWidth((lastLine + piece).trimEnd()) <= width) {
+      lines[lines.length - 1] = lastLine + piece;
+    } else {
+      lines.push(piece);
+    }
+  }
+  return lines.flatMap(
+    (wrappedLine) => splitCellLines(wrapTableColumn([[wrappedLine.trimEnd()]], { columnIndex: 0, width })[0][0])
+  );
+}
+function renderStackedRows(options) {
+  const valueColumnIndexes = options.headerCells.map((_, columnIndex) => columnIndex).filter((columnIndex) => columnIndex >= options.titleColumnCount);
+  const labelWidth = valueColumnIndexes.reduce(
+    (maxWidth, columnIndex) => Math.max(maxWidth, visibleWidth(joinCellLines(options.measureHeaderCells[columnIndex]))),
+    0
+  );
+  const continuationIndent = " ".repeat(2 + labelWidth + 2);
+  const availableValueWidth = Math.max(1, options.terminalWidth - continuationIndent.length);
+  const valueWidth = Math.min(
+    availableValueWidth,
+    options.measureBodyRows.reduce(
+      (maxWidth, row) => valueColumnIndexes.reduce(
+        (rowMax, columnIndex) => Math.max(rowMax, measureLinesWidth(row[columnIndex])),
+        maxWidth
+      ),
+      0
+    )
+  );
+  const records = options.bodyRows.map((row, rowIndex) => {
+    const title = row.slice(0, options.titleColumnCount).map(joinCellLines).filter((cell) => cell.trim().length > 0).join(" \xB7 ");
+    const valueLines = valueColumnIndexes.flatMap((columnIndex) => {
+      const lines = measureLinesWidth(row[columnIndex]) > availableValueWidth ? splitCellLines(options.measureBodyRows[rowIndex][columnIndex]).flatMap(
+        (line) => wrapAtNameBreaks(line, availableValueWidth)
+      ) : splitCellLines(row[columnIndex]);
+      if (lines.every((line) => line.trim().length === 0)) {
+        return [];
+      }
+      const alignment2 = getColumnAlignment(
+        columnIndex,
+        options.multilineColumnIndex,
+        options.leftAlignedColumnIndexes
+      );
+      const label = alignCellLine(
+        joinCellLines(options.headerCells[columnIndex]),
+        labelWidth,
+        "left"
+      );
+      return lines.map((line, lineIndex) => {
+        const value = alignCellLine(line, valueWidth, alignment2).trimEnd();
+        return lineIndex === 0 ? `  ${label}  ${value}` : `${continuationIndent}${value}`;
+      });
+    });
+    return [title, ...valueLines].join("\n");
+  });
+  return records.join("\n\n");
+}
 function renderUnicodeTable(options) {
   const bodyColumnCount = getMaxRowColumnCount(options.bodyRows, options.headerCells.length);
   const measureColumnCount = getMaxRowColumnCount(
@@ -32932,6 +33388,20 @@ function renderUnicodeTable(options) {
     multilineColumnIndex: options.multilineColumnIndex,
     multilineColumnWidth: options.multilineColumnWidth
   });
+  const normalizedBodyRows = renderableRows.map((row) => row.bodyRow);
+  const normalizedRowMetas = renderableRows.map((row) => row.rowMeta);
+  if (options.terminalWidth !== void 0 && measureBoxedTableWidth(widths) > options.terminalWidth) {
+    return renderStackedRows({
+      headerCells: normalizedHeaderRow,
+      measureHeaderCells: normalizedMeasureHeaderRow,
+      bodyRows: normalizedBodyRows,
+      measureBodyRows: renderableRows.map((row) => row.measureBodyRow),
+      titleColumnCount: options.stackedTitleColumnCount ?? options.multilineColumnIndex + 1,
+      terminalWidth: options.terminalWidth,
+      multilineColumnIndex: options.multilineColumnIndex,
+      leftAlignedColumnIndexes: options.leftAlignedColumnIndexes
+    });
+  }
   const outputLines = [];
   outputLines.push(
     buildBorderLine(widths, {
@@ -32955,8 +33425,6 @@ function renderUnicodeTable(options) {
       right: "\u2524"
     })
   );
-  const normalizedBodyRows = renderableRows.map((row) => row.bodyRow);
-  const normalizedRowMetas = renderableRows.map((row) => row.rowMeta);
   normalizedBodyRows.forEach((row, rowIndex) => {
     outputLines.push(
       ...toRenderableRowLines(row, {
@@ -33254,7 +33722,8 @@ function renderPreparedTable(rows, prepared, options) {
     rowMetas: toRowMetas(rows),
     layout: options.tableLayout === "per_model_columns" ? "top_aligned" : "compact",
     multilineColumnIndex: prepared.showsModels ? columns.indexOf(modelsColumnIndex2) : columns.indexOf(sourceColumnIndex2),
-    multilineColumnWidth: prepared.showsModels ? options.modelsColumnWidth : void 0
+    multilineColumnWidth: prepared.showsModels ? options.modelsColumnWidth : void 0,
+    terminalWidth: options.stackedWidth
   });
   return { output, truncatedModelNames };
 }
@@ -33273,12 +33742,20 @@ function renderTerminalTableWithFit(rows, options = {}) {
       prepared = prepareFitStep(rows, tableLayout, step);
     }
   }
+  const stacked = tableLayout === "compact" && terminalWidth !== void 0 && !fitsTerminal(prepared, terminalWidth);
+  if (stacked) {
+    const listStep = steps.find((step) => step.hiddenColumns.includes("models"));
+    if (listStep) {
+      prepared = prepareFitStep(rows, tableLayout, listStep);
+    }
+  }
   const modelsColumnWidth = resolveModelsColumnWidth(prepared, tableLayout, terminalWidth);
   const { output, truncatedModelNames } = renderPreparedTable(rows, prepared, {
     tableLayout,
     useColor,
     modelsColumnWidth,
-    packModels: terminalWidth !== void 0
+    packModels: terminalWidth !== void 0,
+    stackedWidth: stacked ? terminalWidth : void 0
   });
   if (hasExplicitTerminalWidth && terminalWidth !== void 0) {
     const renderedTableWidth = measureTableWidth(output);
@@ -33293,7 +33770,8 @@ function renderTerminalTableWithFit(rows, options = {}) {
     fit: {
       tokenFormat: prepared.step.tokenFormat,
       hiddenColumns: [...prepared.step.hiddenColumns],
-      truncatedModelNames
+      truncatedModelNames,
+      stacked
     }
   };
 }
@@ -33408,9 +33886,13 @@ function renderTerminalTable(options) {
     rowMetas: createRowMetas(options.bodyRows.length),
     layout: "compact",
     multilineColumnIndex: 0,
-    multilineColumnWidth: options.firstColumnWidth
+    multilineColumnWidth: options.firstColumnWidth,
+    terminalWidth: resolveTtyColumns(process.stdout)
   });
 }
+function hasNoUsage(compareData) {
+  return compareData.current.totals.events === 0 && compareData.baseline.totals.events === 0;
+}
 function renderTerminalCompareReport(compareData, options) {
   const useColor = options.useColor ?? shouldUseColorByDefault();
   const lines = [];
@@ -33421,9 +33903,9 @@ function renderTerminalCompareReport(compareData, options) {
     })
   );
   lines.push("");
-  if (compareData.current.totals.events === 0 && compareData.baseline.totals.events === 0) {
-    lines.push("No usage data found for the selected filters.");
-    lines.push("");
+  if (hasNoUsage(compareData)) {
+    lines.push(formatNoUsageMessage(options.filtered ?? false));
+    return lines.join("\n");
   }
   lines.push(
     renderTerminalTable({
@@ -34224,7 +34706,7 @@ async function buildCompareData(options, deps = {}) {
     pricingOrigin,
     pricingWarning,
     warnings: dataset.warnings,
-    notes: dataset.notes,
+    notes: withUnpricedEventsNote(dataset.notes, [...currentEvents, ...baselineEvents]),
     activeEnvOverrides: dataset.readEnvVarOverrides(),
     activeConfig: dataset.activeConfig,
     timezone: dataset.normalizedInputs.timezone,
@@ -34883,7 +35365,7 @@ async function prepareCompareReport(options, deps = {}) {
       title: "Compare share card",
       render: (theme) => renderCompareShareSvg(compareData, theme)
     }) : void 0,
-    render: (compareData, format) => renderCompareReport(compareData, format)
+    render: (compareData, format) => renderCompareReport(compareData, format, { filtered: hasCliFilters(options) })
   });
 }
 async function runCompareReport(options) {
@@ -35067,19 +35549,21 @@ function formatDecimal(value, options = {}) {
   const formatted = decimalFormatter.format(value);
   return options.approximate ? `~${formatted}` : formatted;
 }
-function toEfficiencyTableCells(rows) {
+function toEfficiencyTableCells(rows, tokenFormat = "full") {
+  const formatTokens = tokenFormat === "abbreviated" ? formatAbbreviatedTokenCount : formatInteger3;
+  const formatTokenRate = (value) => value !== void 0 && tokenFormat === "abbreviated" ? formatAbbreviatedTokenCount(value) : formatDecimal(value);
   return rows.map((row) => [
     row.rowType === "period_source" ? `  ${row.source}` : row.periodKey,
     formatInteger3(row.rowType === "period_source" ? void 0 : row.commitCount),
     formatInteger3(row.rowType === "period_source" ? void 0 : row.linesAdded),
     formatInteger3(row.rowType === "period_source" ? void 0 : row.linesDeleted),
     formatInteger3(row.rowType === "period_source" ? void 0 : row.linesChanged),
-    formatInteger3(row.inputTokens),
-    formatInteger3(row.outputTokens),
-    formatInteger3(row.reasoningTokens),
-    formatInteger3(row.cacheReadTokens),
-    formatInteger3(row.cacheWriteTokens),
-    formatInteger3(row.totalTokens),
+    formatTokens(row.inputTokens),
+    formatTokens(row.outputTokens),
+    formatTokens(row.reasoningTokens),
+    formatTokens(row.cacheReadTokens),
+    formatTokens(row.cacheWriteTokens),
+    formatTokens(row.totalTokens),
     formatUsd4(row.costUsd, { approximate: row.costIncomplete }),
     formatUsdRate(row.rowType === "period_source" ? void 0 : row.usdPerCommit, {
       approximate: row.costIncomplete
@@ -35087,7 +35571,7 @@ function toEfficiencyTableCells(rows) {
     formatUsdRate(row.rowType === "period_source" ? void 0 : row.usdPer1kLinesChanged, {
       approximate: row.costIncomplete
     }),
-    formatDecimal(row.rowType === "period_source" ? void 0 : row.tokensPerCommit),
+    formatTokenRate(row.rowType === "period_source" ? void 0 : row.tokensPerCommit),
     formatDecimal(row.rowType === "period_source" ? void 0 : row.commitsPerUsd, {
       approximate: row.costIncomplete
     })
@@ -35096,15 +35580,45 @@ function toEfficiencyTableCells(rows) {
 
 // src/render/render-efficiency-report.ts
 var periodColumnIndex2 = 0;
-var minimumEfficiencyColumnWidth = 1;
 var commitsColumnIndex = 1;
 var linesAddedColumnIndex = 2;
 var linesDeletedColumnIndex = 3;
 var linesChangedColumnIndex = 4;
+var inputColumnIndex = 5;
+var outputColumnIndex = 6;
+var reasoningColumnIndex = 7;
+var cacheReadColumnIndex = 8;
+var cacheWriteColumnIndex = 9;
 var costColumnIndex = 11;
 var usdPerCommitColumnIndex = 12;
 var usdPer1kLinesChangedColumnIndex = 13;
 var commitsPerUsdColumnIndex = 15;
+var efficiencyFitSteps = [
+  { tokenFormat: "full", hiddenColumnIndexes: [] },
+  { tokenFormat: "abbreviated", hiddenColumnIndexes: [] },
+  {
+    tokenFormat: "abbreviated",
+    hiddenColumnIndexes: [
+      inputColumnIndex,
+      outputColumnIndex,
+      reasoningColumnIndex,
+      cacheWriteColumnIndex
+    ]
+  },
+  {
+    tokenFormat: "abbreviated",
+    hiddenColumnIndexes: [
+      linesAddedColumnIndex,
+      linesDeletedColumnIndex,
+      inputColumnIndex,
+      outputColumnIndex,
+      reasoningColumnIndex,
+      cacheReadColumnIndex,
+      cacheWriteColumnIndex,
+      commitsPerUsdColumnIndex
+    ]
+  }
+];
 function getReportTitle(granularity) {
   switch (granularity) {
     case "daily":
@@ -35129,11 +35643,7 @@ function measureRenderedTableWidth(columnWidths) {
   return columnWidths.reduce((sum, width) => sum + width, 0) + columnWidths.length * 3 + 1;
 }
 function computeColumnWidths2(headerCells, bodyRows) {
-  const columnCount = Math.max(
-    headerCells.length,
-    ...bodyRows.map((row) => row.length),
-    efficiencyTableHeaders.length
-  );
+  const columnCount = Math.max(headerCells.length, ...bodyRows.map((row) => row.length));
   const widths = Array.from({ length: columnCount }, () => 0);
   const measureRow = (row) => {
     for (let columnIndex = 0; columnIndex < columnCount; columnIndex += 1) {
@@ -35148,71 +35658,69 @@ function computeColumnWidths2(headerCells, bodyRows) {
   }
   return widths;
 }
-function resolveWrappedCells(headerCells, bodyRows, widths) {
-  let wrappedHeaderCells = [...headerCells];
-  let wrappedBodyRows = bodyRows.map((row) => [...row]);
-  for (let columnIndex = 0; columnIndex < widths.length; columnIndex += 1) {
-    const columnWidth = widths[columnIndex] ?? 0;
-    if (columnWidth <= 0) {
-      continue;
+function splitHeaderPieces(header) {
+  return header.split(" ").flatMap((word) => word.split(/(?<=\/)/u));
+}
+function wrapHeader(header, width) {
+  const lines = [];
+  for (const piece of splitHeaderPieces(header)) {
+    const lastLine = lines.at(-1);
+    const separator = lastLine === void 0 || lastLine.endsWith("/") ? "" : " ";
+    if (lastLine !== void 0 && visibleWidth(lastLine + separator + piece) <= width) {
+      lines[lines.length - 1] = lastLine + separator + piece;
+    } else {
+      lines.push(piece);
     }
-    wrappedHeaderCells = wrapTableColumn([wrappedHeaderCells], {
-      columnIndex,
-      width: columnWidth
-    })[0] ?? [];
-    wrappedBodyRows = wrapTableColumn(wrappedBodyRows, {
-      columnIndex,
-      width: columnWidth
-    });
   }
-  return {
-    wrappedHeaderCells,
-    wrappedBodyRows
-  };
+  return lines.join("\n");
+}
+function computeMinimumColumnWidths(headerCells, bodyRows) {
+  const headerPieceWidths = headerCells.map(
+    (header) => splitHeaderPieces(header).reduce(
+      (maxWidth, piece) => Math.max(maxWidth, visibleWidth(piece)),
+      0
+    )
+  );
+  return computeColumnWidths2([], bodyRows).map(
+    (bodyWidth, columnIndex) => Math.max(bodyWidth, headerPieceWidths[columnIndex] ?? 0)
+  );
 }
 function fitTableCellsToTerminal(headerCells, bodyRows) {
   const naturalWidths = computeColumnWidths2(headerCells, bodyRows);
   const terminalWidth = resolveTtyColumns(process.stdout);
+  const natural = {
+    headerCells: [...headerCells],
+    bodyRows: bodyRows.map((row) => [...row]),
+    widths: naturalWidths
+  };
   if (terminalWidth === void 0 || measureRenderedTableWidth(naturalWidths) <= terminalWidth) {
-    return {
-      headerCells: [...headerCells],
-      bodyRows: bodyRows.map((row) => [...row]),
-      widths: naturalWidths
-    };
+    return natural;
+  }
+  const minimumWidths = computeMinimumColumnWidths(headerCells, bodyRows);
+  if (measureRenderedTableWidth(minimumWidths) > terminalWidth) {
+    return { ...natural, stackedWidth: terminalWidth };
   }
   const constrainedWidths = [...naturalWidths];
-  let renderedTableWidth = measureRenderedTableWidth(constrainedWidths);
-  while (renderedTableWidth > terminalWidth && constrainedWidths.some((width) => width > minimumEfficiencyColumnWidth)) {
-    let widestIndex = -1;
-    let widestWidth = -1;
-    for (let columnIndex = 0; columnIndex < constrainedWidths.length; columnIndex += 1) {
-      const columnWidth = constrainedWidths[columnIndex];
-      if (columnWidth <= minimumEfficiencyColumnWidth || columnWidth <= widestWidth) {
-        continue;
+  let overflowColumns = measureRenderedTableWidth(constrainedWidths) - terminalWidth;
+  while (overflowColumns > 0) {
+    let shrinkIndex = 0;
+    for (let columnIndex = 1; columnIndex < constrainedWidths.length; columnIndex += 1) {
+      if (constrainedWidths[columnIndex] - minimumWidths[columnIndex] > constrainedWidths[shrinkIndex] - minimumWidths[shrinkIndex]) {
+        shrinkIndex = columnIndex;
       }
-      widestIndex = columnIndex;
-      widestWidth = columnWidth;
     }
-    if (widestIndex === -1) {
-      break;
-    }
-    const overflowColumns = renderedTableWidth - terminalWidth;
-    const maxReducibleWidth = widestWidth - minimumEfficiencyColumnWidth;
-    const reduction = Math.min(overflowColumns, maxReducibleWidth);
-    if (reduction <= 0) {
-      break;
-    }
-    constrainedWidths[widestIndex] -= reduction;
-    renderedTableWidth -= reduction;
+    const reduction = Math.min(
+      overflowColumns,
+      constrainedWidths[shrinkIndex] - minimumWidths[shrinkIndex]
+    );
+    constrainedWidths[shrinkIndex] -= reduction;
+    overflowColumns -= reduction;
   }
-  const { wrappedHeaderCells, wrappedBodyRows } = resolveWrappedCells(
-    headerCells,
-    bodyRows,
-    constrainedWidths
-  );
   return {
-    headerCells: wrappedHeaderCells,
-    bodyRows: wrappedBodyRows,
+    headerCells: headerCells.map(
+      (header, columnIndex) => wrapHeader(header, constrainedWidths[columnIndex])
+    ),
+    bodyRows: natural.bodyRows,
     widths: constrainedWidths
   };
 }
@@ -35282,12 +35790,50 @@ function styleEfficiencyTerminalRows(rows, bodyRows, options) {
     return styledCells;
   });
 }
+function fitEfficiencyStep(rows, step, options) {
+  const visibleColumnIndexes = efficiencyTableHeaders.map((_, columnIndex) => columnIndex).filter((columnIndex) => !step.hiddenColumnIndexes.includes(columnIndex));
+  const styledRows = styleEfficiencyTerminalRows(
+    rows,
+    toEfficiencyTableCells(rows, step.tokenFormat),
+    options
+  );
+  return fitTableCellsToTerminal(
+    selectColumns(Array.from(efficiencyTableHeaders), visibleColumnIndexes),
+    styledRows.map((row) => selectColumns(row, visibleColumnIndexes))
+  );
+}
+function describeEfficiencyFit(step, stacked) {
+  if (stacked) {
+    return "Listed rows instead of a table to fit the terminal. Widen the terminal to see the table.";
+  }
+  const changes = [];
+  if (step.tokenFormat === "abbreviated") {
+    changes.push("abbreviated token counts");
+  }
+  const hiddenHeaders = step.hiddenColumnIndexes.map(
+    (columnIndex) => efficiencyTableHeaders[columnIndex]
+  );
+  if (hiddenHeaders.length > 0) {
+    changes.push(`hid ${hiddenHeaders.slice(0, -1).join(", ")} and ${hiddenHeaders.at(-1) ?? ""}`);
+  }
+  return changes.length > 0 ? `Fitted the table to the terminal: ${changes.join(", ")}. Widen the terminal or use --json for full detail.` : void 0;
+}
 function renderTerminalEfficiencyTable(rows, options) {
-  const headerCells = Array.from(efficiencyTableHeaders);
-  const bodyRows = styleEfficiencyTerminalRows(rows, toEfficiencyTableCells(rows), options);
   const rowMetas = rows.map((row) => toTableRowMeta(row));
-  const fittedCells = fitTableCellsToTerminal(headerCells, bodyRows);
-  return renderUnicodeTable({
+  let fittedStep = efficiencyFitSteps[0];
+  let fittedCells = fitEfficiencyStep(rows, fittedStep, options);
+  for (const step of efficiencyFitSteps.slice(1)) {
+    if (fittedCells.stackedWidth === void 0) {
+      break;
+    }
+    const candidate = fitEfficiencyStep(rows, step, options);
+    if (candidate.stackedWidth === void 0) {
+      fittedStep = step;
+      fittedCells = candidate;
+    }
+  }
+  const note = describeEfficiencyFit(fittedStep, fittedCells.stackedWidth !== void 0);
+  const output = renderUnicodeTable({
     headerCells: fittedCells.headerCells,
     bodyRows: fittedCells.bodyRows,
     measureHeaderCells: fittedCells.headerCells,
@@ -35295,8 +35841,10 @@ function renderTerminalEfficiencyTable(rows, options) {
     rowMetas,
     layout: "compact",
     multilineColumnIndex: periodColumnIndex2,
-    multilineColumnWidth: fittedCells.widths[periodColumnIndex2] ?? efficiencyTableHeaders[periodColumnIndex2].length
+    multilineColumnWidth: fittedCells.widths[periodColumnIndex2] ?? efficiencyTableHeaders[periodColumnIndex2].length,
+    terminalWidth: fittedCells.stackedWidth
   });
+  return { output, notes: note ? [note] : [] };
 }
 function renderMarkdownEfficiencyTable(rows) {
   const bodyRows = toEfficiencyTableCells(rows).map(
@@ -35317,19 +35865,22 @@ function renderTerminalEfficiencyReport(efficiencyData, options) {
       useColor
     })
   );
-  outputLines.push("");
-  outputLines.push(renderTerminalEfficiencyTable(efficiencyData.rows, { useColor }));
-  return outputLines.join("\n");
+  const table = renderTerminalEfficiencyTable(efficiencyData.rows, { useColor });
+  outputLines.push("", table.output);
+  return { output: outputLines.join("\n"), notes: table.notes };
 }
-function renderEfficiencyReport(efficiencyData, format, options) {
+function renderEfficiencyReportWithNotes(efficiencyData, format, options) {
   switch (format) {
     case "json":
-      return renderReportJson("efficiency", {
-        grouping: efficiencyData.grouping,
-        rows: efficiencyData.rows
-      });
+      return {
+        output: renderReportJson("efficiency", {
+          grouping: efficiencyData.grouping,
+          rows: efficiencyData.rows
+        }),
+        notes: []
+      };
     case "markdown":
-      return renderMarkdownEfficiencyTable(efficiencyData.rows);
+      return { output: renderMarkdownEfficiencyTable(efficiencyData.rows), notes: [] };
     case "terminal":
       return renderTerminalEfficiencyReport(efficiencyData, options);
   }
@@ -35581,12 +36132,22 @@ async function assertRepoDirReadable(repoDir) {
     throw new Error(`Repository path is not a directory: ${repoDir}`);
   }
 }
-async function assertGitRepository(repoDir, runCommand) {
-  const gitRepoResult = await runCommand(repoDir, ["rev-parse", "--is-inside-work-tree"]);
-  if (gitRepoResult.exitCode === 0) {
-    return;
-  }
-  throw new Error(`Repository is not a git repository: ${repoDir}`);
+async function isGitRepository(repoDir, runCommand) {
+  const gitRepoResult = await runCommand(repoDir, ["rev-parse", "--is-inside-work-tree"]).catch(
+    (error) => {
+      if (getNodeErrorCode2(error) === "ENOENT") {
+        throw new Error("git was not found on PATH; efficiency needs git installed", {
+          cause: error
+        });
+      }
+      throw error;
+    }
+  );
+  return gitRepoResult.exitCode === 0;
+}
+function notGitRepositoryMessage(repoDir, repoDirOption) {
+  const hint = repoDirOption === void 0 ? "<path>" : "<path to a git repository>";
+  return `${repoDir} is not a git repository; pass --repo-dir ${hint}`;
 }
 function isNoCommitHistoryFailure(result) {
   if (result.exitCode !== 128) {
@@ -35859,11 +36420,20 @@ async function collectGitOutcomes(options, deps = {}) {
   const includeMergeCommits = options.includeMergeCommits ?? false;
   const runCommand = deps.runGitCommand ?? runGitCommand;
   if (options.activeUsageDays?.size === 0) {
-    return createEmptyOutcomeCollection(repoDir, includeMergeCommits);
+    const emptyCollection = createEmptyOutcomeCollection(repoDir, includeMergeCommits);
+    if (!deps.runGitCommand) {
+      await assertRepoDirReadable(repoDir);
+      if (!await isGitRepository(repoDir, runCommand)) {
+        emptyCollection.warning = notGitRepositoryMessage(repoDir, options.repoDir);
+      }
+    }
+    return emptyCollection;
   }
   if (!deps.runGitCommand) {
     await assertRepoDirReadable(repoDir);
-    await assertGitRepository(repoDir, runCommand);
+    if (!await isGitRepository(repoDir, runCommand)) {
+      throw new Error(notGitRepositoryMessage(repoDir, options.repoDir));
+    }
   }
   let authorEmail;
   try {
@@ -36174,8 +36744,8 @@ async function buildEfficiencyData(granularity, options, deps = {}) {
     sourceFailures: dataset.sourceFailures,
     pricingOrigin,
     pricingWarning,
-    warnings: dataset.warnings,
-    notes: dataset.notes,
+    warnings: gitOutcomes.warning ? [...dataset.warnings, gitOutcomes.warning] : dataset.warnings,
+    notes: withUnpricedEventsNote(dataset.notes, matchedEventsWithSignal),
     activeEnvOverrides: dataset.readEnvVarOverrides(),
     activeConfig: dataset.activeConfig,
     timezone: dataset.normalizedInputs.timezone,
@@ -36229,9 +36799,12 @@ async function prepareEfficiencyReport(granularity, options, deps = {}) {
       title: "Efficiency share card",
       render: (theme) => renderEfficiencyMonthlyShareSvg(efficiencyData, theme)
     }) : void 0,
-    render: (efficiencyData, format) => renderEfficiencyReport(efficiencyData, format, {
-      granularity
-    })
+    render: (efficiencyData, format) => {
+      const { output, notes } = renderEfficiencyReportWithNotes(efficiencyData, format, {
+        granularity
+      });
+      return { output, hintsAfterOutput: notes };
+    }
   });
 }
 function emitEfficiencyReportDiagnostics(diagnostics) {
@@ -36465,7 +37038,8 @@ function renderTerminalOptimizeReport(optimizeData, options) {
       rowMetas: optimizeData.rows.map((row) => toTableRowMeta2(row)),
       layout: "compact",
       multilineColumnIndex: 1,
-      multilineColumnWidth: candidateColumnWidth
+      multilineColumnWidth: candidateColumnWidth,
+      terminalWidth: resolveTtyColumns(process.stdout)
     })
   );
   return outputLines.join("\n");
@@ -36643,7 +37217,7 @@ function hasAnyUsageSignal(period) {
 }
 function parseCandidateModelsRaw(candidateModel) {
   if (!candidateModel || Array.isArray(candidateModel) && candidateModel.length === 0) {
-    throw new Error("At least one --candidate-model is required");
+    throw new Error("At least one --candidate-model is required, e.g. --candidate-model gpt-5.5");
   }
   const normalizedCandidates = (Array.isArray(candidateModel) ? candidateModel : [candidateModel]).flatMap((candidate) => candidate.split(",")).map((candidate) => candidate.trim().toLowerCase()).filter((candidate) => candidate.length > 0);
   if (normalizedCandidates.length === 0) {
@@ -36692,9 +37266,7 @@ function createSyntheticEvent(period) {
     reasoningTokens: period.reasoningTokens,
     cacheReadTokens: period.cacheReadTokens,
     cacheWriteTokens: period.cacheWriteTokens,
-    // Report rows do not keep the one-hour share, so candidates price every write at the
-    // standard cache-write rate.
-    cacheWrite1hTokens: 0,
+    cacheWrite1hTokens: period.cacheWrite1hTokens,
     totalTokens: period.totalTokens,
     costMode: "estimated",
     costUsd: void 0
@@ -36797,7 +37369,7 @@ function compareCandidateRank(left, right4) {
   }
   return compareByCodePoint(left.candidateModel, right4.candidateModel);
 }
-function resolveBaselinePeriods(usageRows) {
+function resolveBaselinePeriods(usageRows, oneHourCacheWritesByPeriod) {
   const periodRows = /* @__PURE__ */ new Map();
   let grandTotalRow;
   for (const row of usageRows) {
@@ -36839,6 +37411,7 @@ function resolveBaselinePeriods(usageRows) {
       reasoningTokens: row.reasoningTokens,
       cacheReadTokens: row.cacheReadTokens,
       cacheWriteTokens: row.cacheWriteTokens,
+      cacheWrite1hTokens: oneHourCacheWritesByPeriod.get(periodKey) ?? 0,
       totalTokens: row.totalTokens,
       baselineCostUsd: row.costUsd,
       baselineCostIncomplete: row.costIncomplete === true
@@ -36853,6 +37426,7 @@ function resolveBaselinePeriods(usageRows) {
       reasoningTokens: allRow.reasoningTokens,
       cacheReadTokens: allRow.cacheReadTokens,
       cacheWriteTokens: allRow.cacheWriteTokens,
+      cacheWrite1hTokens: oneHourCacheWritesByPeriod.get("ALL") ?? 0,
       totalTokens: allRow.totalTokens,
       baselineCostUsd: allRow.costUsd,
       baselineCostIncomplete: allRow.costIncomplete === true
@@ -36865,6 +37439,7 @@ function resolveBaselinePeriods(usageRows) {
       reasoningTokens: 0,
       cacheReadTokens: 0,
       cacheWriteTokens: 0,
+      cacheWrite1hTokens: 0,
       totalTokens: 0,
       baselineCostUsd: 0,
       baselineCostIncomplete: false
@@ -36880,7 +37455,7 @@ function buildWarning(periodKeys) {
   return `Baseline cost exists for zero-token periods (${sortedPeriodKeys.join(", ")}); savings were omitted.`;
 }
 function buildCounterfactualRows(input) {
-  const baselinePeriods = resolveBaselinePeriods(input.usageRows);
+  const baselinePeriods = resolveBaselinePeriods(input.usageRows, input.oneHourCacheWritesByPeriod);
   const allPeriod = baselinePeriods.find((period) => period.periodKey === "ALL");
   if (!allPeriod) {
     throw new Error("Missing ALL baseline totals");
@@ -36923,7 +37498,7 @@ function buildCounterfactualRows(input) {
 }
 
 // src/cli/build-optimize-data.ts
-function resolveOptimizeProvider(providers, providerFilter) {
+function resolveOptimizeProvider(providers, providerFilter, candidateModels) {
   const distinctProviders = collectCanonicalProviderRoots(providers);
   const normalizedProviderFilter = normalizeProviderFilter(providerFilter);
   if (distinctProviders.length > 1) {
@@ -36945,8 +37520,12 @@ function resolveOptimizeProvider(providers, providerFilter) {
         );
       }
     }
+    const candidateProviders = inferCanonicalProviderRootsFromModels(candidateModels);
+    const suggestedProvider = candidateProviders?.length === 1 && distinctProviders.includes(candidateProviders[0]) && distinctProviders.filter(
+      (provider) => matchesCanonicalProviderFilter(provider, candidateProviders[0])
+    ).length === 1 ? ` ${candidateProviders[0]}` : "";
     throw new Error(
-      `Optimize requires a single provider; found providers: ${distinctProviders.join(", ")}. Narrow with --provider.`
+      `Optimize requires a single provider; found providers: ${distinctProviders.join(", ")}. Narrow with --provider${suggestedProvider}.`
     );
   }
   if (distinctProviders.length === 1) {
@@ -36968,7 +37547,11 @@ async function buildOptimizeData(granularity, options, deps = {}) {
   const provider = measureRuntimeProfileStageSync(
     deps.runtimeProfile,
     "optimize.resolve_provider",
-    () => resolveOptimizeProvider(detectedProviders, dataset.normalizedInputs.providerFilter)
+    () => resolveOptimizeProvider(
+      detectedProviders,
+      dataset.normalizedInputs.providerFilter,
+      candidateModels
+    )
   );
   const { pricedEvents, pricingOrigin, pricingWarning, pricingSource } = await applyPricingToUsageEventDataset(dataset, deps, "force");
   const usageRows = measureRuntimeProfileStageSync(
@@ -36981,11 +37564,25 @@ async function buildOptimizeData(granularity, options, deps = {}) {
       includeModelBreakdown: false
     })
   );
+  const oneHourCacheWritesByPeriod = /* @__PURE__ */ new Map();
+  for (const event of pricedEvents) {
+    if (event.cacheWrite1hTokens === 0) {
+      continue;
+    }
+    const periodKey = getPeriodKey(event.timestamp, granularity, dataset.normalizedInputs.timezone);
+    for (const key of [periodKey, "ALL"]) {
+      oneHourCacheWritesByPeriod.set(
+        key,
+        (oneHourCacheWritesByPeriod.get(key) ?? 0) + event.cacheWrite1hTokens
+      );
+    }
+  }
   const counterfactual = measureRuntimeProfileStageSync(
     deps.runtimeProfile,
     "optimize.counterfactual",
     () => buildCounterfactualRows({
       usageRows,
+      oneHourCacheWritesByPeriod,
       provider,
       candidateModels,
       pricingSource,
@@ -36999,7 +37596,7 @@ async function buildOptimizeData(granularity, options, deps = {}) {
     pricingOrigin,
     pricingWarning,
     warnings: dataset.warnings,
-    notes: dataset.notes,
+    notes: withUnpricedEventsNote(dataset.notes, pricedEvents),
     activeEnvOverrides: dataset.readEnvVarOverrides(),
     activeConfig: dataset.activeConfig,
     timezone: dataset.normalizedInputs.timezone,
@@ -37140,12 +37737,7 @@ function formatModels2(models) {
   if (models.length === 0) {
     return "-";
   }
-  if (models.length <= MAX_NAMED_MODELS) {
-    return models.join("\n");
-  }
-  return [...models.slice(0, MAX_NAMED_MODELS), `+${models.length - MAX_NAMED_MODELS} more`].join(
-    "\n"
-  );
+  return limitNamedModels(models, MAX_NAMED_MODELS).join("\n");
 }
 function toSessionTableCells(row, options) {
   return [
@@ -37205,7 +37797,7 @@ function renderTerminalSessionReport(sessionData, options) {
     ""
   ];
   if (bodyRows.length === 0) {
-    outputLines.push("No usage data found for the selected filters.");
+    outputLines.push(formatNoUsageMessage(options.filtered ?? false));
     return outputLines.join("\n");
   }
   const modelsColumnIndex3 = headers.length - 1;
@@ -37222,7 +37814,9 @@ function renderTerminalSessionReport(sessionData, options) {
       rowMetas: wrappedRows.map(() => toRowMeta()),
       layout: "top_aligned",
       multilineColumnIndex: modelsColumnIndex3,
-      multilineColumnWidth: MODELS_COLUMN_WIDTH
+      multilineColumnWidth: MODELS_COLUMN_WIDTH,
+      terminalWidth: resolveTtyColumns(process.stdout),
+      stackedTitleColumnCount: 1
     })
   );
   return outputLines.join("\n");
@@ -37504,14 +38098,14 @@ async function buildSessionData(options, deps = {}) {
     since: options.since,
     until: options.until
   };
-  const diagnostics = buildUsageDiagnostics({
+  const buildDiagnostics = (shownEvents) => buildUsageDiagnostics({
     adaptersToParse: dataset.adaptersToParse,
     successfulParseResults: dataset.successfulParseResults,
     sourceFailures: dataset.sourceFailures,
     pricingOrigin,
     pricingWarning,
     warnings: dataset.warnings,
-    notes: dataset.notes,
+    notes: withUnpricedEventsNote(dataset.notes, shownEvents),
     activeEnvOverrides: dataset.readEnvVarOverrides(),
     activeConfig: dataset.activeConfig,
     timezone: dataset.normalizedInputs.timezone,
@@ -37524,11 +38118,14 @@ async function buildSessionData(options, deps = {}) {
       () => aggregateSessionsByRepo(pricedEvents, aggregateOptions)
     );
     const limited2 = limitRows(repoRows, limit, "repos");
+    const shownRepos = new Set(limited2.rows.map((row) => row.repoRoot ?? ""));
     return {
       grouping: "repo",
       rows: limited2.rows,
       limitNote: limited2.limitNote,
-      diagnostics
+      diagnostics: buildDiagnostics(
+        pricedEvents.filter((event) => shownRepos.has(event.repoRoot ?? ""))
+      )
     };
   }
   const sessionRows = measureRuntimeProfileStageSync(
@@ -37537,11 +38134,14 @@ async function buildSessionData(options, deps = {}) {
     () => aggregateSessions(pricedEvents, { ...aggregateOptions, ids: idFilters })
   );
   const limited = limitRows(sessionRows, limit, "sessions");
+  const shownSessions = new Set(limited.rows.map((row) => getEventSessionKey(row)));
   return {
     grouping: "session",
     rows: limited.rows,
     limitNote: limited.limitNote,
-    diagnostics
+    diagnostics: buildDiagnostics(
+      pricedEvents.filter((event) => shownSessions.has(getEventSessionKey(event)))
+    )
   };
 }
 
@@ -37559,7 +38159,8 @@ async function prepareSessionReport(options, deps = {}) {
     runtimeProfile: deps.runtimeProfile,
     render: (sessionData, format) => renderSessionReport(sessionData, format, {
       timezone: sessionData.diagnostics.timezone,
-      truncateSessionIds: !options.id?.length
+      truncateSessionIds: !options.id?.length,
+      filtered: hasCliFilters(options)
     })
   });
 }
@@ -37676,6 +38277,19 @@ function toTableRow(period) {
 function hasAnyUsage(summaryData) {
   return summaryData.periods.some((period) => period.totals.events > 0);
 }
+function toNoRecentUsageMessage(summaryData, filtered) {
+  if (filtered) {
+    return "No usage in the last 7 days or this month for the selected filters.";
+  }
+  const latestDay = summaryData.activity.days.filter((day) => day.totalTokens > 0).at(-1);
+  if (latestDay) {
+    return `No usage in the last 7 days or this month. Latest usage: ${latestDay.date}. Try \`llm-usage monthly --all\`.`;
+  }
+  if (summaryData.diagnostics.sessionStats.some((stat10) => stat10.filesFound > 0)) {
+    return "No usage in the past year. Try `llm-usage monthly --all`.";
+  }
+  return "No usage found in the last 7 days or this month. Run `llm-usage doctor` to see which sources were found.";
+}
 function getTitle(summaryData) {
   const today = summaryData.periods[0]?.until ?? "";
   return `Usage summary for ${today} (${summaryData.timezone})`;
@@ -37803,12 +38417,16 @@ function renderTerminalSummaryReport(summaryData, options) {
     periodKey: "summary",
     rowKind: "detail"
   }));
-  const lines = [renderReportHeader({ title: getTitle(summaryData), useColor }), ""];
+  const lines = [
+    renderReportHeader({
+      title: getTitle(summaryData),
+      useColor,
+      terminalWidth: options.terminalWidth
+    }),
+    ""
+  ];
   if (!hasAnyUsage(summaryData)) {
-    lines.push(
-      "No usage found in the last 7 days or this month. Run `llm-usage doctor` to see which sources were found."
-    );
-    lines.push("");
+    lines.push(toNoRecentUsageMessage(summaryData, options.filtered ?? false), "");
   }
   lines.push(
     renderUnicodeTable({
@@ -37820,7 +38438,8 @@ function renderTerminalSummaryReport(summaryData, options) {
       layout: "compact",
       multilineColumnIndex: 0,
       multilineColumnWidth: 13,
-      leftAlignedColumnIndexes: [3]
+      leftAlignedColumnIndexes: [3],
+      terminalWidth: options.terminalWidth ?? resolveTtyColumns(process.stdout)
     })
   );
   const monthNotes = toMonthNotes(summaryData);
@@ -38291,6 +38910,10 @@ async function buildSummaryData(options, deps = {}) {
     pricedEvents.filter((event) => isEventWithinWindow(event, monthToDateWindow, timezone)),
     pricingSource
   ) : void 0;
+  const bestDay = activity.bestDay?.costUsd === void 0 ? void 0 : activity.bestDay.date;
+  const shownCostEvents = pricedEvents.filter(
+    (event) => windows.some((window) => isEventWithinWindow(event, window, timezone)) || getPeriodKey(event.timestamp, "daily", timezone) === bestDay
+  );
   return {
     timezone,
     periods,
@@ -38308,7 +38931,7 @@ async function buildSummaryData(options, deps = {}) {
       pricingOrigin,
       pricingWarning,
       warnings: dataset.warnings,
-      notes: dataset.notes,
+      notes: withUnpricedEventsNote(dataset.notes, shownCostEvents),
       activeEnvOverrides: dataset.readEnvVarOverrides(),
       activeConfig: dataset.activeConfig,
       timezone,
@@ -38333,7 +38956,7 @@ async function prepareSummaryReport(options, deps = {}) {
       title: "Activity share card",
       render: (theme) => renderSummaryShareSvg(summaryData, theme)
     }) : void 0,
-    render: (summaryData, format) => renderSummaryReport(summaryData, format),
+    render: (summaryData, format) => renderSummaryReport(summaryData, format, { filtered: hasCliFilters(options) }),
     getHintsAfterOutput: (_summaryData, format) => format === "terminal" ? [SUMMARY_NEXT_STEPS_HINT] : []
   });
 }
@@ -38428,9 +39051,6 @@ function formatStatusline(summary, session) {
   return parts.join(SEPARATOR);
 }
 async function buildStatuslineSummary(options, deps) {
-  if (options.json) {
-    throw new Error("--json is not supported for statusline; use llm-usage summary --json");
-  }
   return buildSummaryData({ ...options, pricingOffline: true, sync: false }, deps);
 }
 async function runStatusline(options, deps = {}) {
@@ -38577,7 +39197,7 @@ function renderSummaryOnly(trendsData, options) {
   }
   if (trendsData.totalSeries.summary.observedDayCount === 0) {
     lines.push("No usage data found for the selected date range.");
-    lines.push("");
+    return lines.join("\n");
   }
   if (shouldShowNoResolvedCostDataNote(trendsData)) {
     lines.push(
@@ -38736,8 +39356,9 @@ function renderTerminalTrendsReport(trendsData, options) {
   const terminalWidth = resolveTerminalWidth2(options.terminalWidth);
   const accent = trendsData.metric === "cost" ? pc8.green : pc8.cyan;
   const minimumChartWidth = 40;
-  if (terminalWidth !== void 0 && terminalWidth < minimumChartWidth) {
-    return renderSummaryOnly(trendsData, { useColor, narrowNote: true });
+  const isEmpty = trendsData.totalSeries.summary.observedDayCount === 0;
+  if (isEmpty || terminalWidth !== void 0 && terminalWidth < minimumChartWidth) {
+    return renderSummaryOnly(trendsData, { useColor, narrowNote: !isEmpty });
   }
   const lines = [
     renderReportHeader({
@@ -38746,10 +39367,6 @@ function renderTerminalTrendsReport(trendsData, options) {
     }),
     ""
   ];
-  if (trendsData.totalSeries.summary.observedDayCount === 0) {
-    lines.push("No usage data found for the selected date range.");
-    lines.push("");
-  }
   if (shouldShowNoResolvedCostDataNote(trendsData)) {
     lines.push(
       "No resolved cost data for the selected range; use pricing or switch to --metric tokens."
@@ -39100,16 +39717,6 @@ function aggregateTrends(rows, options) {
 }
 
 // src/cli/build-trends-data.ts
-function parseDaysOption(days) {
-  if (days === void 0) {
-    return void 0;
-  }
-  const trimmedDays = days.trim();
-  if (!/^[1-9]\d*$/u.test(trimmedDays)) {
-    throw new Error("--days must be a positive integer");
-  }
-  return Number.parseInt(trimmedDays, 10);
-}
 function resolveMetric(metric) {
   if (metric === void 0 || metric.trim() === "") {
     return "cost";
@@ -39180,8 +39787,13 @@ function resolveOutputDateRange(options, today, days, observedDates) {
   };
 }
 function resolveTrendsOptions(options, timezone, now) {
-  if (options.days !== void 0 && (options.since || options.until)) {
-    throw new Error("--days cannot be combined with --since or --until");
+  if (options.last !== void 0 && options.days !== void 0) {
+    throw new Error("--days is an alias of --last; pass only --last");
+  }
+  const daysFlag = options.days === void 0 ? "--last" : "--days";
+  const daysValue = options.last ?? options.days;
+  if (daysValue !== void 0 && (options.since || options.until)) {
+    throw new Error(`${daysFlag} cannot be combined with --since or --until`);
   }
   if (options.since) {
     validateDateInput(options.since, "--since");
@@ -39193,7 +39805,7 @@ function resolveTrendsOptions(options, timezone, now) {
     throw new Error("--since must be less than or equal to --until");
   }
   const metric = resolveMetric(options.metric);
-  const days = parseDaysOption(options.days);
+  const days = parseLastOption(daysValue, daysFlag);
   const today = getCurrentLocalDateKey(timezone, now);
   return {
     days,
@@ -39300,6 +39912,10 @@ async function buildTrendsData(options, deps = {}) {
       sourceOrder: dataset.adaptersToParse.map((adapter) => adapter.id)
     })
   );
+  const chartedEvents = resolved.metric === "cost" ? pricingResult.pricedEvents.filter((event) => {
+    const day = getPeriodKey(event.timestamp, "daily", dataset.normalizedInputs.timezone);
+    return day >= outputDateRange.from && day <= outputDateRange.to;
+  }) : [];
   const diagnostics = buildUsageDiagnostics({
     adaptersToParse: dataset.adaptersToParse,
     successfulParseResults: dataset.successfulParseResults,
@@ -39307,7 +39923,7 @@ async function buildTrendsData(options, deps = {}) {
     pricingOrigin: pricingResult.pricingOrigin,
     pricingWarning: pricingResult.pricingWarning,
     warnings: dataset.warnings,
-    notes: dataset.notes,
+    notes: withUnpricedEventsNote(dataset.notes, chartedEvents),
     activeEnvOverrides: dataset.readEnvVarOverrides(),
     activeConfig: dataset.activeConfig,
     timezone: dataset.normalizedInputs.timezone,
@@ -39460,7 +40076,8 @@ function describeTableFit(fit, compact, hideCost = false) {
   if (changes.length === 0) {
     return void 0;
   }
-  return `Fitted the table to the terminal: ${changes.join(", ")}. Widen the terminal or use --json for full detail.`;
+  const layout = fit.stacked ? "Listed rows instead of a table to fit the terminal" : "Fitted the table to the terminal";
+  return `${layout}: ${changes.join(", ")}. Widen the terminal or use --json for full detail.`;
 }
 function renderTerminalUsageReport(usageData, options) {
   const outputLines = [];
@@ -39469,12 +40086,13 @@ function renderTerminalUsageReport(usageData, options) {
   outputLines.push(
     renderReportHeader({
       title: getReportTitle4(options.granularity),
-      useColor
+      useColor,
+      terminalWidth: options.terminalWidth
     })
   );
   outputLines.push("");
-  if (usageData.rows.length === 0) {
-    outputLines.push("No usage data found for the selected filters.");
+  if (usageData.rows.every((row) => row.rowType === "grand_total")) {
+    outputLines.push(formatNoUsageMessage(options.filtered ?? false));
     return { output: outputLines.join("\n"), notes: [] };
   }
   const { output, fit } = renderTerminalTableWithFit(usageData.rows, {
@@ -39736,7 +40354,8 @@ async function prepareUsageReport(granularity, options, deps = {}) {
         granularity,
         tableLayout,
         compact: options.compact,
-        hideCost
+        hideCost,
+        filtered: hasCliFilters(options)
       });
       return { output, hintsAfterOutput: notes };
     },
@@ -40406,9 +41025,6 @@ async function runPruneReport(options, deps = {}) {
 var eventsExportFormats = ["jsonl", "csv"];
 var CSV_HEADER = "source,sessionId,timestamp,repoRoot,provider,model,inputTokens,outputTokens,reasoningTokens,cacheReadTokens,cacheWriteTokens,totalTokens,costUsd,costMode,machine";
 function resolveEventsFormat(options) {
-  if (options.json) {
-    throw new Error("--json is not supported for events; use --format jsonl");
-  }
   const format = options.format ?? "jsonl";
   const resolved = eventsExportFormats.find((candidate) => candidate === format);
   if (!resolved) {
@@ -40594,17 +41210,31 @@ function renderTopTable(headerCells, bodyRows) {
     rowMetas,
     layout: "compact",
     multilineColumnIndex: TOP_ITEM_NAME_COLUMN,
-    multilineColumnWidth: nameColumnWidth
+    multilineColumnWidth: nameColumnWidth,
+    terminalWidth: resolveTtyColumns(process.stdout)
   });
 }
+function toEmptyMessage(recap, filtered) {
+  if (recap.eventCount > 0) {
+    return void 0;
+  }
+  return filtered ? formatNoUsageMessage(true) : `No usage in ${recap.year}.`;
+}
 function renderWrappedTerminalReport(recap, options) {
   const useColor = options.useColor ?? shouldUseColorByDefault();
   const palette = options.palette ?? defaultTerminalStylePalette;
   const paint = (styler) => (text2) => useColor ? styler(text2) : text2;
-  return [
+  const heading = [
     renderReportHeader({ title: `Wrapped ${recap.year}`, useColor }),
     paint(palette.dim)(`${recap.from} to ${recap.to} (${recap.timezone})`),
-    "",
+    ""
+  ];
+  const emptyMessage = toEmptyMessage(recap, options.filtered ?? false);
+  if (emptyMessage) {
+    return [...heading, emptyMessage].join("\n");
+  }
+  return [
+    ...heading,
     renderStatLines(recap, paint, palette),
     "",
     "Monthly activity",
@@ -41022,7 +41652,7 @@ async function buildWrappedData(options, deps = {}) {
     pricingOrigin,
     pricingWarning,
     warnings: dataset.warnings,
-    notes: dataset.notes,
+    notes: withUnpricedEventsNote(dataset.notes, pricedEvents),
     activeEnvOverrides: dataset.readEnvVarOverrides(),
     activeConfig: dataset.activeConfig,
     timezone: dataset.normalizedInputs.timezone,
@@ -41051,7 +41681,7 @@ async function prepareWrappedReport(options, deps = {}) {
       title: `${wrappedData.recap.year} Wrapped share card`,
       render: (theme) => renderWrappedShareSvg(wrappedData.recap, theme)
     }) : void 0,
-    render: (wrappedData, format) => renderWrappedReport(wrappedData.recap, format)
+    render: (wrappedData, format) => renderWrappedReport(wrappedData.recap, format, { filtered: hasCliFilters(options) })
   });
 }
 async function runWrappedReport(options) {
@@ -41064,102 +41694,144 @@ async function runWrappedReport(options) {
 import { Option } from "commander";
 var sharedOptionProfileConfig = {
   usage: {
+    includeJson: true,
+    includeQuiet: true,
     includeDateFilters: true,
     includeMarkdown: true,
     includePerModelColumns: true,
     includePricing: true,
+    includePricingFetch: true,
     includeProviderModelFilters: true,
     includeHistory: true,
+    includeSync: true,
     includeShare: true,
     includeTimezone: true
   },
   summary: {
+    includeJson: true,
+    includeQuiet: true,
     includeDateFilters: false,
     includeMarkdown: true,
     includePerModelColumns: false,
     includePricing: true,
+    includePricingFetch: true,
     includeProviderModelFilters: true,
     includeHistory: true,
+    includeSync: true,
     includeShare: true,
     includeTimezone: true
   },
   specialized: {
+    includeJson: true,
+    includeQuiet: true,
     includeDateFilters: true,
     includeMarkdown: true,
     includePerModelColumns: false,
     includePricing: true,
+    includePricingFetch: true,
     includeProviderModelFilters: true,
     includeHistory: true,
+    includeSync: true,
     includeShare: true,
     includeTimezone: true
   },
   compare: {
+    includeJson: true,
+    includeQuiet: true,
     includeDateFilters: true,
     includeMarkdown: true,
     includePerModelColumns: false,
     includePricing: true,
+    includePricingFetch: true,
     includeProviderModelFilters: true,
     includeHistory: true,
+    includeSync: true,
     includeShare: true,
     includeTimezone: true
   },
   trends: {
+    includeJson: true,
+    includeQuiet: true,
     includeDateFilters: true,
     includeMarkdown: true,
     includePerModelColumns: false,
     includePricing: true,
+    includePricingFetch: true,
     includeProviderModelFilters: true,
     includeHistory: true,
+    includeSync: true,
     includeShare: true,
     includeTimezone: true
   },
   session: {
+    includeJson: true,
+    includeQuiet: true,
     includeDateFilters: true,
     includeMarkdown: true,
     includePerModelColumns: false,
     includePricing: true,
+    includePricingFetch: true,
     includeProviderModelFilters: true,
     includeHistory: true,
+    includeSync: true,
     includeShare: false,
     includeTimezone: true
   },
   wrapped: {
+    includeJson: true,
+    includeQuiet: true,
     includeDateFilters: false,
     includeMarkdown: true,
     includePerModelColumns: false,
     includePricing: true,
+    includePricingFetch: true,
     includeProviderModelFilters: true,
     includeHistory: true,
+    includeSync: true,
     includeShare: true,
     includeTimezone: true
   },
   events: {
+    includeJson: false,
+    jsonAlternative: "use --format jsonl",
+    includeQuiet: true,
     includeDateFilters: true,
     includeMarkdown: false,
     includePerModelColumns: false,
     includePricing: true,
+    includePricingFetch: true,
     includeProviderModelFilters: true,
     includeHistory: true,
+    includeSync: true,
     includeShare: false,
     includeTimezone: true
   },
   statusline: {
+    includeJson: false,
+    jsonAlternative: "use llm-usage summary --json",
+    includeQuiet: false,
     includeDateFilters: false,
     includeMarkdown: false,
     includePerModelColumns: false,
     includePricing: true,
+    includePricingFetch: false,
     includeProviderModelFilters: true,
     includeHistory: true,
+    includeSync: false,
     includeShare: false,
     includeTimezone: true
   },
   doctor: {
+    includeJson: true,
+    includeQuiet: true,
     includeDateFilters: false,
     includeMarkdown: false,
     includePerModelColumns: false,
     includePricing: false,
+    includePricingFetch: false,
     includeProviderModelFilters: false,
     includeHistory: false,
+    includeSync: false,
     includeShare: false,
     includeTimezone: false
   }
@@ -41200,6 +41872,20 @@ function suggestHiddenOptionsOnTypo(command) {
     }
   };
 }
+function redirectUnsupportedJson(command, alternative) {
+  if (!hasUnknownOptionHook(command)) {
+    return;
+  }
+  const reportUnknownOption = command.unknownOption.bind(command);
+  command.unknownOption = (flag) => {
+    if (flag === "--json") {
+      command.error(`error: --json is not supported for ${command.name()}; ${alternative}`, {
+        code: "commander.unknownOption"
+      });
+    }
+    reportUnknownOption(flag);
+  };
+}
 function registerSourcePathOptions(command) {
   for (const overrideOption of getSourceOverrideOptions()) {
     const option = new Option(
@@ -41216,7 +41902,7 @@ function registerSourcePathOptions(command) {
     command.help();
   }).addHelpText(
     "after",
-    () => hasHiddenOptions(command) ? "\nPer-source path flags (--claude-dir, --codex-dir, --opencode-db, ...) are\nlisted by --help-all." : ""
+    () => hasHiddenOptions(command) ? "\nPer-source path flags (--claude-dir, ...)\nare listed by --help-all." : ""
   );
   suggestHiddenOptionsOnTypo(command);
 }
@@ -41241,7 +41927,19 @@ function registerSharedReportOptions(command, profile) {
     "--source <name>",
     `Filter by source id (repeatable or comma-separated, supported sources ${supportedSourcesSummary})`,
     collectRepeatedOption
-  ).option("--json", "Render output as JSON").option("--quiet", "Suppress informational stderr output (warnings still print)").option(
+  );
+  if (profileConfig.includeJson) {
+    configuredCommand.option("--json", "Render output as JSON");
+  } else {
+    redirectUnsupportedJson(configuredCommand, profileConfig.jsonAlternative);
+  }
+  if (profileConfig.includeQuiet) {
+    configuredCommand.option(
+      "--quiet",
+      "Suppress informational stderr output (warnings still print)"
+    );
+  }
+  configuredCommand.option(
     "--verbose",
     "Print detailed diagnostics on stderr (per-source counts, routine skips, config, env)"
   );
@@ -41265,10 +41963,20 @@ function registerSharedReportOptions(command, profile) {
     );
   }
   if (profileConfig.includePricing) {
-    configuredCommand.option("--pricing-url <url>", "Override LiteLLM pricing source URL").option(
+    if (profileConfig.includePricingFetch) {
+      configuredCommand.option("--pricing-url <url>", "Override LiteLLM pricing source URL");
+    }
+    configuredCommand.option(
       "--pricing-overrides <path>",
       "Path to a JSON file of per-model pricing overrides (takes precedence over LiteLLM)"
-    ).option("--pricing-offline", "Use cached LiteLLM pricing only (no network fetch)").option(
+    );
+    if (profileConfig.includePricingFetch) {
+      configuredCommand.option(
+        "--pricing-offline",
+        "Use cached LiteLLM pricing only (no network fetch)"
+      );
+    }
+    configuredCommand.option(
       "--ignore-pricing-failures",
       "Continue without estimated costs when pricing cannot be loaded"
     );
@@ -41276,12 +41984,18 @@ function registerSharedReportOptions(command, profile) {
   if (profileConfig.includeHistory) {
     configuredCommand.option(
       "--history",
-      "include usage from files that no longer exist on disk (the default; fails if the event store is unavailable)"
-    ).option("--no-history", "leave out usage from files that no longer exist on disk").option(
+      "Include usage from files that no longer exist on disk (on by default; when passed, fails if the event store is unavailable)"
+    ).option("--no-history", "Leave out usage from files that no longer exist on disk").option(
       "--machine <name>",
       "Count only these machines (repeatable or comma-separated; local is this one; default: all)",
       collectRepeatedOption
-    ).option("--no-sync", "use other machines' cached usage without refreshing it over ssh");
+    );
+    if (profileConfig.includeSync) {
+      configuredCommand.option(
+        "--no-sync",
+        "Use other machines' cached usage without refreshing it over ssh"
+      );
+    }
   }
   if (profileConfig.includeMarkdown) {
     configuredCommand.option("--markdown", "Render output as markdown table");
@@ -41323,6 +42037,15 @@ function parseGranularityArgument(value) {
     `Invalid granularity: ${value}. Expected one of: ${GRANULARITY_ARGUMENT_VALUES.join(", ")}`
   );
 }
+function addGranularityArgument(command) {
+  const reportMissingGranularity = (name) => command.error(
+    `error: missing required argument '${name}' (choose ${GRANULARITY_ARGUMENT_VALUES.join(", ")})`,
+    { code: "commander.missingArgument" }
+  );
+  return Object.assign(command, { missingArgument: reportMissingGranularity }).addArgument(
+    new Argument("<granularity>", "Report period").choices(GRANULARITY_ARGUMENT_VALUES).argParser(parseGranularityArgument)
+  );
+}
 var MAX_COMMAND_HELP_EXAMPLES = 4;
 function formatHelpExamples(commands) {
   return commands.length === 0 ? "" : ["", "Examples:", ...commands.map((command) => `  $ ${command}`)].join("\n");
@@ -41507,7 +42230,7 @@ var efficiencyReportDefinition = {
     ]
   },
   register(command) {
-    command.argument("<granularity>", "Granularity: daily | weekly | monthly", parseGranularityArgument).option("--repo-dir <path>", "Path to repository for Git outcome metrics").option("--include-merge-commits", "Include merge commits in Git outcome metrics").option("--by-source", "Include per-source usage rows under each period").action(
+    addGranularityArgument(command).option("--repo-dir <path>", "Path to repository for Git outcome metrics").option("--include-merge-commits", "Include merge commits in Git outcome metrics").option("--by-source", "Include per-source usage rows under each period").action(
       (granularity, options) => runEfficiencyReport(granularity, options)
     );
     return command;
@@ -41557,7 +42280,7 @@ var optimizeReportDefinition = {
     ]
   },
   register(command) {
-    command.argument("<granularity>", "Granularity: daily | weekly | monthly", parseGranularityArgument).option(
+    addGranularityArgument(command).option(
       "--candidate-model <name>",
       "Candidate model for counterfactual pricing (repeatable or comma-separated)",
       collectRepeatedOption
@@ -41581,7 +42304,7 @@ var trendsReportDefinition = {
         includeInCliReference: true
       },
       {
-        command: "llm-usage trends --metric tokens --days 7",
+        command: "llm-usage trends --metric tokens --last 7",
         includeInCliReference: true
       },
       {
@@ -41592,9 +42315,9 @@ var trendsReportDefinition = {
   },
   register(command) {
     command.option(
-      "--days <n>",
-      "Trailing local calendar days to chart; defaults to 30 when no date flags are provided"
-    ).option("--metric <name>", "Trend metric: cost | tokens | active-hours", "cost").option(
+      "--last <n>",
+      "Chart the last N local calendar days, counting today; defaults to 30 when no date flags are provided"
+    ).addOption(new Option2("--days <n>", "Alias of --last").hideHelp()).option("--metric <name>", "Trend metric: cost | tokens | active-hours", "cost").option(
       "--by-source",
       "Render one sparkline row per source instead of a single combined chart"
     ).action((options) => runTrendsReport(options));
@@ -42015,7 +42738,7 @@ async function runMachineExport(options, deps = {}) {
     knownFiles
   );
   const end = lines.at(-1);
-  const missingEventCount = dataset.filteredEvents.length - (end?.type === "end" ? end.eventCount : 0);
+  const missingEventCount = dataset.filteredEvents.length + dataset.ledger.copiedEventCount - (end?.type === "end" ? end.eventCount : 0);
   if (missingEventCount > 0) {
     logger.warn(
       `machine export left out ${missingEventCount} event(s) that reports count but the event store does not hold`
@@ -44701,6 +45424,29 @@ function rejectUnknownCommand(program, args) {
 (Did you mean ${suggestion}?)` : "";
   program.error(`error: unknown command '${unknownCommand}'${hint}`);
 }
+var SIDE_BY_SIDE_MIN_DESCRIPTION_WIDTH = 40;
+var STACKED_DESCRIPTION_INDENT = "      ";
+function formatHelpItem(term, termWidth, description, helper) {
+  const helpWidth = this.helpWidth ?? 80;
+  const sideBySideWidth = helpWidth - termWidth - 4;
+  if (!description || sideBySideWidth >= SIDE_BY_SIDE_MIN_DESCRIPTION_WIDTH) {
+    return Help.prototype.formatItem.call(this, term, termWidth, description, helper);
+  }
+  const wrappedDescription = helper.boxWrap(
+    description,
+    helpWidth - STACKED_DESCRIPTION_INDENT.length
+  );
+  return [
+    `  ${term}`,
+    ...wrappedDescription.split("\n").map((line) => `${STACKED_DESCRIPTION_INDENT}${line}`)
+  ].join("\n");
+}
+function wrapHelpOnNarrowTerminals(command) {
+  command.configureHelp({ minWidthToWrap: 20, formatItem: formatHelpItem });
+  for (const subcommand of command.commands) {
+    wrapHelpOnNarrowTerminals(subcommand);
+  }
+}
 function createCli(options = {}) {
   const program = new Command6();
   program.name("llm-usage").description(createRootDescription()).version(options.version ?? "0.0.0").showHelpAfterError();
@@ -44736,6 +45482,7 @@ function createCli(options = {}) {
       setLogLevel("debug");
     }
   });
+  wrapHelpOnNarrowTerminals(program);
   return program;
 }