llm-usage-metrics 0.3.2 → 0.3.4

package/dist/index.js

@@ -138,6 +138,33 @@ function getUserCacheRootDir(env = process.env, platform = process.platform, hom
   return path.join(homedir, ".cache");
 }
 
+// src/utils/compare-by-code-point.ts
+function compareByCodePoint(left, right) {
+  if (left === right) {
+    return 0;
+  }
+  const leftIterator = left[Symbol.iterator]();
+  const rightIterator = right[Symbol.iterator]();
+  for (; ; ) {
+    const leftStep = leftIterator.next();
+    const rightStep = rightIterator.next();
+    if (leftStep.done && rightStep.done) {
+      return 0;
+    }
+    if (leftStep.done) {
+      return -1;
+    }
+    if (rightStep.done) {
+      return 1;
+    }
+    const leftCodePoint = leftStep.value.codePointAt(0) ?? 0;
+    const rightCodePoint = rightStep.value.codePointAt(0) ?? 0;
+    if (leftCodePoint !== rightCodePoint) {
+      return leftCodePoint < rightCodePoint ? -1 : 1;
+    }
+  }
+}
+
 // src/update/version-utils.ts
 function parseVersion(value) {
   const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/u.exec(
@@ -175,7 +202,7 @@ function comparePrereleaseIdentifiers(left, right) {
   if (!leftIsNumeric && rightIsNumeric) {
     return 1;
   }
-  return left.localeCompare(right);
+  return compareByCodePoint(left, right);
 }
 function isPrerelease(version) {
   const parsed = parseVersion(version);
@@ -427,7 +454,10 @@ async function resolveLatestVersion(options) {
 import { spawn } from "child_process";
 import { createInterface } from "readline/promises";
 function isInteractiveSession(options) {
-  return options.stdinIsTTY && options.stdoutIsTTY && !options.env.CI;
+  const ciValue = options.env.CI;
+  const normalizedCiValue = ciValue?.trim().toLowerCase();
+  const ciEnabled = normalizedCiValue !== void 0 && normalizedCiValue.length > 0 && !["0", "false", "no", "off"].includes(normalizedCiValue);
+  return options.stdinIsTTY && options.stdoutIsTTY && !ciEnabled;
 }
 async function defaultConfirmInstall(prompt) {
   const readline = createInterface({
@@ -496,9 +526,19 @@ async function runInteractiveInstallAndRestart(options) {
 
 // src/update/update-notifier.ts
 var UPDATE_CHECK_SKIP_ENV_VAR = "LLM_USAGE_SKIP_UPDATE_CHECK";
+function isTruthyEnvFlag(value) {
+  if (value === void 0) {
+    return false;
+  }
+  const normalizedValue = value.trim().toLowerCase();
+  if (normalizedValue.length === 0) {
+    return false;
+  }
+  return ["1", "true", "yes", "on"].includes(normalizedValue);
+}
 function shouldSkipUpdateCheckForArgv(argv) {
   const executableArgs = argv.slice(2);
-  const commandNames = /* @__PURE__ */ new Set(["daily", "weekly", "monthly", "help", "version"]);
+  const commandNames = /* @__PURE__ */ new Set(["daily", "weekly", "monthly", "efficiency", "help", "version"]);
   if (executableArgs.length === 0) {
     return false;
   }
@@ -518,7 +558,7 @@ function isLikelyNpxExecution(argv, env) {
     return true;
   }
   const npmCommand = env.npm_command ?? "";
-  return npmCommand === "exec";
+  return npmCommand === "exec" || npmCommand === "npx";
 }
 function isLikelySourceExecution(argv) {
   const executablePath = argv[1] ?? "";
@@ -539,7 +579,7 @@ function toResolveLatestVersionOptions(options, env) {
 async function checkForUpdatesAndMaybeRestart(options) {
   const env = options.env ?? process.env;
   const argv = options.argv ?? process.argv;
-  if (env[UPDATE_CHECK_SKIP_ENV_VAR] === "1") {
+  if (isTruthyEnvFlag(env[UPDATE_CHECK_SKIP_ENV_VAR])) {
     return { continueExecution: true };
   }
   if (shouldSkipUpdateCheckForArgv(argv)) {
@@ -588,33 +628,6 @@ import { Command } from "commander";
 import os2 from "os";
 import path4 from "path";
 
-// src/utils/compare-by-code-point.ts
-function compareByCodePoint(left, right) {
-  if (left === right) {
-    return 0;
-  }
-  const leftIterator = left[Symbol.iterator]();
-  const rightIterator = right[Symbol.iterator]();
-  for (; ; ) {
-    const leftStep = leftIterator.next();
-    const rightStep = rightIterator.next();
-    if (leftStep.done && rightStep.done) {
-      return 0;
-    }
-    if (leftStep.done) {
-      return -1;
-    }
-    if (rightStep.done) {
-      return 1;
-    }
-    const leftCodePoint = leftStep.value.codePointAt(0) ?? 0;
-    const rightCodePoint = rightStep.value.codePointAt(0) ?? 0;
-    if (leftCodePoint !== rightCodePoint) {
-      return leftCodePoint < rightCodePoint ? -1 : 1;
-    }
-  }
-}
-
 // src/domain/normalization.ts
 function normalizeNonNegativeInteger(value) {
   if (value === null || value === void 0) {
@@ -683,6 +696,9 @@ function normalizeOptionalText(value) {
   const normalized = value.trim();
   return normalized || void 0;
 }
+function normalizeOptionalPath(value) {
+  return normalizeOptionalText(value);
+}
 function normalizeOptionalModel(value) {
   const normalized = normalizeOptionalText(value);
   if (!normalized) {
@@ -718,6 +734,7 @@ function createUsageEvent(input) {
     source,
     sessionId: requireText(input.sessionId, "sessionId"),
     timestamp: normalizeTimestamp(input.timestamp),
+    repoRoot: normalizeOptionalPath(input.repoRoot),
     provider: normalizeOptionalText(input.provider),
     model: normalizeOptionalModel(input.model),
     inputTokens,
@@ -731,7 +748,7 @@ function createUsageEvent(input) {
   };
 }
 
-// src/utils/discover-jsonl-files.ts
+// src/utils/discover-files.ts
 import { readdir } from "fs/promises";
 import path3 from "path";
 function getNodeErrorCode(error) {
@@ -742,39 +759,103 @@ function isSkippableDirectoryReadError(error) {
   const code = getNodeErrorCode(error);
   return code === "EACCES" || code === "EPERM";
 }
+function matchesExtension(fileName, extension) {
+  const lowerFileName = fileName.toLowerCase();
+  const lowerExtension = extension.toLowerCase();
+  return lowerFileName.endsWith(lowerExtension);
+}
+function normalizeExtension(extension) {
+  const normalized = extension.trim();
+  if (!normalized) {
+    throw new Error("discoverFiles extension must be a non-empty string");
+  }
+  if (!normalized.startsWith(".")) {
+    throw new Error('discoverFiles extension must start with "."');
+  }
+  return normalized;
+}
 async function walkDirectory(rootDir, acc, options) {
   let entries;
   try {
     entries = await readdir(rootDir, { withFileTypes: true, encoding: "utf8" });
   } catch (error) {
+    if (getNodeErrorCode(error) === "ENOENT") {
+      return;
+    }
     if (options.allowPermissionSkip && isSkippableDirectoryReadError(error)) {
       return;
     }
     throw error;
   }
-  entries.sort((left, right) => left.name.localeCompare(right.name));
+  if (options.sort) {
+    entries.sort((left, right) => compareByCodePoint(left.name, right.name));
+  }
   for (const entry of entries) {
     const entryPath = path3.join(rootDir, entry.name);
-    if (entry.isDirectory()) {
-      await walkDirectory(entryPath, acc, { allowPermissionSkip: true });
+    if (entry.isDirectory() && options.recursive) {
+      await walkDirectory(entryPath, acc, options);
       continue;
     }
-    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+    if (entry.isFile() && matchesExtension(entry.name, options.extension)) {
       acc.push(entryPath);
     }
   }
 }
-async function discoverJsonlFiles(rootDir) {
+async function discoverFiles(rootDir, options) {
   const files = [];
+  const resolvedOptions = {
+    extension: normalizeExtension(options.extension),
+    recursive: options.recursive ?? true,
+    allowPermissionSkip: options.allowPermissionSkip ?? true,
+    sort: options.sort ?? true
+  };
+  await walkDirectory(rootDir, files, resolvedOptions);
+  return files;
+}
+
+// src/utils/discover-jsonl-files.ts
+async function discoverJsonlFiles(rootDir) {
+  return discoverFiles(rootDir, { extension: ".jsonl" });
+}
+
+// src/utils/fs-helpers.ts
+import { access, constants, stat } from "fs/promises";
+async function pathExists(filePath) {
   try {
-    await walkDirectory(rootDir, files, { allowPermissionSkip: false });
-  } catch (error) {
-    if (getNodeErrorCode(error) === "ENOENT") {
-      return [];
-    }
-    throw error;
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pathReadable(filePath) {
+  try {
+    await access(filePath, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pathIsDirectory(filePath) {
+  try {
+    return (await stat(filePath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function pathIsFile(filePath) {
+  try {
+    return (await stat(filePath)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function pathStat(filePath) {
+  try {
+    return await stat(filePath);
+  } catch {
+    return void 0;
   }
-  return files;
 }
 
 // src/utils/read-jsonl-objects.ts
@@ -826,6 +907,9 @@ function asTrimmedText(value) {
   const normalized = value.trim();
   return normalized || void 0;
 }
+function isBlankText(value) {
+  return value.trim().length === 0;
+}
 function toNumberLike(value) {
   if (value === null || value === void 0 || typeof value === "number" || typeof value === "string") {
     return value;
@@ -902,14 +986,37 @@ function deriveDeltaUsage(info, previousTotalUsage) {
 function getFallbackSessionId(filePath) {
   return path4.basename(filePath, ".jsonl");
 }
+function resolveRepoRootFromPayload(payload) {
+  if (!payload) {
+    return void 0;
+  }
+  return asTrimmedText(payload.cwd) ?? asTrimmedText(payload.repo_root) ?? asTrimmedText(payload.repoRoot) ?? asTrimmedText(payload.project_root) ?? asTrimmedText(payload.projectRoot);
+}
 var CodexSourceAdapter = class {
   id = "codex";
   sessionsDir;
+  requireSessionsDir;
   constructor(options = {}) {
     this.sessionsDir = options.sessionsDir ?? defaultSessionsDir;
+    this.requireSessionsDir = options.requireSessionsDir ?? false;
   }
   async discoverFiles() {
-    return discoverJsonlFiles(this.sessionsDir);
+    if (isBlankText(this.sessionsDir)) {
+      throw new Error("Codex sessions directory must be a non-empty path");
+    }
+    const normalizedSessionsDir = this.sessionsDir.trim();
+    if (this.requireSessionsDir) {
+      const sessionsDirStats = await pathStat(normalizedSessionsDir);
+      if (!sessionsDirStats) {
+        throw new Error(
+          `Codex sessions directory is missing or unreadable: ${normalizedSessionsDir}`
+        );
+      }
+      if (!sessionsDirStats.isDirectory()) {
+        throw new Error(`Codex sessions directory is not a directory: ${normalizedSessionsDir}`);
+      }
+    }
+    return discoverJsonlFiles(normalizedSessionsDir);
   }
   async parseFile(filePath) {
     const events = [];
@@ -924,11 +1031,13 @@ var CodexSourceAdapter = class {
         const payload2 = asRecord(line.payload);
         state.sessionId = asTrimmedText(payload2?.id) ?? state.sessionId;
         state.provider = asTrimmedText(payload2?.model_provider) ?? state.provider;
+        state.repoRoot = resolveRepoRootFromPayload(payload2) ?? state.repoRoot;
         continue;
       }
       if (line.type === "turn_context") {
         const payload2 = asRecord(line.payload);
         state.model = asTrimmedText(payload2?.model) ?? state.model;
+        state.repoRoot = resolveRepoRootFromPayload(payload2) ?? state.repoRoot;
         continue;
       }
       if (line.type !== "event_msg") {
@@ -959,6 +1068,7 @@ var CodexSourceAdapter = class {
             source: this.id,
             sessionId: state.sessionId,
             timestamp,
+            repoRoot: state.repoRoot,
             provider: state.provider,
             model,
             inputTokens: deltaUsage.inputTokens,
@@ -984,48 +1094,294 @@ var CodexSourceAdapter = class {
   }
 };
 
-// src/sources/opencode/opencode-source-adapter.ts
-import { access, constants } from "fs/promises";
-
-// src/sources/opencode/opencode-db-path-resolver.ts
+// src/sources/gemini/gemini-source-adapter.ts
+import { readFile as readFile2 } from "fs/promises";
 import os3 from "os";
 import path5 from "path";
+var defaultGeminiDir = path5.join(os3.homedir(), ".gemini");
+function parseProjectsJson(data) {
+  const mapping = /* @__PURE__ */ new Map();
+  const record = asRecord(data);
+  if (!record) {
+    return mapping;
+  }
+  const projects = asRecord(record.projects);
+  if (!projects) {
+    return mapping;
+  }
+  for (const [key, value] of Object.entries(projects)) {
+    const projectEntry = asRecord(value);
+    const absolutePath = asTrimmedText(projectEntry?.absolutePath);
+    if (absolutePath) {
+      mapping.set(key, absolutePath);
+    }
+  }
+  return mapping;
+}
+async function loadProjectsJson(geminiDir) {
+  const projectsPath = path5.join(geminiDir, "projects.json");
+  try {
+    const content = await readFile2(projectsPath, "utf8");
+    const parsed = JSON.parse(content);
+    return parseProjectsJson(parsed);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+async function discoverSessionFiles(geminiDir) {
+  const tmpDir = path5.join(geminiDir, "tmp");
+  const allSessionFiles = [];
+  const discoveredFiles = await discoverFiles(tmpDir, { extension: ".json" });
+  for (const filePath of discoveredFiles) {
+    const parentDir = path5.basename(path5.dirname(filePath));
+    if (parentDir.toLowerCase() === "chats") {
+      allSessionFiles.push(filePath);
+    }
+  }
+  return allSessionFiles;
+}
+function resolveRepoRoot(filePath, sessionData, projectMapping) {
+  const projectHash = asTrimmedText(sessionData.projectHash);
+  if (projectHash) {
+    const mappedRoot = projectMapping.get(projectHash);
+    if (mappedRoot) {
+      return mappedRoot;
+    }
+  }
+  const chatsDir = path5.dirname(filePath);
+  const projectDir = path5.dirname(chatsDir);
+  const projectIdentifier = path5.basename(projectDir);
+  return projectMapping.get(projectIdentifier);
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+function extractTokenUsage(tokens) {
+  if (!tokens) {
+    return null;
+  }
+  const input = Math.max(0, toFiniteNumber(tokens.input) ?? 0);
+  const tool = Math.max(0, toFiniteNumber(tokens.tool) ?? 0);
+  const output = Math.max(0, toFiniteNumber(tokens.output) ?? 0);
+  const thoughts = Math.max(0, toFiniteNumber(tokens.thoughts) ?? 0);
+  const cached = Math.max(0, toFiniteNumber(tokens.cached) ?? 0);
+  const inputTokens = input + tool;
+  const outputTokens = output;
+  const reasoningTokens = thoughts;
+  const cacheReadTokens = cached;
+  const declaredTotal = Math.max(0, toFiniteNumber(tokens.total) ?? 0);
+  const componentTotal = inputTokens + outputTokens + reasoningTokens + cacheReadTokens;
+  const totalTokens = declaredTotal > 0 ? declaredTotal : componentTotal;
+  if (inputTokens === 0 && outputTokens === 0 && reasoningTokens === 0 && cached === 0) {
+    return null;
+  }
+  return {
+    inputTokens,
+    outputTokens,
+    reasoningTokens,
+    cacheReadTokens,
+    totalTokens
+  };
+}
+function incrementSkippedReason(reasons, reason) {
+  const current = reasons.get(reason) ?? 0;
+  reasons.set(reason, current + 1);
+}
+function toSkippedRowReasonStats(reasons) {
+  return [...reasons.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right) => compareByCodePoint(left.reason, right.reason));
+}
+function toParseDiagnostics(events, skippedRows, skippedRowReasons) {
+  return {
+    events,
+    skippedRows,
+    skippedRowReasons: toSkippedRowReasonStats(skippedRowReasons)
+  };
+}
+function normalizeTimestamp2(candidate) {
+  if (typeof candidate !== "string" || isBlankText(candidate)) {
+    return void 0;
+  }
+  const date = new Date(candidate.trim());
+  if (Number.isNaN(date.getTime())) {
+    return void 0;
+  }
+  return date.toISOString();
+}
+var GeminiSourceAdapter = class {
+  id = "gemini";
+  geminiDir;
+  requireGeminiDir;
+  projectMapping = null;
+  constructor(options = {}) {
+    this.geminiDir = options.geminiDir ?? defaultGeminiDir;
+    this.requireGeminiDir = options.requireGeminiDir ?? false;
+  }
+  getNormalizedGeminiDir() {
+    if (isBlankText(this.geminiDir)) {
+      throw new Error("Gemini directory must be a non-empty path");
+    }
+    return this.geminiDir.trim();
+  }
+  async getProjectMapping(normalizedGeminiDir) {
+    if (this.projectMapping) {
+      return this.projectMapping;
+    }
+    this.projectMapping = await loadProjectsJson(normalizedGeminiDir);
+    return this.projectMapping;
+  }
+  async getProjectMappingForParse() {
+    if (this.projectMapping) {
+      return this.projectMapping;
+    }
+    if (isBlankText(this.geminiDir)) {
+      return /* @__PURE__ */ new Map();
+    }
+    this.projectMapping = await loadProjectsJson(this.geminiDir.trim());
+    return this.projectMapping;
+  }
+  async discoverFiles() {
+    const normalizedDir = this.getNormalizedGeminiDir();
+    if (this.requireGeminiDir && !await pathReadable(normalizedDir)) {
+      throw new Error(`Gemini directory is missing or unreadable: ${normalizedDir}`);
+    }
+    if (this.requireGeminiDir && !await pathIsDirectory(normalizedDir)) {
+      throw new Error(`Gemini directory is not a directory: ${normalizedDir}`);
+    }
+    await this.getProjectMapping(normalizedDir);
+    return discoverSessionFiles(normalizedDir);
+  }
+  async parseFile(filePath) {
+    const { events } = await this.parseFileWithDiagnostics(filePath);
+    return events;
+  }
+  async parseFileWithDiagnostics(filePath) {
+    const events = [];
+    let skippedRows = 0;
+    const skippedRowReasons = /* @__PURE__ */ new Map();
+    let sessionData;
+    try {
+      const content = await readFile2(filePath, "utf8");
+      sessionData = JSON.parse(content);
+    } catch {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "json_parse_error");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    const sessionDataRecord = asRecord(sessionData);
+    if (!sessionDataRecord) {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "invalid_session_data");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    const sessionId = asTrimmedText(sessionDataRecord.sessionId) ?? path5.basename(filePath, ".json");
+    const projectMapping = await this.getProjectMappingForParse();
+    const repoRoot = resolveRepoRoot(filePath, sessionDataRecord, projectMapping);
+    if (!Array.isArray(sessionDataRecord.messages)) {
+      skippedRows++;
+      incrementSkippedReason(skippedRowReasons, "invalid_messages_array");
+      return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+    }
+    const messages = sessionDataRecord.messages;
+    for (const rawMessage of messages) {
+      const message = asRecord(rawMessage);
+      if (!message) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "invalid_message");
+        continue;
+      }
+      if (message.type !== "gemini") {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "non_gemini_message");
+        continue;
+      }
+      const tokens = extractTokenUsage(asRecord(message.tokens));
+      if (!tokens) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "no_token_usage");
+        continue;
+      }
+      const timestamp = normalizeTimestamp2(message.timestamp);
+      if (!timestamp) {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "invalid_timestamp");
+        continue;
+      }
+      const model = asTrimmedText(message.model);
+      try {
+        events.push(
+          createUsageEvent({
+            source: this.id,
+            sessionId,
+            timestamp,
+            repoRoot,
+            provider: "google",
+            model,
+            ...tokens,
+            costMode: "estimated"
+          })
+        );
+      } catch {
+        skippedRows++;
+        incrementSkippedReason(skippedRowReasons, "event_creation_failed");
+      }
+    }
+    return toParseDiagnostics(events, skippedRows, skippedRowReasons);
+  }
+};
+
+// src/sources/opencode/opencode-db-path-resolver.ts
+import os4 from "os";
+import path6 from "path";
 function deduplicate(paths) {
   return [...new Set(paths)];
 }
 function getLinuxLikeCandidates(homeDir, env) {
-  const xdgDataHome = env.XDG_DATA_HOME ?? path5.join(homeDir, ".local", "share");
+  const xdgDataHome = env.XDG_DATA_HOME ?? path6.join(homeDir, ".local", "share");
   return [
-    path5.join(xdgDataHome, "opencode", "opencode.db"),
-    path5.join(xdgDataHome, "opencode", "db.sqlite"),
-    path5.join(homeDir, ".opencode", "opencode.db"),
-    path5.join(homeDir, ".opencode", "db.sqlite")
+    path6.join(xdgDataHome, "opencode", "opencode.db"),
+    path6.join(xdgDataHome, "opencode", "db.sqlite"),
+    path6.join(homeDir, ".opencode", "opencode.db"),
+    path6.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getMacOsCandidates(homeDir) {
-  const appSupportDir = path5.join(homeDir, "Library", "Application Support");
+  const appSupportDir = path6.join(homeDir, "Library", "Application Support");
   return [
-    path5.join(appSupportDir, "opencode", "opencode.db"),
-    path5.join(appSupportDir, "opencode", "db.sqlite"),
-    path5.join(homeDir, ".opencode", "opencode.db"),
-    path5.join(homeDir, ".opencode", "db.sqlite")
+    path6.join(appSupportDir, "opencode", "opencode.db"),
+    path6.join(appSupportDir, "opencode", "db.sqlite"),
+    path6.join(homeDir, ".opencode", "opencode.db"),
+    path6.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getWindowsCandidates(homeDir, env) {
-  const roamingBase = env.APPDATA ?? env.LOCALAPPDATA ?? (env.USERPROFILE ? path5.join(env.USERPROFILE, "AppData", "Roaming") : void 0);
+  const roamingBase = env.APPDATA ?? env.LOCALAPPDATA ?? (env.USERPROFILE ? path6.join(env.USERPROFILE, "AppData", "Roaming") : void 0);
   const roamingCandidates = roamingBase ? [
-    path5.join(roamingBase, "opencode", "opencode.db"),
-    path5.join(roamingBase, "opencode", "db.sqlite")
+    path6.join(roamingBase, "opencode", "opencode.db"),
+    path6.join(roamingBase, "opencode", "db.sqlite")
   ] : [];
   return [
     ...roamingCandidates,
-    path5.join(homeDir, ".opencode", "opencode.db"),
-    path5.join(homeDir, ".opencode", "db.sqlite")
+    path6.join(homeDir, ".opencode", "opencode.db"),
+    path6.join(homeDir, ".opencode", "db.sqlite")
   ];
 }
 function getDefaultOpenCodeDbPathCandidates(options = {}) {
   const platform = options.platform ?? process.platform;
-  const homeDir = options.homeDir ?? os3.homedir();
+  const homeDir = options.homeDir ?? os4.homedir();
   const env = options.env ?? process.env;
   switch (platform) {
     case "win32":
@@ -1153,6 +1509,10 @@ function normalizeSessionIdCandidate(value) {
   }
   return asTrimmedText(value);
 }
+function resolveRepoRoot2(messagePayload) {
+  const pathPayload = asRecord(messagePayload.path);
+  return asTrimmedText(pathPayload?.root) ?? asTrimmedText(pathPayload?.cwd) ?? asTrimmedText(messagePayload.cwd) ?? asTrimmedText(messagePayload.repo_root) ?? asTrimmedText(messagePayload.repoRoot) ?? asTrimmedText(messagePayload.project_root) ?? asTrimmedText(messagePayload.projectRoot);
+}
 function hasUsageSignal2(usageFields, explicitCost) {
   if (explicitCost !== void 0) {
     return true;
@@ -1204,6 +1564,7 @@ function parseOpenCodeMessageRows(rows, sourceId) {
     }
     const provider = asTrimmedText(payload.providerID) ?? asTrimmedText(payload.provider);
     const model = asTrimmedText(payload.modelID) ?? asTrimmedText(payload.model);
+    const repoRoot = resolveRepoRoot2(payload);
     const tokens = asRecord(payload.tokens);
     const tokenCache = asRecord(tokens?.cache);
     const inputTokens = toNumberLike(tokens?.input);
@@ -1233,6 +1594,7 @@ function parseOpenCodeMessageRows(rows, sourceId) {
           source: sourceId,
           sessionId,
           timestamp,
+          repoRoot,
           provider,
           model,
           inputTokens,
@@ -1428,25 +1790,9 @@ function queryOpenCodeMessageRows(database) {
 // src/sources/opencode/opencode-source-adapter.ts
 var DEFAULT_BUSY_RETRY_COUNT = 2;
 var DEFAULT_BUSY_RETRY_DELAY_MS = 50;
-function isBlankText(value) {
+function isBlankText2(value) {
   return value.trim().length === 0;
 }
-async function pathExists(filePath) {
-  try {
-    await access(filePath, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function pathReadable(filePath) {
-  try {
-    await access(filePath, constants.R_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function sleep2(delayMs) {
   await new Promise((resolve) => {
     setTimeout(resolve, delayMs);
@@ -1458,6 +1804,7 @@ var OpenCodeSourceAdapter = class {
   resolveDefaultDbPaths;
   pathExists;
   pathReadable;
+  pathIsFile;
   loadSqliteModule;
   maxBusyRetries;
   busyRetryDelayMs;
@@ -1467,6 +1814,7 @@ var OpenCodeSourceAdapter = class {
     this.resolveDefaultDbPaths = options.resolveDefaultDbPaths ?? getDefaultOpenCodeDbPathCandidates;
     this.pathExists = options.pathExists ?? pathExists;
     this.pathReadable = options.pathReadable ?? pathReadable;
+    this.pathIsFile = options.pathIsFile ?? pathIsFile;
     this.loadSqliteModule = options.loadSqliteModule ?? loadNodeSqliteModule;
     this.maxBusyRetries = Math.max(0, options.maxBusyRetries ?? DEFAULT_BUSY_RETRY_COUNT);
     this.busyRetryDelayMs = Math.max(1, options.busyRetryDelayMs ?? DEFAULT_BUSY_RETRY_DELAY_MS);
@@ -1474,7 +1822,7 @@ var OpenCodeSourceAdapter = class {
   }
   async discoverFiles() {
     if (this.explicitDbPath !== void 0) {
-      if (isBlankText(this.explicitDbPath)) {
+      if (isBlankText2(this.explicitDbPath)) {
         throw new Error("--opencode-db must be a non-empty path");
       }
       const explicitDbPath = this.explicitDbPath.trim();
@@ -1482,11 +1830,17 @@ var OpenCodeSourceAdapter = class {
       if (!readable) {
         throw new Error(`OpenCode DB path is missing or unreadable: ${explicitDbPath}`);
       }
+      if (await this.pathExists(explicitDbPath) && !await this.pathIsFile(explicitDbPath)) {
+        throw new Error(`OpenCode DB path is not a file: ${explicitDbPath}`);
+      }
       return [explicitDbPath];
     }
     let firstUnreadableCandidatePath;
     for (const candidatePath of this.resolveDefaultDbPaths()) {
       if (await this.pathReadable(candidatePath)) {
+        if (await this.pathExists(candidatePath) && !await this.pathIsFile(candidatePath)) {
+          throw new Error(`OpenCode DB path is not a file: ${candidatePath}`);
+        }
         return [candidatePath];
       }
       if (!firstUnreadableCandidatePath && await this.pathExists(candidatePath)) {
@@ -1503,7 +1857,7 @@ var OpenCodeSourceAdapter = class {
     return parseDiagnostics.events;
   }
   async parseFileWithDiagnostics(dbPath) {
-    if (isBlankText(dbPath)) {
+    if (isBlankText2(dbPath)) {
       throw new Error("OpenCode DB path must be a non-empty path");
     }
     const normalizedDbPath = dbPath.trim();
@@ -1511,6 +1865,9 @@ var OpenCodeSourceAdapter = class {
     if (!readable) {
       throw new Error(`OpenCode DB path is unreadable: ${normalizedDbPath}`);
     }
+    if (await this.pathExists(normalizedDbPath) && !await this.pathIsFile(normalizedDbPath)) {
+      throw new Error(`OpenCode DB path is not a file: ${normalizedDbPath}`);
+    }
     return runWithBusyRetries(() => this.parseFileOnce(normalizedDbPath), {
       dbPath: normalizedDbPath,
       maxBusyRetries: this.maxBusyRetries,
@@ -1531,9 +1888,9 @@ var OpenCodeSourceAdapter = class {
 };
 
 // src/sources/pi/pi-source-adapter.ts
-import os4 from "os";
-import path6 from "path";
-var defaultSessionsDir2 = path6.join(os4.homedir(), ".pi", "agent", "sessions");
+import os5 from "os";
+import path7 from "path";
+var defaultSessionsDir2 = path7.join(os5.homedir(), ".pi", "agent", "sessions");
 var PI_MESSAGE_LINE_PATTERN = /"type"\s*:\s*"message"/u;
 var PI_SESSION_LINE_PATTERN = /"type"\s*:\s*"session"/u;
 var PI_MODEL_CHANGE_LINE_PATTERN = /"type"\s*:\s*"model_change"/u;
@@ -1582,14 +1939,40 @@ function extractUsageFromRecord(usage) {
     totalTokens: toNumberLike(usage.totalTokens),
     costUsd: toNumberLike(cost?.total)
   };
-  const hasKnownUsageField = extracted.inputTokens !== void 0 || extracted.outputTokens !== void 0 || extracted.reasoningTokens !== void 0 || extracted.cacheReadTokens !== void 0 || extracted.cacheWriteTokens !== void 0 || extracted.totalTokens !== void 0 || extracted.costUsd !== void 0;
-  return hasKnownUsageField ? extracted : void 0;
-}
-function extractUsage(line, message) {
-  const lineUsage = asRecord(line.usage);
-  const messageUsage = asRecord(message?.usage);
-  if (lineUsage) {
-    const extractedLineUsage = extractUsageFromRecord(lineUsage);
+  const toFiniteNumber2 = (value) => {
+    if (value === null || value === void 0) {
+      return void 0;
+    }
+    if (typeof value === "string" && value.trim().length === 0) {
+      return void 0;
+    }
+    const parsed = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(parsed)) {
+      return void 0;
+    }
+    return parsed;
+  };
+  const usageCandidates = [
+    extracted.inputTokens,
+    extracted.outputTokens,
+    extracted.reasoningTokens,
+    extracted.cacheReadTokens,
+    extracted.cacheWriteTokens,
+    extracted.totalTokens
+  ];
+  const hasPositiveUsageSignal = usageCandidates.some((value) => {
+    const parsed = toFiniteNumber2(value);
+    return parsed !== void 0 && parsed > 0;
+  });
+  const explicitCost = toFiniteNumber2(extracted.costUsd);
+  const hasPositiveCostSignal = explicitCost !== void 0 && explicitCost > 0;
+  return hasPositiveUsageSignal || hasPositiveCostSignal ? extracted : void 0;
+}
+function extractUsage(line, message) {
+  const lineUsage = asRecord(line.usage);
+  const messageUsage = asRecord(message?.usage);
+  if (lineUsage) {
+    const extractedLineUsage = extractUsageFromRecord(lineUsage);
     if (extractedLineUsage) {
       return extractedLineUsage;
     }
@@ -1600,18 +1983,37 @@ function extractUsage(line, message) {
   return extractUsageFromRecord(messageUsage);
 }
 function getFallbackSessionId2(filePath) {
-  return path6.basename(filePath, ".jsonl");
+  return path7.basename(filePath, ".jsonl");
+}
+function resolveRepoRootFromRecord(record) {
+  if (!record) {
+    return void 0;
+  }
+  const pathRecord = asRecord(record.path);
+  return asTrimmedText(pathRecord?.root) ?? asTrimmedText(pathRecord?.cwd) ?? asTrimmedText(record.cwd) ?? asTrimmedText(record.repo_root) ?? asTrimmedText(record.repoRoot) ?? asTrimmedText(record.project_root) ?? asTrimmedText(record.projectRoot);
 }
 var PiSourceAdapter = class {
   id = "pi";
   sessionsDir;
   providerFilter;
+  requireSessionsDir;
   constructor(options = {}) {
     this.sessionsDir = options.sessionsDir ?? defaultSessionsDir2;
     this.providerFilter = options.providerFilter ?? allowAllProviders;
+    this.requireSessionsDir = options.requireSessionsDir ?? false;
   }
   async discoverFiles() {
-    return discoverJsonlFiles(this.sessionsDir);
+    if (isBlankText(this.sessionsDir)) {
+      throw new Error("PI sessions directory must be a non-empty path");
+    }
+    const normalizedSessionsDir = this.sessionsDir.trim();
+    if (this.requireSessionsDir && !await pathReadable(normalizedSessionsDir)) {
+      throw new Error(`PI sessions directory is missing or unreadable: ${normalizedSessionsDir}`);
+    }
+    if (this.requireSessionsDir && !await pathIsDirectory(normalizedSessionsDir)) {
+      throw new Error(`PI sessions directory is not a directory: ${normalizedSessionsDir}`);
+    }
+    return discoverJsonlFiles(normalizedSessionsDir);
   }
   async parseFile(filePath) {
     const events = [];
@@ -1622,11 +2024,13 @@ var PiSourceAdapter = class {
       if (line.type === "session") {
         state.sessionId = asTrimmedText(line.id) ?? state.sessionId;
         state.sessionTimestamp = asTrimmedText(line.timestamp) ?? state.sessionTimestamp;
+        state.repoRoot = resolveRepoRootFromRecord(line) ?? state.repoRoot;
         continue;
       }
       if (line.type === "model_change") {
         state.provider = asTrimmedText(line.provider) ?? state.provider;
         state.model = asTrimmedText(line.modelId) ?? asTrimmedText(line.model) ?? state.model;
+        state.repoRoot = resolveRepoRootFromRecord(line) ?? state.repoRoot;
         continue;
       }
       if (line.type !== "message") {
@@ -1646,12 +2050,14 @@ var PiSourceAdapter = class {
         continue;
       }
       const model = asTrimmedText(line.model) ?? asTrimmedText(line.modelId) ?? asTrimmedText(message?.model) ?? state.model;
+      const repoRoot = resolveRepoRootFromRecord(line) ?? resolveRepoRootFromRecord(message) ?? state.repoRoot;
       try {
         events.push(
           createUsageEvent({
             source: this.id,
             sessionId: state.sessionId,
             timestamp,
+            repoRoot,
             provider,
             model,
             ...usage
@@ -1692,16 +2098,43 @@ var sourceRegistrations = [
   {
     id: "pi",
     sourceDirOverride: { kind: "directory" },
-    create: (options, sourceDirectoryOverrides) => new PiSourceAdapter({
-      sessionsDir: resolveDirectoryOverride("pi", options.piDir, sourceDirectoryOverrides)
-    })
+    create: (options, sourceDirectoryOverrides) => {
+      const directoryConfig = resolveDirectoryConfig("pi", options.piDir, sourceDirectoryOverrides);
+      return new PiSourceAdapter({
+        sessionsDir: directoryConfig.path,
+        requireSessionsDir: directoryConfig.requireExistingPath
+      });
+    }
   },
   {
     id: "codex",
     sourceDirOverride: { kind: "directory" },
-    create: (options, sourceDirectoryOverrides) => new CodexSourceAdapter({
-      sessionsDir: resolveDirectoryOverride("codex", options.codexDir, sourceDirectoryOverrides)
-    })
+    create: (options, sourceDirectoryOverrides) => {
+      const directoryConfig = resolveDirectoryConfig(
+        "codex",
+        options.codexDir,
+        sourceDirectoryOverrides
+      );
+      return new CodexSourceAdapter({
+        sessionsDir: directoryConfig.path,
+        requireSessionsDir: directoryConfig.requireExistingPath
+      });
+    }
+  },
+  {
+    id: "gemini",
+    sourceDirOverride: { kind: "directory" },
+    create: (options, sourceDirectoryOverrides) => {
+      const directoryConfig = resolveDirectoryConfig(
+        "gemini",
+        options.geminiDir,
+        sourceDirectoryOverrides
+      );
+      return new GeminiSourceAdapter({
+        geminiDir: directoryConfig.path,
+        requireGeminiDir: directoryConfig.requireExistingPath
+      });
+    }
   },
   {
     id: "opencode",
@@ -1736,9 +2169,7 @@ function validateSourceDirectoryOverrideIds(sourceDirectoryOverrides) {
   if (unknownSourceIds.length === 0) {
     return;
   }
-  const allowedSourceIds = [...sourceDirSupportedIds].sort(
-    (left, right) => left.localeCompare(right)
-  );
+  const allowedSourceIds = [...sourceDirSupportedIds].sort(compareByCodePoint);
   throw new Error(
     `Unknown --source-dir source id(s): ${unknownSourceIds.join(", ")}. Allowed values: ${allowedSourceIds.join(", ")}`
   );
@@ -1751,14 +2182,41 @@ function validateOpencodeOverride(opencodeDb) {
     throw new Error("--opencode-db must be a non-empty path");
   }
 }
-function resolveDirectoryOverride(sourceId, explicitDirectory, sourceDirectoryOverrides) {
-  return explicitDirectory ?? sourceDirectoryOverrides.get(sourceId);
+function validateDirectoryOverride(optionName, value) {
+  if (value === void 0) {
+    return;
+  }
+  if (value.trim().length === 0) {
+    throw new Error(`${optionName} must be a non-empty path`);
+  }
+}
+function resolveDirectoryConfig(sourceId, explicitDirectory, sourceDirectoryOverrides) {
+  if (explicitDirectory !== void 0) {
+    return {
+      path: explicitDirectory,
+      requireExistingPath: true
+    };
+  }
+  const sourceDirOverride = sourceDirectoryOverrides.get(sourceId);
+  if (sourceDirOverride !== void 0) {
+    return {
+      path: sourceDirOverride,
+      requireExistingPath: true
+    };
+  }
+  return {
+    path: void 0,
+    requireExistingPath: false
+  };
 }
 function getDefaultSourceIds() {
   return sourceRegistrations.map((source) => source.id);
 }
 function createDefaultAdapters(options) {
   validateOpencodeOverride(options.opencodeDb);
+  validateDirectoryOverride("--pi-dir", options.piDir);
+  validateDirectoryOverride("--codex-dir", options.codexDir);
+  validateDirectoryOverride("--gemini-dir", options.geminiDir);
   const sourceDirectoryOverrides = parseSourceDirectoryOverrides(options.sourceDir);
   validateSourceDirectoryOverrideIds(sourceDirectoryOverrides);
   return sourceRegistrations.map((source) => source.create(options, sourceDirectoryOverrides));
@@ -1934,7 +2392,7 @@ function aggregateUsage(events, options) {
     periodSources.set(event.source, rowAccumulator);
     addEventToAccumulator(rowAccumulator, event);
   }
-  const sortedPeriodKeys = [...periodMap.keys()].sort((left, right) => left.localeCompare(right));
+  const sortedPeriodKeys = [...periodMap.keys()].sort(compareByCodePoint);
   const rows = [];
   const grandTotals = createEmptyTotals();
   const grandModelTotals = /* @__PURE__ */ new Map();
@@ -1976,20 +2434,644 @@ function aggregateUsage(events, options) {
         modelBreakdown: toModelUsageBreakdown(periodCombinedModelTotals),
         ...periodCombinedTotals
       };
-      rows.push(combinedRow);
+      rows.push(combinedRow);
+    }
+  }
+  const finalizedGrandTotals = events.length === 0 && grandTotals.costUsd === void 0 && grandTotals.costIncomplete !== true ? { ...grandTotals, costUsd: 0 } : grandTotals;
+  const grandTotalRow = {
+    rowType: "grand_total",
+    periodKey: "ALL",
+    source: "combined",
+    models: normalizeModelList(grandModelTotals.keys()),
+    modelBreakdown: toModelUsageBreakdown(grandModelTotals),
+    ...finalizedGrandTotals
+  };
+  rows.push(grandTotalRow);
+  return rows;
+}
+
+// src/efficiency/efficiency-row.ts
+function createEmptyEfficiencyUsageTotals() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    totalTokens: 0,
+    costUsd: 0
+  };
+}
+function createEmptyEfficiencyOutcomeTotals() {
+  return {
+    commitCount: 0,
+    linesAdded: 0,
+    linesDeleted: 0,
+    linesChanged: 0
+  };
+}
+
+// src/efficiency/aggregate-efficiency.ts
+var USD_PRECISION_SCALE2 = 1e12;
+function addUsd2(left, right) {
+  return Math.round((left + right) * USD_PRECISION_SCALE2) / USD_PRECISION_SCALE2;
+}
+function toUsageTotals(row) {
+  return {
+    inputTokens: row.inputTokens,
+    outputTokens: row.outputTokens,
+    reasoningTokens: row.reasoningTokens,
+    cacheReadTokens: row.cacheReadTokens,
+    cacheWriteTokens: row.cacheWriteTokens,
+    totalTokens: row.totalTokens,
+    costUsd: row.costUsd,
+    costIncomplete: row.costIncomplete
+  };
+}
+function buildUsageTotalsByPeriod(usageRows) {
+  const combinedByPeriod = /* @__PURE__ */ new Map();
+  const sourceByPeriod = /* @__PURE__ */ new Map();
+  for (const row of usageRows) {
+    if (row.rowType === "grand_total") {
+      continue;
+    }
+    if (row.rowType === "period_combined") {
+      combinedByPeriod.set(row.periodKey, toUsageTotals(row));
+      continue;
+    }
+    const existingSourceTotals = sourceByPeriod.get(row.periodKey) ?? createEmptyEfficiencyUsageTotals();
+    sourceByPeriod.set(row.periodKey, addUsageTotals(existingSourceTotals, toUsageTotals(row)));
+  }
+  const periodKeys = /* @__PURE__ */ new Set([...combinedByPeriod.keys(), ...sourceByPeriod.keys()]);
+  const usageTotalsByPeriod = /* @__PURE__ */ new Map();
+  for (const periodKey of periodKeys) {
+    usageTotalsByPeriod.set(
+      periodKey,
+      combinedByPeriod.get(periodKey) ?? sourceByPeriod.get(periodKey) ?? createEmptyEfficiencyUsageTotals()
+    );
+  }
+  return usageTotalsByPeriod;
+}
+function addOutcomeTotals(left, right) {
+  return {
+    commitCount: left.commitCount + right.commitCount,
+    linesAdded: left.linesAdded + right.linesAdded,
+    linesDeleted: left.linesDeleted + right.linesDeleted,
+    linesChanged: left.linesChanged + right.linesChanged
+  };
+}
+function addUsageTotals(left, right) {
+  const hasUnknownCost = left.costIncomplete === true && left.costUsd === void 0 || right.costIncomplete === true && right.costUsd === void 0;
+  const isNeutralZeroCost = (value) => value.totalTokens === 0 && value.costUsd === 0 && value.costIncomplete !== true;
+  const leftKnownCost = left.costUsd !== void 0 && !isNeutralZeroCost(left) ? left.costUsd : void 0;
+  const rightKnownCost = right.costUsd !== void 0 && !isNeutralZeroCost(right) ? right.costUsd : void 0;
+  let costUsd = leftKnownCost !== void 0 && rightKnownCost !== void 0 ? addUsd2(leftKnownCost, rightKnownCost) : leftKnownCost ?? rightKnownCost;
+  if (hasUnknownCost && (costUsd === void 0 || costUsd === 0)) {
+    costUsd = void 0;
+  }
+  return {
+    inputTokens: left.inputTokens + right.inputTokens,
+    outputTokens: left.outputTokens + right.outputTokens,
+    reasoningTokens: left.reasoningTokens + right.reasoningTokens,
+    cacheReadTokens: left.cacheReadTokens + right.cacheReadTokens,
+    cacheWriteTokens: left.cacheWriteTokens + right.cacheWriteTokens,
+    totalTokens: left.totalTokens + right.totalTokens,
+    costUsd,
+    costIncomplete: left.costIncomplete || right.costIncomplete ? true : void 0
+  };
+}
+function computeDerivedMetrics(usage, outcomes) {
+  const costUsd = usage.costUsd;
+  const nonCacheTotalTokens = usage.inputTokens + usage.outputTokens + usage.reasoningTokens;
+  return {
+    usdPerCommit: costUsd !== void 0 && outcomes.commitCount > 0 ? costUsd / outcomes.commitCount : void 0,
+    usdPer1kLinesChanged: costUsd !== void 0 && outcomes.linesChanged > 0 ? costUsd / (outcomes.linesChanged / 1e3) : void 0,
+    tokensPerCommit: outcomes.commitCount > 0 ? usage.totalTokens / outcomes.commitCount : void 0,
+    nonCacheTokensPerCommit: outcomes.commitCount > 0 ? nonCacheTotalTokens / outcomes.commitCount : void 0,
+    commitsPerUsd: costUsd !== void 0 && costUsd > 0 ? outcomes.commitCount / costUsd : void 0
+  };
+}
+function aggregateEfficiency(options) {
+  const usageTotalsByPeriod = buildUsageTotalsByPeriod(options.usageRows);
+  const periodKeys = [
+    .../* @__PURE__ */ new Set([...usageTotalsByPeriod.keys(), ...options.periodOutcomes.keys()])
+  ].sort(compareByCodePoint);
+  const rows = [];
+  let totalUsage = createEmptyEfficiencyUsageTotals();
+  let totalOutcomes = createEmptyEfficiencyOutcomeTotals();
+  for (const periodKey of periodKeys) {
+    const usageTotals = usageTotalsByPeriod.get(periodKey) ?? createEmptyEfficiencyUsageTotals();
+    const outcomeTotals = options.periodOutcomes.get(periodKey) ?? createEmptyEfficiencyOutcomeTotals();
+    const hasUsageRow = usageTotalsByPeriod.has(periodKey);
+    const hasUsageSignal3 = hasUsageRow && (usageTotals.totalTokens > 0 || usageTotals.costUsd !== void 0 || usageTotals.costIncomplete === true);
+    if (outcomeTotals.commitCount === 0 || !hasUsageSignal3) {
+      continue;
+    }
+    const derived = computeDerivedMetrics(usageTotals, outcomeTotals);
+    rows.push({
+      rowType: "period",
+      periodKey,
+      ...usageTotals,
+      ...outcomeTotals,
+      ...derived
+    });
+    totalUsage = addUsageTotals(totalUsage, usageTotals);
+    totalOutcomes = addOutcomeTotals(totalOutcomes, outcomeTotals);
+  }
+  const finalizedTotalUsage = totalUsage.costUsd === void 0 && totalUsage.costIncomplete !== true && totalUsage.totalTokens === 0 ? { ...totalUsage, costUsd: 0 } : totalUsage;
+  rows.push({
+    rowType: "grand_total",
+    periodKey: "ALL",
+    ...finalizedTotalUsage,
+    ...totalOutcomes,
+    ...computeDerivedMetrics(finalizedTotalUsage, totalOutcomes)
+  });
+  return rows;
+}
+
+// src/efficiency/git-outcome-collector.ts
+import { spawn as spawn2 } from "child_process";
+import { createInterface as createInterface3 } from "readline";
+import path8 from "path";
+import { stat as stat2 } from "fs/promises";
+var GIT_COMMIT_MARKER = "";
+var SHORTSTAT_PATTERN = /(\d+)\s+files?\s+changed(?:,\s+(\d+)\s+insertions?\(\+\))?(?:,\s+(\d+)\s+deletions?\(-\))?/u;
+function shiftDate(value, days) {
+  const date = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid date value: ${value}`);
+  }
+  date.setUTCDate(date.getUTCDate() + days);
+  return date.toISOString().slice(0, 10);
+}
+function escapeGitRegexLiteral(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function resolveGitCommandFailureReason(result) {
+  return result.stderr.trim() || `git exited with code ${result.exitCode}`;
+}
+function resolveRepoDir(repoDir) {
+  if (repoDir === void 0) {
+    return path8.resolve(process.cwd());
+  }
+  const normalizedRepoDir = repoDir.trim();
+  if (!normalizedRepoDir) {
+    throw new Error("--repo-dir must be a non-empty path");
+  }
+  return path8.resolve(normalizedRepoDir);
+}
+function getNodeErrorCode2(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) {
+    return void 0;
+  }
+  const record = error;
+  return typeof record.code === "string" ? record.code : void 0;
+}
+async function assertRepoDirReadable(repoDir) {
+  let directoryStats;
+  try {
+    directoryStats = await stat2(repoDir);
+  } catch (error) {
+    const code = getNodeErrorCode2(error);
+    if (code === "ENOENT") {
+      throw new Error(`Repository path does not exist: ${repoDir}`, { cause: error });
+    }
+    if (code === "EACCES" || code === "EPERM") {
+      throw new Error(`Repository path is unreadable: ${repoDir}`, { cause: error });
+    }
+    throw error;
+  }
+  if (!directoryStats.isDirectory()) {
+    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}`);
+}
+function isNoCommitHistoryFailure(result) {
+  if (result.exitCode !== 128) {
+    return false;
+  }
+  const reason = result.stderr.toLowerCase();
+  return reason.includes("does not have any commits yet") || reason.includes("needed a single revision") || reason.includes("unknown revision or path not in the working tree") || reason.includes("bad revision 'head'");
+}
+function createEmptyOutcomeCollection(repoDir, includeMergeCommits) {
+  return {
+    periodOutcomes: /* @__PURE__ */ new Map(),
+    totalOutcomes: createEmptyEfficiencyOutcomeTotals(),
+    diagnostics: {
+      repoDir,
+      includeMergeCommits,
+      commitsCollected: 0,
+      linesAdded: 0,
+      linesDeleted: 0
+    }
+  };
+}
+function isMissingGitUserEmailError(error) {
+  return error instanceof Error && error.message.startsWith("Git user.email is not configured for");
+}
+function resolveConfiguredEmailFromLines(lines) {
+  return lines.map((line) => line.trim()).find((line) => line.length > 0);
+}
+function resolveEmailFromGitAuthorIdent(lines) {
+  const identLine = lines.map((line) => line.trim()).find((line) => line.length > 0);
+  if (!identLine) {
+    return void 0;
+  }
+  const emailMatch = /<([^>]+)>/u.exec(identLine);
+  const email = emailMatch?.[1]?.trim();
+  return email && email.length > 0 ? email : void 0;
+}
+async function resolveConfiguredAuthorEmail(repoDir, runCommand) {
+  const configLookupAttempts = [
+    ["config", "--get", "user.email"],
+    ["config", "--global", "--get", "user.email"]
+  ];
+  for (const args of configLookupAttempts) {
+    const configResult = await runCommand(repoDir, args);
+    if (configResult.exitCode === 0) {
+      const configuredEmail = resolveConfiguredEmailFromLines(configResult.lines);
+      if (configuredEmail) {
+        return configuredEmail;
+      }
+      continue;
+    }
+    if (configResult.exitCode !== 1) {
+      const reason = resolveGitCommandFailureReason(configResult);
+      throw new Error(`Failed to resolve git user.email from ${repoDir}: ${reason}`);
+    }
+  }
+  const gitAuthorIdentResult = await runCommand(repoDir, ["var", "GIT_AUTHOR_IDENT"]);
+  if (gitAuthorIdentResult.exitCode === 0) {
+    const authorIdentEmail = resolveEmailFromGitAuthorIdent(gitAuthorIdentResult.lines);
+    if (authorIdentEmail) {
+      return authorIdentEmail;
+    }
+  }
+  throw new Error(
+    `Git user.email is not configured for ${repoDir}. Run: git -C ${repoDir} config user.email "you@example.com"`
+  );
+}
+function toIsoTimestamp(timestampSeconds) {
+  const timestamp = new Date(timestampSeconds * 1e3);
+  if (Number.isNaN(timestamp.getTime())) {
+    throw new Error(`Invalid git commit timestamp: ${timestampSeconds}`);
+  }
+  return timestamp.toISOString();
+}
+function parseShortstatLine(line) {
+  const shortstatMatch = SHORTSTAT_PATTERN.exec(line.trim());
+  if (!shortstatMatch) {
+    return void 0;
+  }
+  const linesAddedRaw = shortstatMatch[2];
+  const linesDeletedRaw = shortstatMatch[3];
+  return {
+    linesAdded: linesAddedRaw ? Number.parseInt(linesAddedRaw, 10) : 0,
+    linesDeleted: linesDeletedRaw ? Number.parseInt(linesDeletedRaw, 10) : 0
+  };
+}
+function finalizeCurrentEvent(currentEvent, events, authorEmail) {
+  if (!currentEvent) {
+    return;
+  }
+  if (authorEmail && currentEvent.authorEmail.trim().toLowerCase() !== authorEmail.trim().toLowerCase()) {
+    return;
+  }
+  const timestamp = toIsoTimestamp(currentEvent.timestampSeconds);
+  events.push({
+    sha: currentEvent.sha,
+    timestamp,
+    linesAdded: currentEvent.linesAdded,
+    linesDeleted: currentEvent.linesDeleted,
+    linesChanged: currentEvent.linesAdded + currentEvent.linesDeleted
+  });
+}
+function parseGitLogShortstatLines(lines, authorEmail) {
+  const events = [];
+  let currentEvent;
+  for (const line of lines) {
+    if (line.startsWith(GIT_COMMIT_MARKER)) {
+      const commitParts = line.slice(1).split(GIT_COMMIT_MARKER);
+      const timestampPart = commitParts[0];
+      const shaPart = commitParts[1];
+      const authorPart = commitParts[2];
+      if (commitParts.length !== 3 || !/^\d+$/u.test(timestampPart) || !/^[0-9a-f]{7,64}$/iu.test(shaPart) || authorPart.trim().length === 0) {
+        throw new Error(`Malformed git commit boundary line: ${line}`);
+      }
+      finalizeCurrentEvent(currentEvent, events, authorEmail);
+      currentEvent = {
+        timestampSeconds: Number.parseInt(timestampPart, 10),
+        sha: shaPart,
+        authorEmail: authorPart,
+        linesAdded: 0,
+        linesDeleted: 0
+      };
+      continue;
+    }
+    if (!currentEvent) {
+      continue;
+    }
+    const shortstat = parseShortstatLine(line);
+    if (!shortstat) {
+      continue;
+    }
+    currentEvent.linesAdded += shortstat.linesAdded;
+    currentEvent.linesDeleted += shortstat.linesDeleted;
+  }
+  finalizeCurrentEvent(currentEvent, events, authorEmail);
+  return events;
+}
+async function runGitCommand(repoDir, args) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn2("git", args, {
+      cwd: repoDir,
+      env: {
+        ...process.env,
+        LC_ALL: "C",
+        LANG: "C"
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const lines = [];
+    let stderr = "";
+    const stdoutReader = createInterface3({ input: child.stdout });
+    const stdoutPromise = (async () => {
+      for await (const line of stdoutReader) {
+        lines.push(line);
+      }
+    })();
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once("error", (error) => {
+      reject(error);
+    });
+    child.once("close", (exitCode) => {
+      void stdoutPromise.then(() => {
+        resolve({
+          lines,
+          stderr,
+          exitCode: exitCode ?? 1
+        });
+      }).catch((error) => {
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
+  });
+}
+function filterEventsByDateRange(events, timezone, since, until) {
+  const normalizedSince = since ? shiftDate(since, 0) : void 0;
+  const normalizedUntil = until ? shiftDate(until, 0) : void 0;
+  return events.filter((event) => {
+    const eventDate = getPeriodKey(event.timestamp, "daily", timezone);
+    if (normalizedSince && eventDate < normalizedSince) {
+      return false;
+    }
+    if (normalizedUntil && eventDate > normalizedUntil) {
+      return false;
+    }
+    return true;
+  });
+}
+function filterEventsByActiveUsageDays(events, timezone, activeUsageDays) {
+  if (activeUsageDays === void 0) {
+    return events;
+  }
+  if (activeUsageDays.size === 0) {
+    return [];
+  }
+  return events.filter(
+    (event) => activeUsageDays.has(getPeriodKey(event.timestamp, "daily", timezone))
+  );
+}
+function aggregatePeriodOutcomes(events, granularity, timezone) {
+  const periodOutcomes = /* @__PURE__ */ new Map();
+  const totalOutcomes = createEmptyEfficiencyOutcomeTotals();
+  for (const event of events) {
+    const periodKey = getPeriodKey(event.timestamp, granularity, timezone);
+    const periodTotals = periodOutcomes.get(periodKey) ?? createEmptyEfficiencyOutcomeTotals();
+    periodTotals.commitCount += 1;
+    periodTotals.linesAdded += event.linesAdded;
+    periodTotals.linesDeleted += event.linesDeleted;
+    periodTotals.linesChanged += event.linesChanged;
+    periodOutcomes.set(periodKey, periodTotals);
+    totalOutcomes.commitCount += 1;
+    totalOutcomes.linesAdded += event.linesAdded;
+    totalOutcomes.linesDeleted += event.linesDeleted;
+    totalOutcomes.linesChanged += event.linesChanged;
+  }
+  return {
+    periodOutcomes,
+    totalOutcomes
+  };
+}
+function buildGitLogArgs(options) {
+  const args = [
+    "log",
+    `--pretty=format:${GIT_COMMIT_MARKER}%ct${GIT_COMMIT_MARKER}%H${GIT_COMMIT_MARKER}%ae`,
+    "--shortstat",
+    "--regexp-ignore-case",
+    `--author=<${escapeGitRegexLiteral(options.authorEmail)}>`
+  ];
+  if (!options.includeMergeCommits) {
+    args.push("--no-merges");
+  }
+  if (options.since) {
+    args.push(`--since=${shiftDate(options.since, -1)}T00:00:00Z`);
+  }
+  if (options.until) {
+    args.push(`--until=${shiftDate(options.until, 1)}T23:59:59Z`);
+  }
+  return args;
+}
+function resolveGitLogDateWindow(options) {
+  if (!options.activeUsageDays || options.activeUsageDays.size === 0) {
+    return {
+      since: options.since,
+      until: options.until
+    };
+  }
+  let earliestUsageDay;
+  let latestUsageDay;
+  for (const usageDay of options.activeUsageDays) {
+    if (!earliestUsageDay || usageDay < earliestUsageDay) {
+      earliestUsageDay = usageDay;
+    }
+    if (!latestUsageDay || usageDay > latestUsageDay) {
+      latestUsageDay = usageDay;
+    }
+  }
+  return {
+    since: options.since ?? earliestUsageDay,
+    until: options.until ?? latestUsageDay
+  };
+}
+async function collectGitOutcomes(options, deps = {}) {
+  const repoDir = resolveRepoDir(options.repoDir);
+  const includeMergeCommits = options.includeMergeCommits ?? false;
+  const runCommand = deps.runGitCommand ?? runGitCommand;
+  if (options.activeUsageDays?.size === 0) {
+    return createEmptyOutcomeCollection(repoDir, includeMergeCommits);
+  }
+  if (!deps.runGitCommand) {
+    await assertRepoDirReadable(repoDir);
+    await assertGitRepository(repoDir, runCommand);
+  }
+  let authorEmail;
+  try {
+    authorEmail = await resolveConfiguredAuthorEmail(repoDir, runCommand);
+  } catch (error) {
+    if (!isMissingGitUserEmailError(error)) {
+      throw error;
+    }
+    const headResult = await runCommand(repoDir, ["rev-parse", "--verify", "HEAD"]);
+    if (isNoCommitHistoryFailure(headResult)) {
+      return createEmptyOutcomeCollection(repoDir, includeMergeCommits);
+    }
+    throw error;
+  }
+  const gitLogDateWindow = resolveGitLogDateWindow({
+    since: options.since,
+    until: options.until,
+    activeUsageDays: options.activeUsageDays
+  });
+  const gitResult = await runCommand(
+    repoDir,
+    buildGitLogArgs({
+      since: gitLogDateWindow.since,
+      until: gitLogDateWindow.until,
+      includeMergeCommits,
+      authorEmail
+    })
+  );
+  if (gitResult.exitCode !== 0) {
+    if (isNoCommitHistoryFailure(gitResult)) {
+      return createEmptyOutcomeCollection(repoDir, includeMergeCommits);
+    }
+    const reason = resolveGitCommandFailureReason(gitResult);
+    throw new Error(`Failed to collect git outcomes from ${repoDir}: ${reason}`);
+  }
+  const allEvents = parseGitLogShortstatLines(gitResult.lines, authorEmail);
+  const filteredEvents = filterEventsByDateRange(
+    allEvents,
+    options.timezone,
+    options.since,
+    options.until
+  );
+  const usageAttributedEvents = filterEventsByActiveUsageDays(
+    filteredEvents,
+    options.timezone,
+    options.activeUsageDays
+  );
+  const { periodOutcomes, totalOutcomes } = aggregatePeriodOutcomes(
+    usageAttributedEvents,
+    options.granularity,
+    options.timezone
+  );
+  return {
+    periodOutcomes,
+    totalOutcomes,
+    diagnostics: {
+      repoDir,
+      includeMergeCommits,
+      commitsCollected: totalOutcomes.commitCount,
+      linesAdded: totalOutcomes.linesAdded,
+      linesDeleted: totalOutcomes.linesDeleted
+    }
+  };
+}
+
+// src/efficiency/repo-attribution.ts
+import { access as access2, constants as constants2, realpath } from "fs/promises";
+import path9 from "path";
+async function hasGitMarker(directoryPath) {
+  try {
+    await access2(path9.join(directoryPath, ".git"), constants2.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeComparablePath(value) {
+  const normalizedPath = path9.normalize(path9.resolve(value));
+  return process.platform === "win32" ? normalizedPath.toLowerCase() : normalizedPath;
+}
+async function resolveComparablePath(value) {
+  const resolvedPath = path9.resolve(value);
+  try {
+    return normalizeComparablePath(await realpath(resolvedPath));
+  } catch {
+    return normalizeComparablePath(resolvedPath);
+  }
+}
+async function resolveRepoRootFromPathHint(pathHint) {
+  const trimmedPath = pathHint.trim();
+  if (!trimmedPath) {
+    return void 0;
+  }
+  let currentPath = path9.resolve(trimmedPath);
+  for (; ; ) {
+    if (await hasGitMarker(currentPath)) {
+      return currentPath;
+    }
+    const parentPath = path9.dirname(currentPath);
+    if (parentPath === currentPath) {
+      return void 0;
+    }
+    currentPath = parentPath;
+  }
+}
+async function attributeUsageEventsToRepo(events, repoDir, resolveRepoRoot3 = resolveRepoRootFromPathHint) {
+  const resolvedTargetRepoRoot = await resolveRepoRoot3(repoDir).catch(() => void 0);
+  const targetRepoPath = await resolveComparablePath(resolvedTargetRepoRoot ?? repoDir);
+  const rootCache = /* @__PURE__ */ new Map();
+  const matchedEvents = [];
+  let excludedEventCount = 0;
+  let unattributedEventCount = 0;
+  for (const event of events) {
+    if (!event.repoRoot) {
+      unattributedEventCount += 1;
+      continue;
+    }
+    const eventRepoRoot = event.repoRoot;
+    const cachedRootPromise = rootCache.get(eventRepoRoot) ?? (async () => {
+      const resolvedRoot2 = await resolveRepoRoot3(eventRepoRoot).catch(() => void 0);
+      if (!resolvedRoot2) {
+        return void 0;
+      }
+      return {
+        resolvedRoot: resolvedRoot2,
+        comparableRoot: await resolveComparablePath(resolvedRoot2)
+      };
+    })();
+    rootCache.set(eventRepoRoot, cachedRootPromise);
+    const resolvedRoot = await cachedRootPromise;
+    if (!resolvedRoot) {
+      unattributedEventCount += 1;
+      continue;
     }
+    if (resolvedRoot.comparableRoot !== targetRepoPath) {
+      excludedEventCount += 1;
+      continue;
+    }
+    matchedEvents.push({
+      ...event,
+      repoRoot: resolvedRoot.resolvedRoot
+    });
   }
-  const finalizedGrandTotals = events.length === 0 && grandTotals.costUsd === void 0 && grandTotals.costIncomplete !== true ? { ...grandTotals, costUsd: 0 } : grandTotals;
-  const grandTotalRow = {
-    rowType: "grand_total",
-    periodKey: "ALL",
-    source: "combined",
-    models: normalizeModelList(grandModelTotals.keys()),
-    modelBreakdown: toModelUsageBreakdown(grandModelTotals),
-    ...finalizedGrandTotals
+  return {
+    matchedEvents,
+    matchedEventCount: matchedEvents.length,
+    excludedEventCount,
+    unattributedEventCount
   };
-  rows.push(grandTotalRow);
-  return rows;
 }
 
 // src/config/env-var-display.ts
@@ -2055,12 +3137,14 @@ function buildUsageDiagnostics(params) {
     sourceFailures: params.sourceFailures,
     skippedRows,
     pricingOrigin: params.pricingOrigin,
+    pricingWarning: params.pricingWarning,
     activeEnvOverrides: params.activeEnvOverrides,
     timezone: params.timezone
   };
 }
-function assembleUsageDataResult(rows, diagnostics) {
+function assembleUsageDataResult(events, rows, diagnostics) {
   return {
+    events,
     rows,
     diagnostics
   };
@@ -2121,7 +3205,7 @@ function validateSourceFilterValues(sourceFilter, availableSourceIds) {
   if (unknownSources.length === 0) {
     return;
   }
-  const allowedSources = [...availableSourceIds].sort((left, right) => left.localeCompare(right));
+  const allowedSources = [...availableSourceIds].sort(compareByCodePoint);
   throw new Error(
     `Unknown --source value(s): ${unknownSources.join(", ")}. Allowed values: ${allowedSources.join(", ")}`
   );
@@ -2196,10 +3280,19 @@ function resolveExplicitSourceIds(options, sourceFilter) {
   }
   return explicitSourceIds;
 }
+function detectDefaultTimezone() {
+  const detectedTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  if (typeof detectedTimezone === "string") {
+    const trimmedDetectedTimezone = detectedTimezone.trim();
+    if (trimmedDetectedTimezone.length > 0) {
+      return trimmedDetectedTimezone;
+    }
+  }
+  return "UTC";
+}
 function normalizeBuildUsageInputs(options) {
   const { normalizedPricingUrl } = validateBuildOptions(options);
-  const timezoneInput = options.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
-  const timezone = timezoneInput.trim();
+  const timezone = options.timezone !== void 0 ? options.timezone.trim() : detectDefaultTimezone();
   validateTimezone(timezone);
   const providerFilter = normalizeProviderFilter(options.provider);
   const sourceFilter = normalizeSourceFilter(options.source);
@@ -2221,7 +3314,7 @@ function selectAdaptersForParsing(adapters, sourceFilter) {
 }
 
 // src/cli/build-usage-data-parsing.ts
-import { stat } from "fs/promises";
+import { stat as stat3 } from "fs/promises";
 
 // src/cli/normalize-skipped-row-reasons.ts
 function toPositiveInteger(value) {
@@ -2249,13 +3342,16 @@ function normalizeSkippedRowReasons(value) {
 }
 
 // src/cli/parse-file-cache.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import path7 from "path";
-var PARSE_FILE_CACHE_VERSION = 1;
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import path10 from "path";
+var PARSE_FILE_CACHE_VERSION = 2;
 var CACHE_KEY_SEPARATOR = "\0";
 function createCacheKey(source, filePath) {
   return `${source}${CACHE_KEY_SEPARATOR}${filePath}`;
 }
+function normalizeCacheSource(source) {
+  return normalizeSourceId(source)?.toLowerCase() ?? "";
+}
 function toNonNegativeInteger(value) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
     return void 0;
@@ -2268,20 +3364,32 @@ function toNonNegativeNumber2(value) {
   }
   return value;
 }
+function normalizeCachedTimestamp(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  const timestamp = new Date(normalized);
+  if (Number.isNaN(timestamp.getTime())) {
+    return void 0;
+  }
+  return timestamp.toISOString() === normalized ? normalized : void 0;
+}
 function normalizeCachedUsageEvent(value) {
   const record = asRecord(value);
   if (!record) {
     return void 0;
   }
-  const source = normalizeSourceId(record.source);
+  const source = normalizeSourceId(record.source)?.toLowerCase();
   const sessionId = typeof record.sessionId === "string" ? record.sessionId.trim() : "";
-  const timestamp = typeof record.timestamp === "string" ? record.timestamp.trim() : "";
+  const timestamp = normalizeCachedTimestamp(record.timestamp);
+  const repoRoot = typeof record.repoRoot === "string" ? record.repoRoot.trim() : "";
   if (!source || !sessionId || !timestamp) {
     return void 0;
   }
-  if (Number.isNaN(new Date(timestamp).getTime())) {
-    return void 0;
-  }
   const costMode = record.costMode === "explicit" || record.costMode === "estimated" ? record.costMode : void 0;
   if (!costMode) {
     return void 0;
@@ -2296,7 +3404,7 @@ function normalizeCachedUsageEvent(value) {
     return void 0;
   }
   const provider = typeof record.provider === "string" ? record.provider.trim() : "";
-  const model = typeof record.model === "string" ? record.model.trim() : "";
+  const model = typeof record.model === "string" ? record.model.trim().toLowerCase() : "";
   const costUsd = toNonNegativeNumber2(record.costUsd);
   if (costMode === "explicit" && costUsd === void 0) {
     return void 0;
@@ -2305,6 +3413,7 @@ function normalizeCachedUsageEvent(value) {
     source,
     sessionId,
     timestamp,
+    repoRoot: repoRoot || void 0,
     provider: provider || void 0,
     model: model || void 0,
     inputTokens,
@@ -2324,7 +3433,7 @@ function cloneUsageEvents(events) {
   return events.map((event) => cloneUsageEvent(event));
 }
 function cloneSkippedRowReasons(skippedRowReasons) {
-  return (skippedRowReasons ?? []).map((stat2) => ({ reason: stat2.reason, count: stat2.count }));
+  return (skippedRowReasons ?? []).map((stat4) => ({ reason: stat4.reason, count: stat4.count }));
 }
 function normalizeCachedEvents(value) {
   if (!Array.isArray(value)) {
@@ -2345,7 +3454,7 @@ function normalizeCacheEntry(value) {
   if (!record) {
     return void 0;
   }
-  const source = typeof record.source === "string" ? record.source.trim() : "";
+  const source = normalizeSourceId(record.source)?.toLowerCase() ?? "";
   const filePath = typeof record.filePath === "string" ? record.filePath.trim() : "";
   const cachedAt = toNonNegativeInteger(record.cachedAt);
   const fingerprint = asRecord(record.fingerprint);
@@ -2373,7 +3482,7 @@ function normalizeCacheEntry(value) {
   };
 }
 function getDefaultParseFileCachePath() {
-  return path7.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
+  return path10.join(getUserCacheRootDir(), "llm-usage-metrics", "parse-file-cache.json");
 }
 var ParseFileCache = class _ParseFileCache {
   constructor(cacheFilePath, limits, now) {
@@ -2393,16 +3502,20 @@ var ParseFileCache = class _ParseFileCache {
     return cache;
   }
   get(source, filePath, fingerprint) {
-    const entry = this.entriesByKey.get(createCacheKey(source, filePath));
+    const normalizedSource = normalizeCacheSource(source);
+    const cacheKey = createCacheKey(normalizedSource, filePath);
+    const entry = this.entriesByKey.get(cacheKey);
     if (!entry) {
       return void 0;
     }
     if (entry.cachedAt + this.limits.ttlMs < this.now()) {
-      this.entriesByKey.delete(createCacheKey(source, filePath));
+      this.entriesByKey.delete(cacheKey);
       this.dirty = true;
       return void 0;
     }
     if (entry.fingerprint.size !== fingerprint.size || entry.fingerprint.mtimeMs !== fingerprint.mtimeMs) {
+      this.entriesByKey.delete(cacheKey);
+      this.dirty = true;
       return void 0;
     }
     return {
@@ -2412,8 +3525,9 @@ var ParseFileCache = class _ParseFileCache {
     };
   }
   set(source, filePath, fingerprint, diagnostics) {
-    this.entriesByKey.set(createCacheKey(source, filePath), {
-      source,
+    const normalizedSource = normalizeCacheSource(source);
+    this.entriesByKey.set(createCacheKey(normalizedSource, filePath), {
+      source: normalizedSource,
       filePath,
       fingerprint: {
         size: fingerprint.size,
@@ -2454,7 +3568,7 @@ var ParseFileCache = class _ParseFileCache {
       keptEntries.length = bestCount;
       payloadText = bestPayloadText;
     }
-    await mkdir2(path7.dirname(this.cacheFilePath), { recursive: true });
+    await mkdir2(path10.dirname(this.cacheFilePath), { recursive: true });
     await writeFile2(this.cacheFilePath, payloadText, "utf8");
     this.dirty = false;
   }
@@ -2477,7 +3591,7 @@ var ParseFileCache = class _ParseFileCache {
   async loadFromDisk() {
     let content;
     try {
-      content = await readFile2(this.cacheFilePath, "utf8");
+      content = await readFile3(this.cacheFilePath, "utf8");
     } catch {
       return;
     }
@@ -2559,7 +3673,7 @@ async function parseAdapterEvents(adapter, maxParallelFileParsing, parseFileCach
       let parseFileDiagnostics;
       if (parseFileCache) {
         try {
-          const fileStat = await stat(filePath);
+          const fileStat = await stat3(filePath);
           fileFingerprint = {
             size: fileStat.size,
             mtimeMs: fileStat.mtimeMs
@@ -2651,6 +3765,16 @@ function matchesProvider(provider, providerFilter) {
   }
   return provider?.toLowerCase().includes(providerFilter) ?? false;
 }
+function isEventWithinDateRange(event, timezone, since, until) {
+  const eventDate = getPeriodKey(event.timestamp, "daily", timezone);
+  if (since && eventDate < since) {
+    return false;
+  }
+  if (until && eventDate > until) {
+    return false;
+  }
+  return true;
+}
 function resolveModelFilterRules(events, modelFilter) {
   if (!modelFilter || modelFilter.length === 0) {
     return void 0;
@@ -2675,41 +3799,24 @@ function matchesModel(model, modelRules) {
     (rule) => rule.mode === "exact" ? normalizedModel === rule.value : normalizedModel.includes(rule.value)
   );
 }
-function filterEventsByDateRange(events, timezone, since, until) {
-  return events.filter((event) => {
-    const eventDate = getPeriodKey(event.timestamp, "daily", timezone);
-    if (since && eventDate < since) {
-      return false;
-    }
-    if (until && eventDate > until) {
-      return false;
-    }
-    return true;
-  });
-}
-function filterUsageEvents(events, options) {
-  const providerFilteredEvents = events.filter(
-    (event) => matchesProvider(event.provider, options.providerFilter)
-  );
-  const providerAndDateFilteredEvents = filterEventsByDateRange(
-    providerFilteredEvents,
-    options.timezone,
-    options.since,
-    options.until
-  );
-  const modelFilterRules = resolveModelFilterRules(
-    providerAndDateFilteredEvents,
-    options.modelFilter
-  );
-  return providerAndDateFilteredEvents.filter(
-    (event) => matchesModel(event.model, modelFilterRules)
-  );
+function filterByModelRules(events, modelFilter) {
+  const modelFilterRules = resolveModelFilterRules(events, modelFilter);
+  return events.filter((event) => matchesModel(event.model, modelFilterRules));
 }
 function filterParsedAdapterEvents(parseResults, options) {
-  return filterUsageEvents(
-    parseResults.flatMap((result) => result.events),
-    options
-  );
+  const providerAndDateFilteredEvents = [];
+  for (const result of parseResults) {
+    for (const event of result.events) {
+      if (!matchesProvider(event.provider, options.providerFilter)) {
+        continue;
+      }
+      if (!isEventWithinDateRange(event, options.timezone, options.since, options.until)) {
+        continue;
+      }
+      providerAndDateFilteredEvents.push(event);
+    }
+  }
+  return filterByModelRules(providerAndDateFilteredEvents, options.modelFilter);
 }
 
 // src/pricing/cost-engine.ts
@@ -2755,8 +3862,8 @@ function applyPricingToEvents(events, pricingSource) {
 }
 
 // src/pricing/litellm-pricing-fetcher.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path8 from "path";
+import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import path11 from "path";
 
 // src/pricing/litellm-model-map.json
 var litellm_model_map_default = {
@@ -2764,20 +3871,34 @@ var litellm_model_map_default = {
     k2p5: "kimi-k2.5",
     "kimi-k2p5": "kimi-k2.5",
     "kimi-k2.5": "kimi-k2.5",
+    "kimi-k2.5-free": "kimi-k2.5",
     "moonshotai.kimi-k2.5": "kimi-k2.5",
     "moonshot/kimi-k2.5": "kimi-k2.5",
+    "gpt-5.3-codex-spark": "gpt-5.3-codex",
+    "gemini-3-pro": "gemini-3-pro",
+    "antigravity-gemini-3-flash": "gemini-3-flash",
+    "antigravity-gemini-3-pro": "gemini-3-pro",
+    "antigravity-gemini-3-pro-high": "gemini-3-pro",
+    "minimax-m2.1": "minimax-m2.1",
+    "minimax-m2.1-free": "minimax-m2.1",
+    "minimax-m2.5": "minimax-m2.5",
+    "minimax-m2.5-free": "minimax-m2.5",
     "claude sonnet 4.6": "claude-sonnet-4.6",
     "claude-sonnet-4.6": "claude-sonnet-4.6",
     "claude-sonnet-4-6": "claude-sonnet-4.6",
     "anthropic/claude-sonnet-4.6": "claude-sonnet-4.6",
-    "anthropic.claude-sonnet-4-6": "claude-sonnet-4.6",
-    "gpt-5.3-codex": "gpt-5.2-codex"
+    "anthropic.claude-sonnet-4-6": "claude-sonnet-4.6"
   },
   notes: {
-    "gpt-5.3-codex": "Temporary fallback to gpt-5.2-codex until upstream publishes direct gpt-5.3-codex token pricing"
+    "gpt-5.3-codex-spark": "Alias to gpt-5.3-codex because upstream publishes token pricing on the gpt-5.3-codex key"
   },
   preferredPricingKeyByCanonicalModel: {
     "kimi-k2.5": "moonshot/kimi-k2.5",
+    "gpt-5.3-codex": "gpt-5.3-codex",
+    "gemini-3-flash": "gemini/gemini-3-flash-preview",
+    "gemini-3-pro": "gemini/gemini-3-pro-preview",
+    "minimax-m2.1": "openrouter/minimax/minimax-m2.1",
+    "minimax-m2.5": "openrouter/minimax/minimax-m2.5",
     "claude-sonnet-4.6": "anthropic.claude-sonnet-4-6"
   }
 };
@@ -2926,7 +4047,7 @@ function normalizeLitellmPricingPayload(payload) {
   return normalizedPricing;
 }
 function getDefaultLiteLLMPricingCachePath() {
-  return path8.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
+  return path11.join(getUserCacheRootDir(), "llm-usage-metrics", "litellm-pricing-cache.json");
 }
 function stripProviderPrefix(model) {
   const slashIndex = model.lastIndexOf("/");
@@ -3133,7 +4254,7 @@ var LiteLLMPricingFetcher = class {
         if (!isProviderPrefixedMatch) {
           continue;
         }
-        if (!bestMatch || modelName.length < bestMatch.length || modelName.length === bestMatch.length && modelName.localeCompare(bestMatch) < 0) {
+        if (!bestMatch || modelName.length < bestMatch.length || modelName.length === bestMatch.length && compareByCodePoint(modelName, bestMatch) < 0) {
           bestMatch = modelName;
         }
       }
@@ -3151,7 +4272,7 @@ var LiteLLMPricingFetcher = class {
         if (!isPrefixModelMatch(candidate, modelName)) {
           continue;
         }
-        if (!bestMatch || modelName.length > bestMatch.length || modelName.length === bestMatch.length && modelName.localeCompare(bestMatch) < 0) {
+        if (!bestMatch || modelName.length > bestMatch.length || modelName.length === bestMatch.length && compareByCodePoint(modelName, bestMatch) < 0) {
           bestMatch = modelName;
         }
       }
@@ -3285,7 +4406,7 @@ var LiteLLMPricingFetcher = class {
   async readCachePayload() {
     let content;
     try {
-      content = await readFile3(this.cacheFilePath, "utf8");
+      content = await readFile4(this.cacheFilePath, "utf8");
     } catch {
       return void 0;
     }
@@ -3320,7 +4441,7 @@ var LiteLLMPricingFetcher = class {
     };
   }
   async writeCache() {
-    const directoryPath = path8.dirname(this.cacheFilePath);
+    const directoryPath = path11.dirname(this.cacheFilePath);
     await mkdir3(directoryPath, { recursive: true });
     const payload = {
       fetchedAt: this.now(),
@@ -3383,7 +4504,21 @@ async function resolveAndApplyPricingToEvents(events, options, runtimeConfig = g
       pricingOrigin
     };
   }
-  const pricingResult = await loadPricingSource(options, runtimeConfig);
+  let pricingResult;
+  try {
+    pricingResult = await loadPricingSource(options, runtimeConfig);
+  } catch (error) {
+    if (!options.ignorePricingFailures) {
+      throw error;
+    }
+    const reason = error instanceof Error ? error.message : String(error);
+    const pricingWarning = reason.trim().startsWith("Could not load") ? reason : `Could not load pricing; continuing without estimated costs: ${reason}`;
+    return {
+      pricedEvents: events,
+      pricingOrigin,
+      pricingWarning
+    };
+  }
   pricingOrigin = pricingResult.origin;
   return {
     pricedEvents: applyPricingToEvents(events, pricingResult.source),
@@ -3433,7 +4568,7 @@ async function buildUsageData(granularity, options, deps = {}) {
     modelFilter: normalizedInputs.modelFilter
   });
   const pricingOptions = withNormalizedPricingUrl(options, normalizedInputs.pricingUrl);
-  const { pricedEvents, pricingOrigin } = await resolveAndApplyPricingToEvents(
+  const { pricedEvents, pricingOrigin, pricingWarning } = await resolveAndApplyPricingToEvents(
     filteredEvents,
     pricingOptions,
     pricingRuntimeConfig,
@@ -3449,10 +4584,114 @@ async function buildUsageData(granularity, options, deps = {}) {
     successfulParseResults,
     sourceFailures,
     pricingOrigin,
+    pricingWarning,
     activeEnvOverrides: readEnvVarOverrides(),
     timezone: normalizedInputs.timezone
   });
-  return assembleUsageDataResult(rows, diagnostics);
+  return assembleUsageDataResult(pricedEvents, rows, diagnostics);
+}
+
+// src/cli/build-efficiency-data.ts
+function hasActiveRepeatedFilter(value) {
+  if (!value) {
+    return false;
+  }
+  const values = Array.isArray(value) ? value : [value];
+  return values.some(
+    (entry) => entry.split(",").map((candidate) => candidate.trim()).some((candidate) => candidate.length > 0)
+  );
+}
+function hasActiveProviderFilter(provider) {
+  return Boolean(provider?.trim());
+}
+function hasActiveTextOption(value) {
+  return Boolean(value?.trim());
+}
+function resolveScopeNote(options) {
+  const activeFilters = [];
+  if (hasActiveTextOption(options.piDir)) {
+    activeFilters.push("--pi-dir");
+  }
+  if (hasActiveTextOption(options.codexDir)) {
+    activeFilters.push("--codex-dir");
+  }
+  if (hasActiveTextOption(options.opencodeDb)) {
+    activeFilters.push("--opencode-db");
+  }
+  if (hasActiveRepeatedFilter(options.sourceDir)) {
+    activeFilters.push("--source-dir");
+  }
+  if (hasActiveRepeatedFilter(options.source)) {
+    activeFilters.push("--source");
+  }
+  if (hasActiveProviderFilter(options.provider)) {
+    activeFilters.push("--provider");
+  }
+  if (hasActiveRepeatedFilter(options.model)) {
+    activeFilters.push("--model");
+  }
+  if (activeFilters.length === 0) {
+    return void 0;
+  }
+  return `Usage filters (${activeFilters.join(", ")}) affect commit attribution too: only commit days with matching repo-attributed usage events are counted.`;
+}
+function hasMeaningfulEfficiencyUsageSignal(event) {
+  return event.totalTokens > 0 || event.costUsd !== void 0 && event.costUsd > 0;
+}
+async function buildEfficiencyData(granularity, options, deps = {}) {
+  const buildUsage = deps.buildUsageData ?? buildUsageData;
+  const collectOutcomes = deps.collectGitOutcomes ?? collectGitOutcomes;
+  const resolveRepoRoot3 = deps.resolveRepoRoot ?? resolveRepoRootFromPathHint;
+  const repoDir = options.repoDir?.trim();
+  if (options.repoDir !== void 0 && !repoDir) {
+    throw new Error("--repo-dir must be a non-empty path");
+  }
+  const usageData = await buildUsage(granularity, options);
+  const attribution = await attributeUsageEventsToRepo(
+    usageData.events,
+    repoDir ?? process.cwd(),
+    resolveRepoRoot3
+  );
+  const matchedEventsWithSignal = attribution.matchedEvents.filter(
+    (event) => hasMeaningfulEfficiencyUsageSignal(event)
+  );
+  const activeUsageDays = new Set(
+    matchedEventsWithSignal.map(
+      (event) => getPeriodKey(event.timestamp, "daily", usageData.diagnostics.timezone)
+    )
+  );
+  const gitOutcomes = await collectOutcomes({
+    repoDir,
+    granularity,
+    timezone: usageData.diagnostics.timezone,
+    since: options.since,
+    until: options.until,
+    includeMergeCommits: options.includeMergeCommits,
+    activeUsageDays
+  });
+  const repoScopedUsageRows = aggregateUsage(matchedEventsWithSignal, {
+    granularity,
+    timezone: usageData.diagnostics.timezone
+  });
+  const rows = aggregateEfficiency({
+    usageRows: repoScopedUsageRows,
+    periodOutcomes: gitOutcomes.periodOutcomes
+  });
+  return {
+    rows,
+    diagnostics: {
+      usage: usageData.diagnostics,
+      repoDir: gitOutcomes.diagnostics.repoDir,
+      includeMergeCommits: gitOutcomes.diagnostics.includeMergeCommits,
+      gitCommitCount: gitOutcomes.diagnostics.commitsCollected,
+      gitLinesAdded: gitOutcomes.diagnostics.linesAdded,
+      gitLinesDeleted: gitOutcomes.diagnostics.linesDeleted,
+      repoMatchedUsageEvents: attribution.matchedEventCount,
+      repoExcludedUsageEvents: attribution.excludedEventCount,
+      repoUnattributedUsageEvents: attribution.unattributedEventCount,
+      scopeNote: resolveScopeNote(options)
+    }
+  };
 }
 
 // src/utils/logger.ts
@@ -3523,130 +4762,36 @@ function emitDiagnostics(diagnostics, diagnosticsLogger = logger) {
   switch (diagnostics.pricingOrigin) {
     case "offline-cache":
       diagnosticsLogger.info("Using cached pricing (offline mode)");
-      return;
+      break;
     case "cache":
       diagnosticsLogger.info("Loaded pricing from cache");
-      return;
+      break;
     case "network":
       diagnosticsLogger.info("Fetched pricing from LiteLLM");
-      return;
+      break;
     case "none":
-      return;
-  }
-}
-
-// src/render/markdown-table.ts
-import { markdownTable } from "markdown-table";
-
-// src/render/row-cells.ts
-var usageTableHeaders = [
-  "Period",
-  "Source",
-  "Models",
-  "Input",
-  "Output",
-  "Reasoning",
-  "Cache Read",
-  "Cache Write",
-  "Total",
-  "Cost"
-];
-var integerFormatter = new Intl.NumberFormat("en-US");
-var usdFormatter = new Intl.NumberFormat("en-US", {
-  style: "currency",
-  currency: "USD",
-  minimumFractionDigits: 2,
-  maximumFractionDigits: 2
-});
-function formatSource(row) {
-  if (row.rowType === "grand_total") {
-    return "TOTAL";
-  }
-  return row.source;
-}
-function formatTokenCount(value) {
-  return integerFormatter.format(value ?? 0);
-}
-function formatUsd(value, options = {}) {
-  if (value === void 0) {
-    return "-";
-  }
-  const formattedUsd = usdFormatter.format(value);
-  return options.incomplete ? `~${formattedUsd}` : formattedUsd;
-}
-function buildModelLines(row) {
-  if (row.modelBreakdown.length > 0) {
-    return row.modelBreakdown.map((modelUsage) => `\u2022 ${modelUsage.model}`);
-  }
-  return row.models.map((model) => `\u2022 ${model}`);
-}
-function formatModels(row, layout) {
-  const modelLines = buildModelLines(row);
-  if (modelLines.length === 0) {
-    return "-";
+      break;
   }
-  if (layout === "per_model_columns" && row.modelBreakdown.length > 1) {
-    return [...modelLines, "\u03A3 TOTAL"].join("\n");
+  if (diagnostics.pricingWarning) {
+    diagnosticsLogger.warn(diagnostics.pricingWarning);
   }
-  return modelLines.join("\n");
 }
-function formatModelMetric(row, selector, formatter, layout) {
-  if (layout !== "per_model_columns" || row.modelBreakdown.length === 0) {
-    return formatter(selector(row));
-  }
-  const lines = row.modelBreakdown.map((modelUsage) => formatter(selector(modelUsage)));
-  if (row.modelBreakdown.length > 1) {
-    lines.push(formatter(selector(row)));
+
+// src/cli/emit-env-var-overrides.ts
+function emitEnvVarOverrides(activeEnvOverrides, diagnosticsLogger) {
+  const envVarOverrideLines = formatEnvVarOverrides(activeEnvOverrides);
+  if (envVarOverrideLines.length === 0) {
+    return;
   }
-  return lines.join("\n");
-}
-function formatModelCostMetric(row, layout) {
-  if (layout !== "per_model_columns" || row.modelBreakdown.length === 0) {
-    return formatUsd(row.costUsd, { incomplete: row.costIncomplete });
+  const [headerLine, ...envVarLines] = envVarOverrideLines;
+  if (headerLine) {
+    diagnosticsLogger.info(headerLine);
   }
-  const lines = row.modelBreakdown.map(
-    (modelUsage) => formatUsd(modelUsage.costUsd, { incomplete: modelUsage.costIncomplete })
-  );
-  if (row.modelBreakdown.length > 1) {
-    lines.push(formatUsd(row.costUsd, { incomplete: row.costIncomplete }));
+  for (const envVarLine of envVarLines) {
+    diagnosticsLogger.dim(envVarLine);
   }
-  return lines.join("\n");
-}
-function toUsageTableCells(rows, options = {}) {
-  const layout = options.layout ?? "compact";
-  return rows.map((row) => [
-    row.periodKey,
-    formatSource(row),
-    formatModels(row, layout),
-    formatModelMetric(row, (value) => value.inputTokens, formatTokenCount, layout),
-    formatModelMetric(row, (value) => value.outputTokens, formatTokenCount, layout),
-    formatModelMetric(row, (value) => value.reasoningTokens, formatTokenCount, layout),
-    formatModelMetric(row, (value) => value.cacheReadTokens, formatTokenCount, layout),
-    formatModelMetric(row, (value) => value.cacheWriteTokens, formatTokenCount, layout),
-    formatModelMetric(row, (value) => value.totalTokens, formatTokenCount, layout),
-    formatModelCostMetric(row, layout)
-  ]);
-}
-
-// src/render/markdown-table.ts
-var alignment = ["l", "l", "l", "r", "r", "r", "r", "r", "r", "r"];
-function toMarkdownSafeCell(value) {
-  return value.replace(/\r?\n/gu, "<br>");
-}
-function renderMarkdownTable(rows, options = {}) {
-  const tableLayout = options.tableLayout ?? "compact";
-  const bodyRows = toUsageTableCells(rows, { layout: tableLayout }).map(
-    (row) => row.map((cell) => toMarkdownSafeCell(cell))
-  );
-  const tableRows = [Array.from(usageTableHeaders), ...bodyRows];
-  return markdownTable(tableRows, {
-    align: alignment
-  });
 }
 
-// src/render/report-header.ts
-import pc2 from "picocolors";
-
 // src/render/table-text-layout.ts
 var ansiEscapePattern = new RegExp(String.raw`\u001B\[[0-9;]*m`, "gu");
 var combiningMarkPattern = /\p{Mark}/u;
@@ -3811,16 +4956,50 @@ function wrapTableColumn(rows, options) {
   if (options.width <= 0) {
     throw new RangeError("wrapTableColumn width must be greater than 0");
   }
-  return rows.map((row) => {
-    const wrappedRow = [...row];
-    const cell = wrappedRow[options.columnIndex] ?? "";
-    const wrappedLines = splitCellLines(cell).flatMap((line) => wrapPlainLine(line, options.width));
-    wrappedRow[options.columnIndex] = wrappedLines.join("\n");
-    return wrappedRow;
-  });
+  return rows.map((row) => {
+    const wrappedRow = [...row];
+    const cell = wrappedRow[options.columnIndex] ?? "";
+    const wrappedLines = splitCellLines(cell).flatMap((line) => wrapPlainLine(line, options.width));
+    wrappedRow[options.columnIndex] = wrappedLines.join("\n");
+    return wrappedRow;
+  });
+}
+
+// src/cli/terminal-overflow-warning.ts
+function detectTerminalOverflowColumns(reportOutput, stdoutState) {
+  const terminalColumns = resolveTtyColumns(stdoutState);
+  if (terminalColumns === void 0) {
+    return void 0;
+  }
+  const allLines = reportOutput.trimEnd().split("\n");
+  const tableLikeLinePattern = /[│╭╮╰╯├┼┬┴┌┐└┘]|^\s*\|.*\|\s*$/u;
+  const tableLines = allLines.filter((line) => tableLikeLinePattern.test(line));
+  if (tableLines.length === 0) {
+    return void 0;
+  }
+  const maxLineWidth = tableLines.reduce(
+    (maxWidth, line) => Math.max(maxWidth, visibleWidth(line)),
+    0
+  );
+  if (maxLineWidth <= terminalColumns) {
+    return void 0;
+  }
+  return maxLineWidth - terminalColumns;
+}
+function warnIfTerminalTableOverflows(reportOutput, warn, stdoutState = process.stdout) {
+  const overflowColumns = detectTerminalOverflowColumns(reportOutput, stdoutState);
+  if (overflowColumns !== void 0) {
+    warn(
+      `Report table is wider than terminal by ${overflowColumns} column(s). Use fullscreen/maximized terminal for better readability.`
+    );
+  }
 }
 
+// src/render/render-efficiency-report.ts
+import { markdownTable } from "markdown-table";
+
 // src/render/report-header.ts
+import pc2 from "picocolors";
 function getBoxWidth(content) {
   return visibleWidth(content) + 4;
 }
@@ -3846,6 +5025,89 @@ function renderReportHeader(options) {
   return lines.join("\n");
 }
 
+// src/render/efficiency-row-cells.ts
+var efficiencyTableHeaders = [
+  "Period",
+  "Commits",
+  "+Lines",
+  "-Lines",
+  "\u0394Lines",
+  "Input",
+  "Output",
+  "Reasoning",
+  "Cache Read",
+  "Cache Write",
+  "Total",
+  "Cost",
+  "$/Commit",
+  "$/1k Lines",
+  "All Tokens/Commit",
+  "Non-Cache/Commit",
+  "Commits/$"
+];
+var integerFormatter = new Intl.NumberFormat("en-US");
+var decimalFormatter = new Intl.NumberFormat("en-US", {
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+});
+var usdFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+});
+var usdRateFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 4,
+  maximumFractionDigits: 4
+});
+function formatInteger(value) {
+  return integerFormatter.format(value);
+}
+function formatUsd(value, options = {}) {
+  if (value === void 0) {
+    return "-";
+  }
+  const formatted = usdFormatter.format(value);
+  return options.approximate ? `~${formatted}` : formatted;
+}
+function formatUsdRate(value, options = {}) {
+  if (value === void 0) {
+    return "-";
+  }
+  const formatted = usdRateFormatter.format(value);
+  return options.approximate ? `~${formatted}` : formatted;
+}
+function formatDecimal(value, options = {}) {
+  if (value === void 0) {
+    return "-";
+  }
+  const formatted = decimalFormatter.format(value);
+  return options.approximate ? `~${formatted}` : formatted;
+}
+function toEfficiencyTableCells(rows) {
+  return rows.map((row) => [
+    row.periodKey,
+    formatInteger(row.commitCount),
+    formatInteger(row.linesAdded),
+    formatInteger(row.linesDeleted),
+    formatInteger(row.linesChanged),
+    formatInteger(row.inputTokens),
+    formatInteger(row.outputTokens),
+    formatInteger(row.reasoningTokens),
+    formatInteger(row.cacheReadTokens),
+    formatInteger(row.cacheWriteTokens),
+    formatInteger(row.totalTokens),
+    formatUsd(row.costUsd, { approximate: row.costIncomplete }),
+    formatUsdRate(row.usdPerCommit, { approximate: row.costIncomplete }),
+    formatUsdRate(row.usdPer1kLinesChanged, { approximate: row.costIncomplete }),
+    formatDecimal(row.tokensPerCommit),
+    formatDecimal(row.nonCacheTokensPerCommit),
+    formatDecimal(row.commitsPerUsd, { approximate: row.costIncomplete })
+  ]);
+}
+
 // src/render/terminal-table.ts
 import pc4 from "picocolors";
 
@@ -3924,6 +5186,96 @@ function colorizeUsageBodyRows(bodyRows, rows, options) {
   });
 }
 
+// src/render/row-cells.ts
+var usageTableHeaders = [
+  "Period",
+  "Source",
+  "Models",
+  "Input",
+  "Output",
+  "Reasoning",
+  "Cache Read",
+  "Cache Write",
+  "Total",
+  "Cost"
+];
+var integerFormatter2 = new Intl.NumberFormat("en-US");
+var usdFormatter2 = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2
+});
+function formatSource(row) {
+  if (row.rowType === "grand_total") {
+    return "TOTAL";
+  }
+  return row.source;
+}
+function formatTokenCount(value) {
+  return integerFormatter2.format(value ?? 0);
+}
+function formatUsd2(value, options = {}) {
+  if (value === void 0) {
+    return "-";
+  }
+  const formattedUsd = usdFormatter2.format(value);
+  return options.incomplete ? `~${formattedUsd}` : formattedUsd;
+}
+function buildModelLines(row) {
+  if (row.modelBreakdown.length > 0) {
+    return row.modelBreakdown.map((modelUsage) => `\u2022 ${modelUsage.model}`);
+  }
+  return row.models.map((model) => `\u2022 ${model}`);
+}
+function formatModels(row, layout) {
+  const modelLines = buildModelLines(row);
+  if (modelLines.length === 0) {
+    return "-";
+  }
+  if (layout === "per_model_columns" && row.modelBreakdown.length > 1) {
+    return [...modelLines, "\u03A3 TOTAL"].join("\n");
+  }
+  return modelLines.join("\n");
+}
+function formatModelMetric(row, selector, formatter, layout) {
+  if (layout !== "per_model_columns" || row.modelBreakdown.length === 0) {
+    return formatter(selector(row));
+  }
+  const lines = row.modelBreakdown.map((modelUsage) => formatter(selector(modelUsage)));
+  if (row.modelBreakdown.length > 1) {
+    lines.push(formatter(selector(row)));
+  }
+  return lines.join("\n");
+}
+function formatModelCostMetric(row, layout) {
+  if (layout !== "per_model_columns" || row.modelBreakdown.length === 0) {
+    return formatUsd2(row.costUsd, { incomplete: row.costIncomplete });
+  }
+  const lines = row.modelBreakdown.map(
+    (modelUsage) => formatUsd2(modelUsage.costUsd, { incomplete: modelUsage.costIncomplete })
+  );
+  if (row.modelBreakdown.length > 1) {
+    lines.push(formatUsd2(row.costUsd, { incomplete: row.costIncomplete }));
+  }
+  return lines.join("\n");
+}
+function toUsageTableCells(rows, options = {}) {
+  const layout = options.layout ?? "compact";
+  return rows.map((row) => [
+    row.periodKey,
+    formatSource(row),
+    formatModels(row, layout),
+    formatModelMetric(row, (value) => value.inputTokens, formatTokenCount, layout),
+    formatModelMetric(row, (value) => value.outputTokens, formatTokenCount, layout),
+    formatModelMetric(row, (value) => value.reasoningTokens, formatTokenCount, layout),
+    formatModelMetric(row, (value) => value.cacheReadTokens, formatTokenCount, layout),
+    formatModelMetric(row, (value) => value.cacheWriteTokens, formatTokenCount, layout),
+    formatModelMetric(row, (value) => value.totalTokens, formatTokenCount, layout),
+    formatModelCostMetric(row, layout)
+  ]);
+}
+
 // src/render/unicode-table.ts
 function getColumnAlignment(columnIndex, modelsColumnIndex2) {
   if (columnIndex <= modelsColumnIndex2) {
@@ -4233,8 +5585,174 @@ function renderTerminalTable(rows, options = {}) {
   return renderedTable;
 }
 
-// src/render/render-usage-report.ts
+// src/render/render-efficiency-report.ts
 function getReportTitle(granularity) {
+  switch (granularity) {
+    case "daily":
+      return "Daily Efficiency Report";
+    case "weekly":
+      return "Weekly Efficiency Report";
+    case "monthly":
+      return "Monthly Efficiency Report";
+  }
+}
+function toTableSortRow(row) {
+  if (row.rowType === "grand_total") {
+    return {
+      rowType: "grand_total",
+      periodKey: "ALL",
+      source: "combined",
+      models: [],
+      modelBreakdown: [],
+      inputTokens: row.inputTokens,
+      outputTokens: row.outputTokens,
+      reasoningTokens: row.reasoningTokens,
+      cacheReadTokens: row.cacheReadTokens,
+      cacheWriteTokens: row.cacheWriteTokens,
+      totalTokens: row.totalTokens,
+      costUsd: row.costUsd,
+      costIncomplete: row.costIncomplete
+    };
+  }
+  return {
+    rowType: "period_source",
+    periodKey: row.periodKey,
+    source: "combined",
+    models: [],
+    modelBreakdown: [],
+    inputTokens: row.inputTokens,
+    outputTokens: row.outputTokens,
+    reasoningTokens: row.reasoningTokens,
+    cacheReadTokens: row.cacheReadTokens,
+    cacheWriteTokens: row.cacheWriteTokens,
+    totalTokens: row.totalTokens,
+    costUsd: row.costUsd,
+    costIncomplete: row.costIncomplete
+  };
+}
+function renderTerminalEfficiencyTable(rows) {
+  const bodyRows = toEfficiencyTableCells(rows);
+  const tableSortRows = rows.map((row) => toTableSortRow(row));
+  const periodColumnWidth = Math.max(
+    efficiencyTableHeaders[0].length,
+    ...rows.map((row) => row.periodKey.length)
+  );
+  return renderUnicodeTable({
+    headerCells: efficiencyTableHeaders,
+    bodyRows,
+    measureHeaderCells: efficiencyTableHeaders,
+    measureBodyRows: bodyRows,
+    usageRows: tableSortRows,
+    tableLayout: "compact",
+    modelsColumnIndex: 0,
+    modelsColumnWidth: periodColumnWidth
+  });
+}
+function toMarkdownSafeCell(value) {
+  return value.replace(/\r?\n/gu, "<br>");
+}
+function renderMarkdownEfficiencyTable(rows) {
+  const bodyRows = toEfficiencyTableCells(rows).map(
+    (row) => row.map((cell) => toMarkdownSafeCell(cell))
+  );
+  const tableRows = [Array.from(efficiencyTableHeaders), ...bodyRows];
+  const alignment2 = efficiencyTableHeaders.map((_, index) => index === 0 ? "l" : "r");
+  return markdownTable(tableRows, {
+    align: alignment2
+  });
+}
+function renderTerminalEfficiencyReport(efficiencyData, options) {
+  const outputLines = [];
+  const useColor = options.useColor ?? shouldUseColorByDefault();
+  outputLines.push(
+    renderReportHeader({
+      title: getReportTitle(options.granularity),
+      useColor
+    })
+  );
+  outputLines.push("");
+  outputLines.push(renderTerminalEfficiencyTable(efficiencyData.rows));
+  return outputLines.join("\n");
+}
+function renderEfficiencyReport(efficiencyData, format, options) {
+  switch (format) {
+    case "json":
+      return JSON.stringify(efficiencyData.rows, null, 2);
+    case "markdown":
+      return renderMarkdownEfficiencyTable(efficiencyData.rows);
+    case "terminal":
+      return renderTerminalEfficiencyReport(efficiencyData, options);
+  }
+}
+
+// src/cli/run-efficiency-report.ts
+function validateOutputFormatOptions(options) {
+  if (options.markdown && options.json) {
+    throw new Error("Choose either --markdown or --json, not both");
+  }
+}
+function resolveReportFormat(options) {
+  if (options.json) {
+    return "json";
+  }
+  if (options.markdown) {
+    return "markdown";
+  }
+  return "terminal";
+}
+async function prepareEfficiencyReport(granularity, options) {
+  validateOutputFormatOptions(options);
+  const efficiencyData = await buildEfficiencyData(granularity, options);
+  const format = resolveReportFormat(options);
+  return {
+    format,
+    diagnostics: efficiencyData.diagnostics,
+    output: renderEfficiencyReport(efficiencyData, format, {
+      granularity
+    })
+  };
+}
+async function runEfficiencyReport(granularity, options) {
+  const preparedReport = await prepareEfficiencyReport(granularity, options);
+  emitDiagnostics(preparedReport.diagnostics.usage, logger);
+  emitEnvVarOverrides(preparedReport.diagnostics.usage.activeEnvOverrides, logger);
+  const mergeModeLabel = preparedReport.diagnostics.includeMergeCommits ? "including merge commits" : "excluding merge commits";
+  logger.info(
+    `Git outcomes (${mergeModeLabel}): ${preparedReport.diagnostics.gitCommitCount} commit(s), +${preparedReport.diagnostics.gitLinesAdded}/-${preparedReport.diagnostics.gitLinesDeleted} lines (${preparedReport.diagnostics.repoDir})`
+  );
+  logger.info(
+    `Repo-attributed usage events: ${preparedReport.diagnostics.repoMatchedUsageEvents} matched, ${preparedReport.diagnostics.repoExcludedUsageEvents} excluded, ${preparedReport.diagnostics.repoUnattributedUsageEvents} unattributed`
+  );
+  if (preparedReport.diagnostics.scopeNote) {
+    logger.warn(preparedReport.diagnostics.scopeNote);
+  }
+  if (preparedReport.format === "terminal") {
+    warnIfTerminalTableOverflows(preparedReport.output, (message) => {
+      logger.warn(message);
+    });
+  }
+  console.log(preparedReport.output);
+}
+
+// src/render/markdown-table.ts
+import { markdownTable as markdownTable2 } from "markdown-table";
+var alignment = ["l", "l", "l", "r", "r", "r", "r", "r", "r", "r"];
+function toMarkdownSafeCell2(value) {
+  return value.replace(/\r?\n/gu, "<br>");
+}
+function renderMarkdownTable(rows, options = {}) {
+  const tableLayout = options.tableLayout ?? "compact";
+  const bodyRows = toUsageTableCells(rows, { layout: tableLayout }).map(
+    (row) => row.map((cell) => toMarkdownSafeCell2(cell))
+  );
+  const tableRows = [Array.from(usageTableHeaders), ...bodyRows];
+  return markdownTable2(tableRows, {
+    align: alignment
+  });
+}
+
+// src/render/render-usage-report.ts
+function getReportTitle2(granularity) {
   switch (granularity) {
     case "daily":
       return "Daily Token Usage Report";
@@ -4246,16 +5764,11 @@ function getReportTitle(granularity) {
 }
 function renderTerminalUsageReport(usageData, options) {
   const outputLines = [];
-  const envVarOverrideLines = formatEnvVarOverrides(usageData.diagnostics.activeEnvOverrides);
   const useColor = options.useColor ?? shouldUseColorByDefault();
   const tableLayout = options.tableLayout ?? "compact";
-  if (envVarOverrideLines.length > 0) {
-    outputLines.push(...envVarOverrideLines);
-    outputLines.push("");
-  }
   outputLines.push(
     renderReportHeader({
-      title: getReportTitle(options.granularity),
+      title: getReportTitle2(options.granularity),
       useColor
     })
   );
@@ -4276,12 +5789,12 @@ function renderUsageReport(usageData, format, options) {
 }
 
 // src/cli/run-usage-report.ts
-function validateOutputFormatOptions(options) {
+function validateOutputFormatOptions2(options) {
   if (options.markdown && options.json) {
     throw new Error("Choose either --markdown or --json, not both");
   }
 }
-function resolveReportFormat(options) {
+function resolveReportFormat2(options) {
   if (options.json) {
     return "json";
   }
@@ -4293,31 +5806,10 @@ function resolveReportFormat(options) {
 function resolveTableLayout(options) {
   return options.perModelColumns ? "per_model_columns" : "compact";
 }
-function detectTerminalOverflowColumns(reportOutput) {
-  const stdoutState = process.stdout;
-  const terminalColumns = resolveTtyColumns(stdoutState);
-  if (terminalColumns === void 0) {
-    return void 0;
-  }
-  const allLines = reportOutput.trimEnd().split("\n");
-  const tableLikeLinePattern = /[│╭╮╰╯├┼┬┴┌┐└┘]|^\s*\|.*\|\s*$/u;
-  const tableLines = allLines.filter((line) => tableLikeLinePattern.test(line));
-  if (tableLines.length === 0) {
-    return void 0;
-  }
-  const maxLineWidth = tableLines.reduce(
-    (maxWidth, line) => Math.max(maxWidth, visibleWidth(line)),
-    0
-  );
-  if (maxLineWidth <= terminalColumns) {
-    return void 0;
-  }
-  return maxLineWidth - terminalColumns;
-}
 async function prepareUsageReport(granularity, options) {
-  validateOutputFormatOptions(options);
+  validateOutputFormatOptions2(options);
   const usageData = await buildUsageData(granularity, options);
-  const format = resolveReportFormat(options);
+  const format = resolveReportFormat2(options);
   return {
     format,
     diagnostics: usageData.diagnostics,
@@ -4330,13 +5822,11 @@ async function prepareUsageReport(granularity, options) {
 async function runUsageReport(granularity, options) {
   const preparedReport = await prepareUsageReport(granularity, options);
   emitDiagnostics(preparedReport.diagnostics, logger);
+  emitEnvVarOverrides(preparedReport.diagnostics.activeEnvOverrides, logger);
   if (preparedReport.format === "terminal") {
-    const overflowColumns = detectTerminalOverflowColumns(preparedReport.output);
-    if (overflowColumns !== void 0) {
-      logger.warn(
-        `Report table is wider than terminal by ${overflowColumns} column(s). Use fullscreen/maximized terminal for better readability.`
-      );
-    }
+    warnIfTerminalTableOverflows(preparedReport.output, (message) => {
+      logger.warn(message);
+    });
   }
   console.log(preparedReport.output);
 }
@@ -4352,11 +5842,12 @@ function getSupportedSourceIds() {
 function getAllowedSourcesLabel(supportedSourceIds) {
   return supportedSourceIds.join(", ");
 }
-function addSharedOptions(command) {
+function addSharedOptions(command, options = {}) {
   const supportedSourceIds = getSupportedSourceIds();
   const allowedSourcesLabel = getAllowedSourcesLabel(supportedSourceIds);
   const supportedSourcesSummary = `(${supportedSourceIds.length}): ${allowedSourcesLabel}`;
-  return command.option("--pi-dir <path>", "Path to .pi sessions directory").option("--codex-dir <path>", "Path to .codex sessions directory").option("--opencode-db <path>", "Path to OpenCode SQLite DB").option(
+  const includePerModelColumns = options.includePerModelColumns ?? true;
+  const configuredCommand = command.option("--pi-dir <path>", "Path to .pi sessions directory").option("--codex-dir <path>", "Path to .codex sessions directory").option("--gemini-dir <path>", "Path to .gemini directory").option("--opencode-db <path>", "Path to OpenCode SQLite DB").option(
     "--source-dir <source-id=path>",
     "Override source directory for directory-backed sources (repeatable)",
     collectRepeatedOption,
@@ -4371,7 +5862,14 @@ function addSharedOptions(command) {
     "Filter by model (repeatable/comma-separated; exact when exact match exists after source/provider/date filters, otherwise substring)",
     collectRepeatedOption,
     []
-  ).option("--pricing-url <url>", "Override LiteLLM pricing source URL").option("--pricing-offline", "Use cached LiteLLM pricing only (no network fetch)").option("--markdown", "Render output as markdown table").option("--json", "Render output as JSON").option(
+  ).option("--pricing-url <url>", "Override LiteLLM pricing source URL").option("--pricing-offline", "Use cached LiteLLM pricing only (no network fetch)").option(
+    "--ignore-pricing-failures",
+    "Continue without estimated costs when pricing cannot be loaded"
+  ).option("--markdown", "Render output as markdown table").option("--json", "Render output as JSON");
+  if (!includePerModelColumns) {
+    return configuredCommand;
+  }
+  return configuredCommand.option(
     "--per-model-columns",
     "Render per-model metrics as multiline aligned table columns (terminal/markdown)"
   );
@@ -4393,6 +5891,20 @@ function createCommand(granularity) {
   });
   return command;
 }
+function parseGranularityArgument(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "daily" || normalized === "weekly" || normalized === "monthly") {
+    return normalized;
+  }
+  throw new Error(`Invalid granularity: ${value}. Expected one of: daily, weekly, monthly`);
+}
+function createEfficiencyCommand() {
+  const command = new Command("efficiency");
+  addSharedOptions(command, { includePerModelColumns: false }).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").description("Show efficiency report by correlating usage metrics with local Git outcomes").action(async (granularity, options) => {
+    await runEfficiencyReport(granularity, options);
+  });
+  return command;
+}
 function rootDescription() {
   const supportedSourceIds = getSupportedSourceIds();
   const allowedSourcesLabel = getAllowedSourcesLabel(supportedSourceIds);
@@ -4409,13 +5921,15 @@ function rootDescription() {
     "  $ llm-usage monthly --since 2026-01-01 --until 2026-01-31 --source pi,codex --json",
     "  $ llm-usage monthly --source opencode --opencode-db /path/to/opencode.db --json",
     "  $ llm-usage monthly --model claude --per-model-columns",
-    "  $ llm-usage daily --source-dir pi=/tmp/pi-sessions",
+    "  $ llm-usage daily --source-dir pi=/tmp/pi-sessions --source-dir gemini=/tmp/.gemini",
+    "  $ llm-usage daily --pi-dir /tmp/pi-sessions --gemini-dir /tmp/.gemini",
+    "  $ llm-usage efficiency weekly --repo-dir /path/to/repo --json",
     "  $ npx --yes llm-usage-metrics daily"
   ].join("\n");
 }
 function createCli(options = {}) {
   const program = new Command();
-  program.name("llm-usage").description(rootDescription()).version(options.version ?? "0.0.0").showHelpAfterError().addCommand(createCommand("daily")).addCommand(createCommand("weekly")).addCommand(createCommand("monthly"));
+  program.name("llm-usage").description(rootDescription()).version(options.version ?? "0.0.0").showHelpAfterError().addCommand(createCommand("daily")).addCommand(createCommand("weekly")).addCommand(createCommand("monthly")).addCommand(createEfficiencyCommand());
   return program;
 }