iteration-cli 0.10.1 → 0.12.0

package/dist/cli.js

@@ -648,7 +648,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os8 = __require("os");
+    var os9 = __require("os");
     var tty = __require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -696,7 +696,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os8.release().split(".");
+        const osRelease = os9.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -933,9 +933,9 @@ var require_src = __commonJS({
 
 // src/cli.ts
 import { spawnSync } from "node:child_process";
-import os7 from "node:os";
-import path18 from "node:path";
-import { promises as fs14 } from "node:fs";
+import os8 from "node:os";
+import path21 from "node:path";
+import { promises as fs17 } from "node:fs";
 import { createInterface as createInterface3 } from "node:readline/promises";
 import { parseArgs } from "node:util";
 
@@ -1175,10 +1175,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path19) {
-  if (!path19)
+function getElementAtPath(obj, path22) {
+  if (!path22)
     return obj;
-  return path19.reduce((acc, key) => acc?.[key], obj);
+  return path22.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1518,11 +1518,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path19, issues) {
+function prefixIssues(path22, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path19);
+    iss.path.unshift(path22);
     return iss;
   });
 }
@@ -1968,16 +1968,16 @@ function flattenError(error2, mapper = (issue2) => issue2.message) {
 }
 function formatError(error2, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error3, path19 = []) => {
+  const processError = (error3, path22 = []) => {
     for (const issue2 of error3.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path19, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path19, ...issue2.path];
+        const fullpath = [...path22, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -7447,12 +7447,37 @@ function json(params) {
   return jsonSchema;
 }
 
+// ../../node_modules/.pnpm/zod@4.6.4/node_modules/zod/v4/classic/iso.js
+var iso_exports = {};
+__export(iso_exports, {
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  date: () => date2,
+  datetime: () => datetime2,
+  duration: () => duration2,
+  time: () => time2
+});
+function datetime2(params) {
+  return _isoDateTime(ZodISODateTime, params);
+}
+function date2(params) {
+  return _isoDate(ZodISODate, params);
+}
+function time2(params) {
+  return _isoTime(ZodISOTime, params);
+}
+function duration2(params) {
+  return _isoDuration(ZodISODuration, params);
+}
+
 // ../../node_modules/.pnpm/zod@4.6.4/node_modules/zod/v4/classic/coerce.js
 var coerce_exports = {};
 __export(coerce_exports, {
   bigint: () => bigint2,
   boolean: () => boolean3,
-  date: () => date2,
+  date: () => date3,
   number: () => number3,
   string: () => string3
 });
@@ -7468,7 +7493,7 @@ function boolean3(params) {
 function bigint2(params) {
   return _coercedBigint(ZodBigInt, params);
 }
-function date2(params) {
+function date3(params) {
   return _coercedDate(ZodDate, params);
 }
 
@@ -7513,6 +7538,53 @@ function collectorSourceLabel(source) {
   return COLLECTOR_SOURCE_LABELS[source];
 }
 var MAX_TRACE_EVENTS_PER_BATCH = 100;
+var cursorBillingRequestSchema = object({
+  conversationId: uuid2(),
+  reconcileFromMs: number2().int().nonnegative().nullable(),
+  events: array(object({
+    timestamp: number2().int().nonnegative(),
+    kind: _enum([
+      "included",
+      "paid",
+      "byok",
+      "not_charged",
+      "unknown"
+    ]),
+    inputTokens: number2().int().nonnegative().nullable(),
+    outputTokens: number2().int().nonnegative().nullable(),
+    cacheReadTokens: number2().int().nonnegative().nullable(),
+    cacheWriteTokens: number2().int().nonnegative().nullable(),
+    paidUsd: number2().finite().nonnegative().nullable()
+  }).strict()).max(5e3)
+}).strict();
+function codexCreditSign(value) {
+  const mantissa = value.split(/[eE]/, 1)[0];
+  if (!/[1-9]/.test(mantissa))
+    return 0;
+  return mantissa.startsWith("-") ? -1 : 1;
+}
+var codexBillingRequestSchema = object({
+  accountFingerprint: string2().regex(/^[0-9a-f]{64}$/),
+  reconcile: boolean2(),
+  tasks: array(object({
+    threadId: uuid2(),
+    createdAt: iso_exports.datetime().nullable(),
+    descendantThreadIds: array(uuid2()).max(900),
+    dataStatus: _enum([
+      "available",
+      "partial",
+      "unavailable",
+      "not_queried"
+    ]),
+    usageSource: string2().max(100),
+    balanceUsageCredits: string2().regex(/^[+-]?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d{1,3})?$/).max(128).nullable()
+  }).strict()).max(100),
+  authTurns: array(object({
+    threadId: uuid2(),
+    turnId: uuid2(),
+    mode: _enum(["chatgpt", "api_key", "conflicting"])
+  }).strict()).max(5e3)
+}).strict();
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 var TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
 var unpairedSurrogate = /[\uD800-\uDFFF]/u;
@@ -7975,10 +8047,10 @@ async function authenticateAndEnrollCollector(endpoint, deviceNameValue, organiz
 }
 
 // src/auto-connect.ts
-import { promises as fs10 } from "node:fs";
+import { promises as fs12 } from "node:fs";
 import { createHmac } from "node:crypto";
 import os6 from "node:os";
-import path10 from "node:path";
+import path12 from "node:path";
 
 // src/background-service.ts
 import os4 from "node:os";
@@ -9330,14 +9402,100 @@ var collectorFetch = (input, init = {}) => {
 
 // src/turn-summary.ts
 import { createHash as createHash3 } from "node:crypto";
-import { promises as fs8 } from "node:fs";
-import path8 from "node:path";
+import { promises as fs10 } from "node:fs";
+import path10 from "node:path";
+
+// src/claude-git-hook.ts
+import { randomUUID } from "node:crypto";
+import { promises as fs9 } from "node:fs";
+import path9 from "node:path";
+
+// src/git-repository.ts
+import fs7 from "node:fs";
+import path6 from "node:path";
+var repositoryUrls = /* @__PURE__ */ new Map();
+function missing(error2) {
+  const code = error2.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function readText(file) {
+  try {
+    return fs7.readFileSync(file, "utf8");
+  } catch (error2) {
+    if (missing(error2)) return null;
+    throw error2;
+  }
+}
+function gitFiles(cwd) {
+  try {
+    if (!fs7.statSync(cwd).isDirectory()) return null;
+  } catch (error2) {
+    if (missing(error2)) return null;
+    throw error2;
+  }
+  for (let directory = cwd; ; directory = path6.dirname(directory)) {
+    const dotGit = path6.join(directory, ".git");
+    let stats;
+    try {
+      stats = fs7.statSync(dotGit);
+    } catch (error2) {
+      if (!missing(error2)) throw error2;
+      if (path6.dirname(directory) === directory) return null;
+      continue;
+    }
+    if (stats.isDirectory())
+      return { directory: dotGit, config: path6.join(dotGit, "config") };
+    const pointer = /^gitdir:\s*(.+?)\s*$/m.exec(readText(dotGit) ?? "");
+    if (pointer === null) return null;
+    const gitDirectory = path6.resolve(directory, pointer[1]);
+    const common = readText(path6.join(gitDirectory, "commondir"))?.trim();
+    return {
+      directory: gitDirectory,
+      config: path6.join(
+        common ? path6.resolve(gitDirectory, common) : gitDirectory,
+        "config"
+      )
+    };
+  }
+}
+function originUrl(config2) {
+  let inOrigin = false;
+  for (const line of config2.split(/\r?\n/)) {
+    const section = /^\s*\[\s*([^\]]+?)\s*\]/.exec(line);
+    if (section !== null) {
+      inOrigin = /^remote\s+"origin"$/i.test(section[1]);
+      continue;
+    }
+    const url2 = inOrigin ? /^\s*url\s*=\s*(.+?)\s*$/i.exec(line) : null;
+    if (url2 !== null) return url2[1].replace(/^"(.*)"$/, "$1");
+  }
+  return null;
+}
+function withoutCredentials(url2) {
+  return url2.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/i, "$1");
+}
+function gitRepositoryUrl(cwd) {
+  const known = repositoryUrls.get(cwd);
+  if (known !== void 0) return known;
+  const files = gitFiles(cwd);
+  const config2 = files === null ? null : readText(files.config);
+  const origin = config2 === null ? null : originUrl(config2);
+  const url2 = origin === null ? null : withoutCredentials(origin);
+  if (url2 !== null) repositoryUrls.set(cwd, url2);
+  return url2;
+}
+function gitBranch(cwd) {
+  const files = gitFiles(cwd);
+  const head = files === null ? null : readText(path6.join(files.directory, "HEAD"));
+  const branch = /^ref: refs\/heads\/(.+)\s*$/.exec(head ?? "")?.[1];
+  return branch ?? null;
+}
 
 // src/storage.ts
 import { once } from "node:events";
-import { createReadStream, createWriteStream as createWriteStream2, promises as fs7 } from "node:fs";
+import { createReadStream, createWriteStream as createWriteStream2, promises as fs8 } from "node:fs";
 import os5 from "node:os";
-import path7 from "node:path";
+import path8 from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 
 // ../../node_modules/.pnpm/@secretlint+core@13.0.6/node_modules/@secretlint/core/module/SecretLintSourceCodeImpl.js
@@ -10166,7 +10324,7 @@ var registerRule = ({ sourceCode, config: config2, descriptorRule, contextEvents
 };
 
 // ../../node_modules/.pnpm/@secretlint+secretlint-rule-preset-recommend@13.0.6/node_modules/@secretlint/secretlint-rule-preset-recommend/module/index.js
-import path6 from "node:path";
+import path7 from "node:path";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 var regexpStringMatcher = {};
 var lodash_uniq;
@@ -11148,11 +11306,11 @@ function requireLodash_sortby() {
     function baseForOwn(object3, iteratee) {
       return object3 && baseFor(object3, iteratee, keys);
     }
-    function baseGet(object3, path19) {
-      path19 = isKey(path19, object3) ? [path19] : castPath(path19);
-      var index = 0, length = path19.length;
+    function baseGet(object3, path22) {
+      path22 = isKey(path22, object3) ? [path22] : castPath(path22);
+      var index = 0, length = path22.length;
       while (object3 != null && index < length) {
-        object3 = object3[toKey(path19[index++])];
+        object3 = object3[toKey(path22[index++])];
       }
       return index && index == length ? object3 : void 0;
     }
@@ -11279,13 +11437,13 @@ function requireLodash_sortby() {
         return object3 === source || baseIsMatch(object3, source, matchData);
       };
     }
-    function baseMatchesProperty(path19, srcValue) {
-      if (isKey(path19) && isStrictComparable(srcValue)) {
-        return matchesStrictComparable(toKey(path19), srcValue);
+    function baseMatchesProperty(path22, srcValue) {
+      if (isKey(path22) && isStrictComparable(srcValue)) {
+        return matchesStrictComparable(toKey(path22), srcValue);
       }
       return function(object3) {
-        var objValue = get(object3, path19);
-        return objValue === void 0 && objValue === srcValue ? hasIn(object3, path19) : baseIsEqual(srcValue, objValue, void 0, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
+        var objValue = get(object3, path22);
+        return objValue === void 0 && objValue === srcValue ? hasIn(object3, path22) : baseIsEqual(srcValue, objValue, void 0, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
       };
     }
     function baseOrderBy(collection, iteratees, orders) {
@@ -11301,9 +11459,9 @@ function requireLodash_sortby() {
         return compareMultiple(object3, other, orders);
       });
     }
-    function basePropertyDeep(path19) {
+    function basePropertyDeep(path22) {
       return function(object3) {
-        return baseGet(object3, path19);
+        return baseGet(object3, path22);
       };
     }
     function baseRest(func, start2) {
@@ -11558,11 +11716,11 @@ function requireLodash_sortby() {
         return result;
       };
     }
-    function hasPath(object3, path19, hasFunc) {
-      path19 = isKey(path19, object3) ? [path19] : castPath(path19);
-      var result, index = -1, length = path19.length;
+    function hasPath(object3, path22, hasFunc) {
+      path22 = isKey(path22, object3) ? [path22] : castPath(path22);
+      var result, index = -1, length = path22.length;
       while (++index < length) {
-        var key = toKey(path19[index]);
+        var key = toKey(path22[index]);
         if (!(result = object3 != null && hasFunc(object3, key))) {
           break;
         }
@@ -11717,12 +11875,12 @@ function requireLodash_sortby() {
     function toString(value) {
       return value == null ? "" : baseToString(value);
     }
-    function get(object3, path19, defaultValue) {
-      var result = object3 == null ? void 0 : baseGet(object3, path19);
+    function get(object3, path22, defaultValue) {
+      var result = object3 == null ? void 0 : baseGet(object3, path22);
       return result === void 0 ? defaultValue : result;
     }
-    function hasIn(object3, path19) {
-      return object3 != null && hasPath(object3, path19, baseHasIn);
+    function hasIn(object3, path22) {
+      return object3 != null && hasPath(object3, path22, baseHasIn);
     }
     function keys(object3) {
       return isArrayLike(object3) ? arrayLikeKeys(object3) : baseKeys(object3);
@@ -11730,8 +11888,8 @@ function requireLodash_sortby() {
     function identity(value) {
       return value;
     }
-    function property(path19) {
-      return isKey(path19) ? baseProperty(toKey(path19)) : basePropertyDeep(path19);
+    function property(path22) {
+      return isKey(path22) ? baseProperty(toKey(path22)) : basePropertyDeep(path22);
     }
     module.exports = sortBy;
   })(lodash_sortby, lodash_sortby.exports);
@@ -12162,16 +12320,16 @@ async function reportIfFoundPrivateKeyP12Format({ source, context, t }) {
     return;
   }
   try {
-    const fs15 = await import("node:fs");
-    const path19 = await import("node:path");
-    const pfxBytes = new Uint8Array(fs15.readFileSync(source.filePath));
+    const fs18 = await import("node:fs");
+    const path22 = await import("node:path");
+    const pfxBytes = new Uint8Array(fs18.readFileSync(source.filePath));
     const isGcpServiceAccountP12 = await verifyPkcs12Mac(pfxBytes, GCP_SERVICE_ACCOUNT_P12_PASSWORD);
     if (!isGcpServiceAccountP12) {
       return;
     }
     context.report({
       message: t("PrivateKeyP12", {
-        FILE_NAME: path19.basename(source.filePath)
+        FILE_NAME: path22.basename(source.filePath)
       }),
       range: [0, source.content.length]
     });
@@ -12198,7 +12356,7 @@ function reportIfFoundPrivateKeyJSONFormat({ source, context, t }) {
     }
     context.report({
       message: t("PrivateKeyJSON", {
-        FILE_NAME: source.filePath ? path6.basename(source.filePath) : ""
+        FILE_NAME: source.filePath ? path7.basename(source.filePath) : ""
       }),
       range: [0, source.content.length]
     });
@@ -14272,7 +14430,7 @@ function parseOutboxEvent(line) {
   return event3;
 }
 function defaultCollectorDirectory(source) {
-  return path7.join(os5.homedir(), ".config", "iteration", `${source}-collector`);
+  return path8.join(os5.homedir(), ".config", "iteration", `${source}-collector`);
 }
 function validateCollectorEndpoint(endpoint) {
   let parsed;
@@ -14298,18 +14456,18 @@ function validateCollectorEndpoint(endpoint) {
 }
 function collectorPaths(directory = defaultCollectorDirectory("codex")) {
   return {
-    config: path7.join(directory, "config.json"),
-    state: path7.join(directory, "state.json"),
-    outbox: path7.join(directory, "outbox.jsonl"),
-    redactionMarker: path7.join(directory, "redaction.json"),
-    lock: path7.join(directory, "collector.lock"),
-    historyBackfill: path7.join(directory, "history-backfill.json"),
-    health: path7.join(directory, "health.json")
+    config: path8.join(directory, "config.json"),
+    state: path8.join(directory, "state.json"),
+    outbox: path8.join(directory, "outbox.jsonl"),
+    redactionMarker: path8.join(directory, "redaction.json"),
+    lock: path8.join(directory, "collector.lock"),
+    historyBackfill: path8.join(directory, "history-backfill.json"),
+    health: path8.join(directory, "health.json")
   };
 }
 async function assertFreshCollectorDirectory(paths, source = "codex") {
   const state = await loadState(paths);
-  const configExists = await fs7.access(paths.config).then(() => true).catch((error2) => {
+  const configExists = await fs8.access(paths.config).then(() => true).catch((error2) => {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return false;
     throw error2;
@@ -14326,12 +14484,12 @@ async function assertFreshCollectorDirectory(paths, source = "codex") {
   }
 }
 async function ensurePrivateDirectory(directory) {
-  await fs7.mkdir(directory, { recursive: true, mode: 448 });
-  await fs7.chmod(directory, 448);
+  await fs8.mkdir(directory, { recursive: true, mode: 448 });
+  await fs8.chmod(directory, 448);
 }
 async function writeJsonAtomic(filename, value) {
   const temporary = `${filename}.${process.pid}.tmp`;
-  const handle = await fs7.open(temporary, "w", 384);
+  const handle = await fs8.open(temporary, "w", 384);
   try {
     await handle.writeFile(`${JSON.stringify(value)}
 `, "utf8");
@@ -14339,16 +14497,16 @@ async function writeJsonAtomic(filename, value) {
   } finally {
     await handle.close();
   }
-  await fs7.rename(temporary, filename);
+  await fs8.rename(temporary, filename);
 }
 async function saveConfig(config2, paths) {
-  await ensurePrivateDirectory(path7.dirname(paths.config));
+  await ensurePrivateDirectory(path8.dirname(paths.config));
   await writeJsonAtomic(paths.config, config2);
 }
 async function loadHealth(paths) {
   let contents;
   try {
-    contents = await fs7.readFile(paths.health, "utf8");
+    contents = await fs8.readFile(paths.health, "utf8");
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
       return {
@@ -14390,13 +14548,13 @@ async function healthSnapshot(paths) {
   }
 }
 async function saveHealth(health, paths) {
-  await ensurePrivateDirectory(path7.dirname(paths.health));
+  await ensurePrivateDirectory(path8.dirname(paths.health));
   await writeJsonAtomic(paths.health, health);
 }
 async function loadConfig(paths) {
   let contents;
   try {
-    contents = await fs7.readFile(paths.config, "utf8");
+    contents = await fs8.readFile(paths.config, "utf8");
   } catch (error2) {
     throw new Error(`Could not read collector config at ${paths.config}.`, {
       cause: error2
@@ -14423,7 +14581,7 @@ async function loadConfig(paths) {
 async function loadState(paths) {
   let contents;
   try {
-    contents = await fs7.readFile(paths.state, "utf8");
+    contents = await fs8.readFile(paths.state, "utf8");
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
       return {
@@ -14453,12 +14611,12 @@ async function loadState(paths) {
   return parsed.data;
 }
 async function saveState(state, paths) {
-  await ensurePrivateDirectory(path7.dirname(paths.state));
+  await ensurePrivateDirectory(path8.dirname(paths.state));
   await writeJsonAtomic(paths.state, state);
 }
 async function outboxSize(paths) {
   try {
-    return (await fs7.stat(paths.outbox)).size;
+    return (await fs8.stat(paths.outbox)).size;
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return 0;
@@ -14473,7 +14631,7 @@ async function pendingEventIds(paths) {
   if (size > MAX_OUTBOX_BYTES)
     throw new Error("Trace outbox exceeds its configured capacity.");
   try {
-    const input = await fs7.open(paths.outbox, "r");
+    const input = await fs8.open(paths.outbox, "r");
     const stream = input.createReadStream({
       autoClose: true,
       encoding: "utf8"
@@ -14500,8 +14658,8 @@ async function appendEvents(events, paths) {
       "Trace outbox is full; upload pending data before scanning more sessions."
     );
   }
-  await ensurePrivateDirectory(path7.dirname(paths.outbox));
-  const handle = await fs7.open(paths.outbox, "a", 384);
+  await ensurePrivateDirectory(path8.dirname(paths.outbox));
+  const handle = await fs8.open(paths.outbox, "a", 384);
   try {
     await handle.writeFile(contents, "utf8");
     await handle.sync();
@@ -14512,7 +14670,7 @@ async function appendEvents(events, paths) {
 async function redactPendingOutbox(paths) {
   let marker;
   try {
-    marker = await fs7.readFile(paths.redactionMarker, "utf8");
+    marker = await fs8.readFile(paths.redactionMarker, "utf8");
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       marker = null;
@@ -14534,7 +14692,7 @@ async function redactPendingOutbox(paths) {
     throw new Error("Trace outbox exceeds its configured capacity.");
   if (size > 0) {
     const temporary = `${paths.outbox}.${process.pid}.redacting`;
-    const output = await fs7.open(temporary, "w", 384);
+    const output = await fs8.open(temporary, "w", 384);
     try {
       const lines = createInterface2({
         input: createReadStream(paths.outbox, { encoding: "utf8" }),
@@ -14548,28 +14706,28 @@ async function redactPendingOutbox(paths) {
       await output.sync();
     } catch (error2) {
       await output.close();
-      await fs7.rm(temporary, { force: true });
+      await fs8.rm(temporary, { force: true });
       throw error2;
     }
     await output.close();
     try {
-      if ((await fs7.stat(temporary)).size > MAX_OUTBOX_BYTES)
+      if ((await fs8.stat(temporary)).size > MAX_OUTBOX_BYTES)
         throw new Error(
           "Redacted trace outbox exceeds its configured capacity."
         );
-      await fs7.rename(temporary, paths.outbox);
-      const directory = await fs7.open(path7.dirname(paths.outbox), "r");
+      await fs8.rename(temporary, paths.outbox);
+      const directory = await fs8.open(path8.dirname(paths.outbox), "r");
       try {
         await directory.sync();
       } finally {
         await directory.close();
       }
     } catch (error2) {
-      await fs7.rm(temporary, { force: true });
+      await fs8.rm(temporary, { force: true });
       throw error2;
     }
   }
-  await ensurePrivateDirectory(path7.dirname(paths.redactionMarker));
+  await ensurePrivateDirectory(path8.dirname(paths.redactionMarker));
   await writeJsonAtomic(paths.redactionMarker, { version: 1 });
 }
 async function nextBatch(paths, maxBytes) {
@@ -14580,7 +14738,7 @@ async function nextBatch(paths, maxBytes) {
   if (size === 0) return [];
   if (size > MAX_OUTBOX_BYTES)
     throw new Error("Trace outbox exceeds its configured capacity.");
-  const input = await fs7.open(paths.outbox, "r");
+  const input = await fs8.open(paths.outbox, "r");
   const stream = input.createReadStream({ autoClose: true, encoding: "utf8" });
   const lines = createInterface2({ input: stream, crlfDelay: Infinity });
   const events = [];
@@ -14604,7 +14762,7 @@ async function nextBatch(paths, maxBytes) {
 }
 async function acknowledgeEvents(acknowledgedIds, paths) {
   const temporary = `${paths.outbox}.${process.pid}.tmp`;
-  const input = await fs7.open(paths.outbox, "r").catch((error2) => {
+  const input = await fs8.open(paths.outbox, "r").catch((error2) => {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return null;
     throw error2;
@@ -14625,28 +14783,28 @@ async function acknowledgeEvents(acknowledgedIds, paths) {
     }
     output.end();
     await once(output, "close");
-    const durable = await fs7.open(temporary, "r+");
+    const durable = await fs8.open(temporary, "r+");
     try {
       await durable.sync();
     } finally {
       await durable.close();
     }
-    await fs7.rename(temporary, paths.outbox);
+    await fs8.rename(temporary, paths.outbox);
   } catch (error2) {
     output.destroy();
-    await fs7.rm(temporary, { force: true });
+    await fs8.rm(temporary, { force: true });
     throw error2;
   }
 }
 async function prepareSourceInitialState(source, home, includeHistory) {
-  const sourceDirectory = path7.resolve(home);
+  const sourceDirectory = path8.resolve(home);
   const files = await sourceFiles(source, sourceDirectory);
   const cursors = {};
   if (!includeHistory) {
     for (const filename of files) {
       cursors[filename] = await lastCompleteRecordOffset(
         filename,
-        (await fs7.stat(filename)).size
+        (await fs8.stat(filename)).size
       );
     }
   }
@@ -14662,7 +14820,7 @@ async function ensureStartableState(config2, paths) {
   const directory = collectorSourceDirectory(config2);
   const state = await loadState(paths);
   if (state.initialized) {
-    if (state.sourceDirectory !== path7.resolve(directory)) {
+    if (state.sourceDirectory !== path8.resolve(directory)) {
       throw new Error(
         `Collector state belongs to another ${source} directory; use a separate --data-directory.`
       );
@@ -14685,7 +14843,7 @@ var historyBackfillMarkerSchema = object({ version: number2().int().min(1).max(H
 async function readHistoryBackfillVersion(paths) {
   let marker;
   try {
-    marker = await fs7.readFile(paths.historyBackfill, "utf8");
+    marker = await fs8.readFile(paths.historyBackfill, "utf8");
   } catch (error2) {
     if (!(error2 instanceof Error && "code" in error2 && error2.code === "ENOENT"))
       throw error2;
@@ -14711,12 +14869,12 @@ async function ensureHistoryBackfill(codexHome, paths) {
   const version2 = await readHistoryBackfillVersion(paths);
   if (version2 !== null && version2 >= HISTORY_BACKFILL_VERSION) return false;
   const state = await loadState(paths);
-  if (!state.initialized || state.sourceDirectory !== path7.resolve(codexHome)) {
+  if (!state.initialized || state.sourceDirectory !== path8.resolve(codexHome)) {
     throw new Error(
       "Collector state does not match CODEX_HOME; reconnect Codex before uploading."
     );
   }
-  await rolloutFiles(path7.join(codexHome, "sessions"));
+  await rolloutFiles(path8.join(codexHome, "sessions"));
   await saveState({ ...state, cursors: {}, skipping: [] }, paths);
   await writeJsonAtomic(paths.historyBackfill, {
     version: HISTORY_BACKFILL_VERSION
@@ -14729,12 +14887,12 @@ async function ensureClaudeHistoryBackfill(claudeHome, paths) {
   if (version2 !== null && version2 >= CLAUDE_HISTORY_BACKFILL_VERSION)
     return false;
   const state = await loadState(paths);
-  if (!state.initialized || state.sourceDirectory !== path7.resolve(claudeHome)) {
+  if (!state.initialized || state.sourceDirectory !== path8.resolve(claudeHome)) {
     throw new Error(
       "Collector state does not match the Claude directory; reconnect Claude before uploading."
     );
   }
-  await claudeFiles(path7.join(claudeHome, "projects"));
+  await claudeFiles(path8.join(claudeHome, "projects"));
   await saveState({ ...state, cursors: {}, skipping: [] }, paths);
   await writeJsonAtomic(paths.historyBackfill, {
     version: CLAUDE_HISTORY_BACKFILL_VERSION
@@ -14745,11 +14903,11 @@ async function ensureCursorHistoryBackfill(cursorHome, paths) {
   const version2 = await readHistoryBackfillVersion(paths);
   if (version2 !== null && version2 >= 1) return false;
   const state = await loadState(paths);
-  if (!state.initialized || state.sourceDirectory !== path7.resolve(cursorHome))
+  if (!state.initialized || state.sourceDirectory !== path8.resolve(cursorHome))
     throw new Error(
       "Collector state does not match the Cursor directory; reconnect Cursor before uploading."
     );
-  await cursorFiles(path7.join(cursorHome, "projects"));
+  await cursorFiles(path8.join(cursorHome, "projects"));
   await saveState({ ...state, cursors: {}, skipping: [] }, paths);
   await writeJsonAtomic(paths.historyBackfill, { version: 1 });
   return true;
@@ -14758,7 +14916,7 @@ async function historyScanProgress(home, paths, source = "codex") {
   if (await readHistoryBackfillVersion(paths) === null)
     return { kind: "waiting" };
   const state = await loadState(paths);
-  if (!state.initialized || state.sourceDirectory !== path7.resolve(home)) {
+  if (!state.initialized || state.sourceDirectory !== path8.resolve(home)) {
     throw new Error(`Collector state does not match the ${source} directory.`);
   }
   const files = await sourceFiles(source, home);
@@ -14769,7 +14927,7 @@ async function historyScanProgress(home, paths, source = "codex") {
     const sizes = await Promise.all(
       batch.map(async (filename) => {
         try {
-          return (await fs7.stat(filename)).size;
+          return (await fs8.stat(filename)).size;
         } catch (error2) {
           if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
             return null;
@@ -14793,7 +14951,7 @@ async function historyScanProgress(home, paths, source = "codex") {
 }
 async function resetHistoryCursors(home, paths, source = "codex") {
   const state = await loadState(paths);
-  const sourceDirectory = path7.resolve(home);
+  const sourceDirectory = path8.resolve(home);
   if (!state.initialized || state.sourceDirectory !== sourceDirectory) {
     throw new Error(
       `Connect the ${source} source before importing its history.`
@@ -14804,7 +14962,7 @@ async function resetHistoryCursors(home, paths, source = "codex") {
   let bytes = 0;
   for (const filename of files) {
     cursors[filename] = 0;
-    bytes += (await fs7.stat(filename)).size;
+    bytes += (await fs8.stat(filename)).size;
     if (!Number.isSafeInteger(bytes)) {
       throw new Error(`${source} history size exceeds the supported limit.`);
     }
@@ -14831,7 +14989,7 @@ async function historyImportSize(home, source = "codex") {
   const files = await sourceFiles(source, home);
   let bytes = 0;
   for (const filename of files) {
-    bytes += (await fs7.stat(filename)).size;
+    bytes += (await fs8.stat(filename)).size;
     if (!Number.isSafeInteger(bytes)) {
       throw new Error(`${source} history size exceeds the supported limit.`);
     }
@@ -14840,7 +14998,7 @@ async function historyImportSize(home, source = "codex") {
 }
 async function lastCompleteRecordOffset(filename, size) {
   if (size === 0) return 0;
-  const handle = await fs7.open(filename, "r");
+  const handle = await fs8.open(filename, "r");
   try {
     const finalByte = Buffer.alloc(1);
     await handle.read(finalByte, 0, 1, size - 1);
@@ -14871,7 +15029,7 @@ async function rolloutFiles(root) {
     if (directory === void 0) continue;
     let entries2;
     try {
-      entries2 = await fs7.readdir(directory, { withFileTypes: true });
+      entries2 = await fs8.readdir(directory, { withFileTypes: true });
     } catch (error2) {
       if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
         continue;
@@ -14880,7 +15038,7 @@ async function rolloutFiles(root) {
       });
     }
     for (const entry of entries2) {
-      const filename = path7.join(directory, entry.name);
+      const filename = path8.join(directory, entry.name);
       if (entry.isDirectory()) pending.push(filename);
       else if (entry.isFile() && /^rollout-.+\.jsonl$/.test(entry.name))
         files.push(filename);
@@ -14892,7 +15050,7 @@ async function rolloutFiles(root) {
 }
 async function directoryEntries(directory) {
   try {
-    return await fs7.readdir(directory, { withFileTypes: true });
+    return await fs8.readdir(directory, { withFileTypes: true });
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return [];
@@ -14905,16 +15063,16 @@ async function claudeFiles(root) {
   const files = [];
   for (const project of await directoryEntries(root)) {
     if (!project.isDirectory()) continue;
-    const projectDirectory = path7.join(root, project.name);
+    const projectDirectory = path8.join(root, project.name);
     for (const entry of await directoryEntries(projectDirectory)) {
-      const filename = path7.join(projectDirectory, entry.name);
+      const filename = path8.join(projectDirectory, entry.name);
       if (entry.isFile() && /^[^/]+\.jsonl$/.test(entry.name) && !entry.name.includes(".orphaned-") && !entry.name.includes(".superseded-")) {
         files.push(filename);
       } else if (entry.isDirectory()) {
-        const subagents = path7.join(filename, "subagents");
+        const subagents = path8.join(filename, "subagents");
         for (const agent of await directoryEntries(subagents)) {
           if (agent.isFile() && /^agent-.+\.jsonl$/.test(agent.name))
-            files.push(path7.join(subagents, agent.name));
+            files.push(path8.join(subagents, agent.name));
         }
       }
       if (files.length > 1e4)
@@ -14924,10 +15082,10 @@ async function claudeFiles(root) {
   return files.sort();
 }
 function sourceFiles(source, home) {
-  const directory = path7.resolve(home);
-  if (source === "codex") return rolloutFiles(path7.join(directory, "sessions"));
-  if (source === "claude") return claudeFiles(path7.join(directory, "projects"));
-  if (source === "cursor") return cursorFiles(path7.join(directory, "projects"));
+  const directory = path8.resolve(home);
+  if (source === "codex") return rolloutFiles(path8.join(directory, "sessions"));
+  if (source === "claude") return claudeFiles(path8.join(directory, "projects"));
+  if (source === "cursor") return cursorFiles(path8.join(directory, "projects"));
   const unhandled = source;
   throw new Error(`Unsupported collector source: ${unhandled}`);
 }
@@ -14935,15 +15093,15 @@ async function cursorFiles(root) {
   const files = [];
   for (const project of await directoryEntries(root)) {
     if (!project.isDirectory()) continue;
-    const transcripts = path7.join(root, project.name, "agent-transcripts");
+    const transcripts = path8.join(root, project.name, "agent-transcripts");
     for (const conversation of await directoryEntries(transcripts)) {
       if (!conversation.isDirectory()) continue;
-      const filename = path7.join(
+      const filename = path8.join(
         transcripts,
         conversation.name,
         `${conversation.name}.jsonl`
       );
-      if ((await fs7.stat(filename).catch((error2) => {
+      if ((await fs8.stat(filename).catch((error2) => {
         if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
           return null;
         throw error2;
@@ -14956,6 +15114,114 @@ async function cursorFiles(root) {
   return files.sort();
 }
 
+// src/claude-git-hook.ts
+function claudeGitHookPaths(dataDirectory2) {
+  return {
+    script: path9.join(dataDirectory2, "claude-git", "session-start-hook.sh"),
+    queue: path9.join(dataDirectory2, "claude-git", "git-queue"),
+    failure: path9.join(dataDirectory2, "claude-git", "failure.json")
+  };
+}
+var startInput = object({
+  hook_event_name: literal("SessionStart"),
+  session_id: uuid2(),
+  cwd: string2().min(1)
+});
+async function captureClaudeGit(dataDirectory2) {
+  let inputText = "";
+  for await (const chunk of process.stdin) {
+    inputText += chunk.toString();
+    if (inputText.length > 64e3)
+      throw new Error("Claude start hook input is too large.");
+  }
+  const input = startInput.parse(JSON.parse(inputText));
+  if (!path9.isAbsolute(input.cwd))
+    throw new Error("Claude start hook cwd is not absolute.");
+  const git = {
+    branch: gitBranch(input.cwd),
+    repository_url: gitRepositoryUrl(input.cwd)
+  };
+  if (git.branch === null && git.repository_url === null) {
+    process.stdout.write("{}\n");
+    return;
+  }
+  const directory = claudeGitHookPaths(dataDirectory2).queue;
+  await ensurePrivateDirectory(directory);
+  const files = (await fs9.readdir(directory)).filter(
+    (name2) => name2.endsWith(".jsonl")
+  );
+  if (files.length >= 1e4) throw new Error("Claude Git hook queue is full.");
+  const name = randomUUID();
+  const temporary = path9.join(directory, `${name}.tmp`);
+  const filename = path9.join(directory, `${name}.jsonl`);
+  try {
+    const handle = await fs9.open(temporary, "wx", 384);
+    try {
+      await handle.writeFile(
+        `${JSON.stringify({ sessionId: input.session_id, cwd: input.cwd, git, capturedAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`
+      );
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await fs9.rename(temporary, filename);
+  } catch (error2) {
+    await fs9.rm(temporary, { force: true });
+    throw error2;
+  }
+  process.stdout.write("{}\n");
+}
+async function claudeGitHookFiles(dataDirectory2) {
+  const directory = claudeGitHookPaths(dataDirectory2).queue;
+  let names;
+  try {
+    names = await fs9.readdir(directory);
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
+      return [];
+    throw error2;
+  }
+  if (names.length > 1e4)
+    throw new Error("Claude Git hook queue exceeds the scan limit.");
+  return names.filter((name) => /^[0-9a-f-]+\.jsonl$/i.test(name)).sort().map((name) => path9.join(directory, name));
+}
+async function recordClaudeGitHookFailure(dataDirectory2) {
+  const filename = claudeGitHookPaths(dataDirectory2).failure;
+  await ensurePrivateDirectory(path9.dirname(filename));
+  const temporary = `${filename}.${randomUUID()}.tmp`;
+  await fs9.writeFile(temporary, `${JSON.stringify({ atMs: Date.now() })}
+`, {
+    mode: 384
+  });
+  await fs9.rename(temporary, filename);
+}
+async function claudeGitHookFailureAtMs(dataDirectory2) {
+  let contents;
+  try {
+    contents = await fs9.readFile(
+      claudeGitHookPaths(dataDirectory2).failure,
+      "utf8"
+    );
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
+      return null;
+    throw error2;
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(contents);
+  } catch (error2) {
+    throw new Error("Claude Git hook failure status is invalid.", {
+      cause: error2
+    });
+  }
+  const parsed = object({ atMs: number2().int().min(0) }).safeParse(decoded);
+  if (!parsed.success)
+    throw new Error("Claude Git hook failure status is invalid.");
+  return parsed.data.atMs;
+}
+
 // src/turn-summary.ts
 var REFRESH_INTERVAL_MS = 5 * 60 * 1e3;
 var REQUEST_RETENTION_MS = 14 * 24 * 60 * 60 * 1e3;
@@ -14964,13 +15230,13 @@ var REQUEST_TIMEOUT_MS2 = 1e4;
 var HOOK_TIMEOUT_SECONDS = 1;
 var REQUEST_KEY_PATTERN = /^\d{1,10}$/;
 function turnSummaryPaths(dataDirectory2) {
-  const directory = path8.join(dataDirectory2, "turn-summary");
+  const directory = path10.join(dataDirectory2, "turn-summary");
   return {
     directory,
-    script: path8.join(directory, "stop-hook.sh"),
-    requests: path8.join(directory, "requests"),
-    lines: path8.join(directory, "lines"),
-    shown: path8.join(directory, "shown")
+    script: path10.join(directory, "stop-hook.sh"),
+    requests: path10.join(directory, "requests"),
+    lines: path10.join(directory, "lines"),
+    shown: path10.join(directory, "shown")
   };
 }
 function shellQuote(value) {
@@ -15006,19 +15272,22 @@ function hookCommand(paths) {
 function agentHookFile(config2) {
   if ("cursorHome" in config2)
     throw new Error("Cursor uses its own trace hooks.");
-  return "claudeHome" in config2 ? path8.join(config2.claudeHome, "settings.json") : path8.join(config2.codexHome, "hooks.json");
+  return "claudeHome" in config2 ? path10.join(config2.claudeHome, "settings.json") : path10.join(config2.codexHome, "hooks.json");
 }
 var hookEntrySchema = object({ command: string2().optional() }).loose();
 var hookGroupSchema = object({ hooks: array(hookEntrySchema).optional() }).loose();
 var hookFileSchema = object({
-  hooks: object({ Stop: array(hookGroupSchema).optional() }).loose().optional()
+  hooks: object({
+    Stop: array(hookGroupSchema).optional(),
+    SessionStart: array(hookGroupSchema).optional()
+  }).loose().optional()
 }).loose();
 async function readHookFile(filename) {
   let contents;
   let mode = 384;
   try {
-    contents = await fs8.readFile(filename, "utf8");
-    mode = (await fs8.stat(filename)).mode & 511;
+    contents = await fs10.readFile(filename, "utf8");
+    mode = (await fs10.stat(filename)).mode & 511;
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
       return { file: {}, mode };
@@ -15044,19 +15313,19 @@ async function readHookFile(filename) {
   return { file: parsed.data, mode };
 }
 async function writeHookFile(filename, file, mode) {
-  await fs8.mkdir(path8.dirname(filename), { recursive: true });
-  const target = await fs8.realpath(filename).catch((error2) => {
+  await fs10.mkdir(path10.dirname(filename), { recursive: true });
+  const target = await fs10.realpath(filename).catch((error2) => {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return filename;
     throw error2;
   });
   const temporary = `${target}.iteration-${process.pid}.tmp`;
-  await fs8.writeFile(temporary, `${JSON.stringify(file, null, 2)}
+  await fs10.writeFile(temporary, `${JSON.stringify(file, null, 2)}
 `, {
     encoding: "utf8",
     mode
   });
-  await fs8.rename(temporary, target);
+  await fs10.rename(temporary, target);
 }
 function withoutCommand(groups, command) {
   return groups.flatMap((group) => {
@@ -15077,30 +15346,55 @@ async function installTurnSummary(config2) {
   await Promise.all(
     [paths.requests, paths.lines, paths.shown].map(ensurePrivateDirectory)
   );
-  await fs8.writeFile(paths.script, hookScript(paths), {
+  await fs10.writeFile(paths.script, hookScript(paths), {
     encoding: "utf8",
     mode: 448
   });
-  await fs8.chmod(paths.script, 448);
+  await fs10.chmod(paths.script, 448);
+  if ("claudeHome" in config2) {
+    const gitPaths = claudeGitHookPaths(config2.dataDirectory);
+    await ensurePrivateDirectory(gitPaths.queue);
+    await fs10.writeFile(
+      gitPaths.script,
+      `#!/bin/sh
+exec ${shellQuote(await stableNodePath())} ${shellQuote(runtimePaths().launcher)} claude-git-hook ${shellQuote(config2.dataDirectory)}
+`,
+      { encoding: "utf8", mode: 448 }
+    );
+    await fs10.chmod(gitPaths.script, 448);
+  }
   const filename = agentHookFile(config2);
   const { file, mode } = await readHookFile(filename);
   const command = hookCommand(paths);
+  const startCommand = `/bin/sh ${shellQuote(claudeGitHookPaths(config2.dataDirectory).script)}`;
   const stop = file.hooks?.Stop ?? [];
-  if (hasCommand(stop, command)) return;
+  const start2 = file.hooks?.SessionStart ?? [];
+  if (hasCommand(stop, command) && (!("claudeHome" in config2) || hasCommand(start2, startCommand)))
+    return;
   await writeHookFile(
     filename,
     {
       ...file,
       hooks: {
         ...file.hooks,
-        Stop: [
+        Stop: hasCommand(stop, command) ? stop : [
           ...stop,
           {
             hooks: [
               { type: "command", command, timeout: HOOK_TIMEOUT_SECONDS }
             ]
           }
-        ]
+        ],
+        ..."claudeHome" in config2 ? {
+          SessionStart: hasCommand(start2, startCommand) ? start2 : [
+            ...start2,
+            {
+              hooks: [
+                { type: "command", command: startCommand, timeout: 3 }
+              ]
+            }
+          ]
+        } : {}
       }
     },
     mode
@@ -15111,14 +15405,25 @@ async function uninstallTurnSummary(config2) {
   const { file, mode } = await readHookFile(filename);
   const stop = file.hooks?.Stop ?? [];
   const command = hookCommand(turnSummaryPaths(config2.dataDirectory));
-  if (!hasCommand(stop, command)) return;
+  const start2 = file.hooks?.SessionStart ?? [];
+  const startCommand = `/bin/sh ${shellQuote(claudeGitHookPaths(config2.dataDirectory).script)}`;
+  if (!hasCommand(stop, command) && !hasCommand(start2, startCommand)) return;
   const remaining = withoutCommand(stop, command);
-  const { Stop: _removed, ...otherEvents } = file.hooks ?? {};
+  const remainingStart = withoutCommand(start2, startCommand);
+  const {
+    Stop: _removed,
+    SessionStart: _removedStart,
+    ...otherEvents
+  } = file.hooks ?? {};
   await writeHookFile(
     filename,
     {
       ...file,
-      hooks: remaining.length === 0 ? otherEvents : { ...otherEvents, Stop: remaining }
+      hooks: {
+        ...otherEvents,
+        ...remaining.length > 0 ? { Stop: remaining } : {},
+        ...remainingStart.length > 0 ? { SessionStart: remainingStart } : {}
+      }
     },
     mode
   );
@@ -15171,7 +15476,7 @@ async function fetchSummary(config2, directory, fetcher, signal) {
 }
 async function readRequest(filename) {
   try {
-    const [directory] = (await fs8.readFile(filename, "utf8")).split("\n");
+    const [directory] = (await fs10.readFile(filename, "utf8")).split("\n");
     return directory ?? null;
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
@@ -15180,25 +15485,25 @@ async function readRequest(filename) {
   }
 }
 async function writeLine(paths, key, directory, message) {
-  const filename = path8.join(paths.lines, key);
+  const filename = path10.join(paths.lines, key);
   if (message === null) {
-    await fs8.rm(filename, { force: true });
+    await fs10.rm(filename, { force: true });
     return;
   }
   const temporary = `${filename}.${process.pid}.tmp`;
-  await fs8.writeFile(
+  await fs10.writeFile(
     temporary,
     `${directory}
 ${JSON.stringify({ systemMessage: message })}
 `,
     { encoding: "utf8", mode: 384 }
   );
-  await fs8.rename(temporary, filename);
+  await fs10.rename(temporary, filename);
 }
 async function forget(paths, key) {
   await Promise.all(
     [paths.requests, paths.lines, paths.shown].map(
-      (directory) => fs8.rm(path8.join(directory, key), { force: true })
+      (directory) => fs10.rm(path10.join(directory, key), { force: true })
     )
   );
 }
@@ -15206,7 +15511,7 @@ async function refreshTurnSummaries(config2, refreshedAt, nowMs, fetcher = colle
   const paths = turnSummaryPaths(config2.dataDirectory);
   let keys;
   try {
-    keys = await fs8.readdir(paths.requests);
+    keys = await fs10.readdir(paths.requests);
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return 0;
@@ -15216,8 +15521,8 @@ async function refreshTurnSummaries(config2, refreshedAt, nowMs, fetcher = colle
   for (const key of keys.sort()) {
     signal?.throwIfAborted();
     if (!REQUEST_KEY_PATTERN.test(key)) continue;
-    const filename = path8.join(paths.requests, key);
-    const stats = await fs8.stat(filename).catch((error2) => {
+    const filename = path10.join(paths.requests, key);
+    const stats = await fs10.stat(filename).catch((error2) => {
       if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
         return null;
       throw error2;
@@ -15284,8 +15589,8 @@ async function codexTurnSummaryApproval(config2) {
     if (handlerIndex < 0) continue;
     let configToml;
     try {
-      configToml = await fs8.readFile(
-        path8.join(config2.codexHome, "config.toml"),
+      configToml = await fs10.readFile(
+        path10.join(config2.codexHome, "config.toml"),
         "utf8"
       );
     } catch (error2) {
@@ -15303,8 +15608,8 @@ async function codexTurnSummaryApproval(config2) {
 }
 
 // src/cursor-hooks.ts
-import { promises as fs9 } from "node:fs";
-import path9 from "node:path";
+import { promises as fs11 } from "node:fs";
+import path11 from "node:path";
 var CURSOR_HOOKS = [
   "sessionStart",
   "beforeSubmitPrompt",
@@ -15320,15 +15625,15 @@ var CURSOR_HOOKS = [
   "sessionEnd"
 ];
 function cursorHookDirectory(dataDirectory2) {
-  return path9.join(dataDirectory2, "cursor-hooks");
+  return path11.join(dataDirectory2, "cursor-hooks");
 }
 function cursorHookFailurePath(dataDirectory2) {
-  return path9.join(dataDirectory2, "cursor-hook-failure.json");
+  return path11.join(dataDirectory2, "cursor-hook-failure.json");
 }
 async function cursorHookFailureAtMs(dataDirectory2) {
   let contents;
   try {
-    contents = await fs9.readFile(cursorHookFailurePath(dataDirectory2), "utf8");
+    contents = await fs11.readFile(cursorHookFailurePath(dataDirectory2), "utf8");
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return null;
@@ -15363,8 +15668,8 @@ async function readHooks(filename) {
   let contents;
   let mode = 384;
   try {
-    contents = await fs9.readFile(filename, "utf8");
-    mode = (await fs9.stat(filename)).mode & 511;
+    contents = await fs11.readFile(filename, "utf8");
+    mode = (await fs11.stat(filename)).mode & 511;
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return { file: {}, mode };
@@ -15386,14 +15691,14 @@ async function readHooks(filename) {
   return { file: checked.data, mode };
 }
 async function writeHooks(filename, file, mode) {
-  await ensurePrivateDirectory(path9.dirname(filename));
-  const target = await fs9.realpath(filename).catch((error2) => {
+  await ensurePrivateDirectory(path11.dirname(filename));
+  const target = await fs11.realpath(filename).catch((error2) => {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return filename;
     throw error2;
   });
   const temporary = `${target}.iteration-${process.pid}.tmp`;
-  const handle = await fs9.open(temporary, "w", mode);
+  const handle = await fs11.open(temporary, "w", mode);
   try {
     await handle.writeFile(`${JSON.stringify(file, null, 2)}
 `, "utf8");
@@ -15401,14 +15706,14 @@ async function writeHooks(filename, file, mode) {
   } finally {
     await handle.close();
   }
-  await fs9.rename(temporary, target);
+  await fs11.rename(temporary, target);
 }
 function entries(value) {
   return value ?? [];
 }
 async function installCursorHooks(cursorHome, dataDirectory2) {
   await ensurePrivateDirectory(cursorHookDirectory(dataDirectory2));
-  const filename = path9.join(cursorHome, "hooks.json");
+  const filename = path11.join(cursorHome, "hooks.json");
   const { file, mode } = await readHooks(filename);
   const hooks = { ...file.hooks };
   const nodePath = await stableNodePath();
@@ -15422,7 +15727,7 @@ async function installCursorHooks(cursorHome, dataDirectory2) {
   await writeHooks(filename, { ...file, version: 1, hooks }, mode);
 }
 async function uninstallCursorHooks(cursorHome, dataDirectory2) {
-  const filename = path9.join(cursorHome, "hooks.json");
+  const filename = path11.join(cursorHome, "hooks.json");
   const { file, mode } = await readHooks(filename);
   const hooks = { ...file.hooks };
   let changed = false;
@@ -15443,7 +15748,7 @@ async function cursorHookFiles(dataDirectory2) {
   const directory = cursorHookDirectory(dataDirectory2);
   let names;
   try {
-    names = await fs9.readdir(directory);
+    names = await fs11.readdir(directory);
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return [];
@@ -15451,7 +15756,7 @@ async function cursorHookFiles(dataDirectory2) {
   }
   if (names.length > 1e4)
     throw new Error("Cursor hook queue exceeds the scan limit.");
-  return names.filter((name) => /^[0-9a-f-]+\.jsonl$/i.test(name)).sort().map((name) => path9.join(directory, name));
+  return names.filter((name) => /^[0-9a-f-]+\.jsonl$/i.test(name)).sort().map((name) => path11.join(directory, name));
 }
 
 // src/auto-connect.ts
@@ -15464,27 +15769,27 @@ var consentSchema = object({
   sourceHomes: object({
     codex: string2(),
     claude: string2(),
-    cursor: string2().default(path10.join(os6.homedir(), ".cursor"))
+    cursor: string2().default(path12.join(os6.homedir(), ".cursor"))
   }).strict()
 }).strict();
 function consentPath() {
-  return path10.join(os6.homedir(), ".config", "iteration", "auto-connect.json");
+  return path12.join(os6.homedir(), ".config", "iteration", "auto-connect.json");
 }
 function sourceHome(source) {
-  return path10.resolve(
-    source === "codex" ? process.env.CODEX_HOME ?? path10.join(os6.homedir(), ".codex") : source === "claude" ? process.env.CLAUDE_CONFIG_DIR ?? path10.join(os6.homedir(), ".claude") : path10.join(os6.homedir(), ".cursor")
+  return path12.resolve(
+    source === "codex" ? process.env.CODEX_HOME ?? path12.join(os6.homedir(), ".codex") : source === "claude" ? process.env.CLAUDE_CONFIG_DIR ?? path12.join(os6.homedir(), ".claude") : path12.join(os6.homedir(), ".cursor")
   );
 }
 async function detectedSources(sourceHomes) {
   const detected = [];
   for (const source of COLLECTOR_SOURCES) {
-    const directory = path10.join(
+    const directory = path12.join(
       sourceHomes[source],
       source === "codex" ? "sessions" : "projects"
     );
     let stats;
     try {
-      stats = await fs10.stat(directory);
+      stats = await fs12.stat(directory);
     } catch (error2) {
       if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
         continue;
@@ -15504,7 +15809,7 @@ async function detectedSources(sourceHomes) {
 async function loadMachineConsent() {
   let text;
   try {
-    text = await fs10.readFile(consentPath(), "utf8");
+    text = await fs12.readFile(consentPath(), "utf8");
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return null;
@@ -15530,9 +15835,9 @@ async function saveMachineConsent(consent) {
   const parsed = consentSchema.parse(consent);
   validateCollectorEndpoint(parsed.endpoint);
   const filename = consentPath();
-  await ensurePrivateDirectory(path10.dirname(filename));
+  await ensurePrivateDirectory(path12.dirname(filename));
   const temporary = `${filename}.${process.pid}.tmp`;
-  const handle = await fs10.open(temporary, "w", 384);
+  const handle = await fs12.open(temporary, "w", 384);
   try {
     await handle.writeFile(`${JSON.stringify(parsed)}
 `, "utf8");
@@ -15540,7 +15845,7 @@ async function saveMachineConsent(consent) {
   } finally {
     await handle.close();
   }
-  await fs10.rename(temporary, filename);
+  await fs12.rename(temporary, filename);
 }
 async function readCollectorScope(anchor2) {
   const endpoint = validateCollectorEndpoint(anchor2.endpoint);
@@ -15636,7 +15941,7 @@ async function connectNewDetectedSources(anchor2, consent) {
     if (source === consent.anchorSource) continue;
     const paths = collectorPaths(defaultCollectorDirectory(source));
     try {
-      await fs10.access(paths.config);
+      await fs12.access(paths.config);
       continue;
     } catch (error2) {
       if (!(error2 instanceof Error && "code" in error2 && error2.code === "ENOENT"))
@@ -15679,7 +15984,7 @@ async function connectNewDetectedSources(anchor2, consent) {
 async function connectedConfig(source) {
   const paths = collectorPaths(defaultCollectorDirectory(source));
   try {
-    await fs10.access(paths.config);
+    await fs12.access(paths.config);
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
       return null;
@@ -15689,93 +15994,20 @@ async function connectedConfig(source) {
 }
 
 // src/history-import.ts
-import path17 from "node:path";
+import path20 from "node:path";
 
 // src/service.ts
-import { promises as fs13 } from "node:fs";
-import path16 from "node:path";
+import { promises as fs16 } from "node:fs";
+import path19 from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 
 // src/collector.ts
-import { promises as fs12 } from "node:fs";
-import path15 from "node:path";
+import { promises as fs13 } from "node:fs";
+import path16 from "node:path";
 
 // src/claude-transcript.ts
 import { createHash as createHash4 } from "node:crypto";
-import path12 from "node:path";
-
-// src/git-repository.ts
-import fs11 from "node:fs";
-import path11 from "node:path";
-var repositoryUrls = /* @__PURE__ */ new Map();
-function missing(error2) {
-  const code = error2.code;
-  return code === "ENOENT" || code === "ENOTDIR";
-}
-function readText(file) {
-  try {
-    return fs11.readFileSync(file, "utf8");
-  } catch (error2) {
-    if (missing(error2)) return null;
-    throw error2;
-  }
-}
-function gitConfigFile(cwd) {
-  try {
-    if (!fs11.statSync(cwd).isDirectory()) return null;
-  } catch (error2) {
-    if (missing(error2)) return null;
-    throw error2;
-  }
-  for (let directory = cwd; ; directory = path11.dirname(directory)) {
-    const dotGit = path11.join(directory, ".git");
-    let stats;
-    try {
-      stats = fs11.statSync(dotGit);
-    } catch (error2) {
-      if (!missing(error2)) throw error2;
-      if (path11.dirname(directory) === directory) return null;
-      continue;
-    }
-    if (stats.isDirectory()) return path11.join(dotGit, "config");
-    const pointer = /^gitdir:\s*(.+?)\s*$/m.exec(readText(dotGit) ?? "");
-    if (pointer === null) return null;
-    const gitDirectory = path11.resolve(directory, pointer[1]);
-    const common = readText(path11.join(gitDirectory, "commondir"))?.trim();
-    return path11.join(
-      common ? path11.resolve(gitDirectory, common) : gitDirectory,
-      "config"
-    );
-  }
-}
-function originUrl(config2) {
-  let inOrigin = false;
-  for (const line of config2.split(/\r?\n/)) {
-    const section = /^\s*\[\s*([^\]]+?)\s*\]/.exec(line);
-    if (section !== null) {
-      inOrigin = /^remote\s+"origin"$/i.test(section[1]);
-      continue;
-    }
-    const url2 = inOrigin ? /^\s*url\s*=\s*(.+?)\s*$/i.exec(line) : null;
-    if (url2 !== null) return url2[1].replace(/^"(.*)"$/, "$1");
-  }
-  return null;
-}
-function withoutCredentials(url2) {
-  return url2.replace(/^([a-z][a-z0-9+.-]*:\/\/)[^/@]*@/i, "$1");
-}
-function gitRepositoryUrl(cwd) {
-  const known = repositoryUrls.get(cwd);
-  if (known !== void 0) return known;
-  const configFile = gitConfigFile(cwd);
-  const config2 = configFile === null ? null : readText(configFile);
-  const origin = config2 === null ? null : originUrl(config2);
-  const url2 = origin === null ? null : withoutCredentials(origin);
-  repositoryUrls.set(cwd, url2);
-  return url2;
-}
-
-// src/claude-transcript.ts
+import path13 from "node:path";
 var CONTEXT_RECORD_TYPES = /* @__PURE__ */ new Set([
   "attachment",
   "system",
@@ -15814,9 +16046,9 @@ function childThreadId(parentId, agentId) {
 var SESSION_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function claudeSessionIdentity(filename) {
   if (!filename.endsWith(".jsonl")) return null;
-  const basename = path12.basename(filename, ".jsonl");
-  if (path12.basename(path12.dirname(filename)) === "subagents") {
-    const parent = path12.basename(path12.dirname(path12.dirname(filename)));
+  const basename = path13.basename(filename, ".jsonl");
+  if (path13.basename(path13.dirname(filename)) === "subagents") {
+    const parent = path13.basename(path13.dirname(path13.dirname(filename)));
     if (!basename.startsWith("agent-") || !SESSION_UUID.test(parent))
       return null;
     const agentId = basename.slice("agent-".length);
@@ -16046,10 +16278,51 @@ function parseClaudeLine(line, filename, byteOffset, repositoryUrl = gitReposito
   }
   return { events: valid, gaps };
 }
+function parseClaudeGitHookLine(line, filename) {
+  const name = path13.basename(filename, ".jsonl");
+  if (!SESSION_UUID.test(name) || path13.basename(path13.dirname(filename)) !== "git-queue")
+    return { events: [], gaps: ["invalid_claude_git_hook_path"] };
+  let decoded;
+  try {
+    decoded = JSON.parse(line);
+  } catch {
+    return { events: [], gaps: ["malformed_claude_git_hook_record"] };
+  }
+  const parsed = object({
+    sessionId: uuid2(),
+    cwd: string2().min(1),
+    capturedAt: iso_exports.datetime(),
+    git: object({
+      branch: string2().nullable(),
+      repository_url: string2().nullable()
+    })
+  }).safeParse(decoded);
+  if (!parsed.success || !path13.isAbsolute(parsed.data.cwd))
+    return { events: [], gaps: ["invalid_claude_git_hook_record"] };
+  const { sessionId, cwd, git, capturedAt } = parsed.data;
+  const candidate = {
+    eventId: `hook:${digest2(filename)}`,
+    sessionId: `claude:${sessionId}`,
+    sequence: 1,
+    callId: null,
+    projectId: null,
+    occurredAt: capturedAt,
+    eventType: "session_meta",
+    payload: { id: sessionId, cwd, git },
+    run: {
+      kind: "identity",
+      id: sessionId,
+      parentId: null,
+      ownStart: true,
+      startOrdinal: null
+    }
+  };
+  return parseTraceEventBatch({ events: [candidate] }).success ? { events: [candidate], gaps: [] } : { events: [], gaps: ["invalid_claude_git_hook_record"] };
+}
 
 // src/cursor-transcript.ts
 import { createHash as createHash5 } from "node:crypto";
-import path13 from "node:path";
+import path14 from "node:path";
 var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function record2(value) {
   const parsed = record(string2(), json()).safeParse(value);
@@ -16077,8 +16350,8 @@ function event2(conversationId, filename, byteOffset, index, eventType, payload,
   };
 }
 function parseCursorTranscriptLine(line, filename, byteOffset) {
-  const conversationId = path13.basename(filename, ".jsonl");
-  if (!UUID.test(conversationId) || path13.basename(path13.dirname(filename)) !== conversationId)
+  const conversationId = path14.basename(filename, ".jsonl");
+  if (!UUID.test(conversationId) || path14.basename(path14.dirname(filename)) !== conversationId)
     return { events: [], gaps: ["invalid_cursor_transcript_path"] };
   let decoded;
   try {
@@ -16219,6 +16492,7 @@ function parseCursorHookLine(line, filename) {
   const events = [];
   if (hook === "beforeSubmitPrompt" || hook === "sessionStart") {
     const roots = Array.isArray(input.workspace_roots) ? input.workspace_roots : [];
+    const git = record2(wrapper?.git);
     events.push({
       ...event2(
         conversationId,
@@ -16229,6 +16503,10 @@ function parseCursorHookLine(line, filename) {
         {
           id: conversationId,
           cwd: string5(roots[0]),
+          git: {
+            branch: string5(git?.branch),
+            repository_url: string5(git?.repository_url)
+          },
           version: string5(input.cursor_version),
           model: string5(input.model),
           transcript_path: string5(input.transcript_path)
@@ -16397,7 +16675,7 @@ function validated(events, gaps) {
 
 // src/rollout.ts
 import { createHash as createHash6 } from "node:crypto";
-import path14 from "node:path";
+import path15 from "node:path";
 var recordSchema = record(string2(), unknown());
 var CONTEXT_RECORDS = [
   "session_meta",
@@ -16450,7 +16728,7 @@ function sourceOrdinal(value) {
   return parsed.success ? parsed.data : null;
 }
 function sessionFromPath(filename) {
-  const basename = path14.basename(filename, ".jsonl");
+  const basename = path15.basename(filename, ".jsonl");
   return basename.startsWith("rollout-") ? basename.slice("rollout-".length) : basename;
 }
 function callIdFrom(record3) {
@@ -16720,9 +16998,10 @@ function logGap(filename, offset, reason) {
   );
 }
 function parseSourceRecord(source, line, filename, byteOffset) {
-  if (source === "claude") return parseClaudeLine(line, filename, byteOffset);
+  if (source === "claude")
+    return filename.includes(`${path16.sep}git-queue${path16.sep}`) ? parseClaudeGitHookLine(line, filename) : parseClaudeLine(line, filename, byteOffset);
   if (source === "cursor")
-    return filename.includes(`${path15.sep}cursor-hooks${path15.sep}`) ? parseCursorHookLine(line, filename) : parseCursorTranscriptLine(line, filename, byteOffset);
+    return filename.includes(`${path16.sep}cursor-hooks${path16.sep}`) ? parseCursorHookLine(line, filename) : parseCursorTranscriptLine(line, filename, byteOffset);
   if (source === "codex") {
     const parsed = parseRolloutLine(line, filename, byteOffset);
     return parsed.kind === "event" ? { events: [parsed.event], gaps: [] } : parsed.kind === "gap" ? { events: [], gaps: [parsed.reason] } : { events: [], gaps: [] };
@@ -16733,7 +17012,7 @@ function parseSourceRecord(source, line, filename, byteOffset) {
 async function scanSourceOnce(config2, paths, signal) {
   signal?.throwIfAborted();
   const source = collectorSource(config2);
-  const sourceDirectory = path15.resolve(collectorSourceDirectory(config2));
+  const sourceDirectory = path16.resolve(collectorSourceDirectory(config2));
   const state = await loadState(paths);
   if (!state.initialized || state.sourceDirectory !== sourceDirectory) {
     throw new Error(
@@ -16743,6 +17022,7 @@ async function scanSourceOnce(config2, paths, signal) {
   const cursors = { ...state.cursors };
   const skipping = new Set(state.skipping);
   const files = [
+    ...source === "claude" ? await claudeGitHookFiles(config2.dataDirectory) : [],
     ...await sourceFiles(source, sourceDirectory),
     ...source === "cursor" ? await cursorHookFiles(config2.dataDirectory) : []
   ];
@@ -16754,12 +17034,12 @@ async function scanSourceOnce(config2, paths, signal) {
   let caughtUp = true;
   for (const filename of files) {
     signal?.throwIfAborted();
-    const recordLimit = source === "cursor" && filename.includes(`${path15.sep}cursor-hooks${path15.sep}`) ? 12 * 1024 * 1024 : MAX_RECORD_BYTES;
+    const recordLimit = source === "cursor" && filename.includes(`${path16.sep}cursor-hooks${path16.sep}`) ? 12 * 1024 * 1024 : MAX_RECORD_BYTES;
     if (remainingBudget === 0) {
       caughtUp = false;
       break;
     }
-    const stats = await fs12.stat(filename);
+    const stats = await fs13.stat(filename);
     let offset = cursors[filename] ?? 0;
     if (offset > stats.size) {
       logGap(filename, offset, "rollout_file_shrank_resetting_cursor");
@@ -16775,7 +17055,7 @@ async function scanSourceOnce(config2, paths, signal) {
       cursors[filename] = offset;
       continue;
     }
-    const handle = await fs12.open(filename, "r");
+    const handle = await fs13.open(filename, "r");
     let buffer;
     let readEnd = offset;
     try {
@@ -16850,12 +17130,12 @@ async function scanSourceOnce(config2, paths, signal) {
       lineStart = buffer.length;
     }
     cursors[filename] = offset + lineStart;
-    if (source === "cursor" && filename.includes(`${path15.sep}cursor-hooks${path15.sep}`) && cursors[filename] === stats.size)
+    if ((source === "cursor" && filename.includes(`${path16.sep}cursor-hooks${path16.sep}`) || source === "claude" && filename.includes(`${path16.sep}git-queue${path16.sep}`)) && cursors[filename] === stats.size)
       completedHooks.push(filename);
   }
   await appendEvents(events, paths);
   for (const filename of completedHooks) {
-    await fs12.rm(filename);
+    await fs13.rm(filename);
     delete cursors[filename];
   }
   await saveState(
@@ -16953,17 +17233,791 @@ async function collectorTick(config2, paths, fetcher = collectorFetch, signal, o
   };
 }
 
-// src/service.ts
-function errorCode2(error2) {
-  if (error2 instanceof Error && "code" in error2) return String(error2.code);
+// src/cursor-billing.ts
+import { createHash as createHash7 } from "node:crypto";
+import { promises as fs14 } from "node:fs";
+import os7 from "node:os";
+import path17 from "node:path";
+var CURSOR_USAGE_URL = "https://api2.cursor.sh/aiserver.v1.DashboardService/GetFilteredUsageEvents";
+var PAGE_SIZE = 500;
+var MAX_PAGES = 1e3;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var AUDIT_INTERVAL_MS = 7 * DAY_MS;
+var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var billingStateSchema = object({
+  accountFingerprint: string2().regex(/^[0-9a-f]{64}$/),
+  lastSyncedAtMs: number2().int().nonnegative(),
+  lastAuditAtMs: number2().int().nonnegative()
+}).strict();
+var usageEventSchema = object({
+  conversationId: string2().optional().nullable(),
+  timestamp: union([number2(), string2().regex(/^\d+$/).transform(Number)]).pipe(number2().int().nonnegative().safe()),
+  kind: string2(),
+  usageBasedCosts: string2().optional().nullable(),
+  tokenUsage: object({
+    inputTokens: number2().int().nonnegative(),
+    outputTokens: number2().int().nonnegative(),
+    cacheReadTokens: number2().int().nonnegative(),
+    cacheWriteTokens: number2().int().nonnegative().optional()
+  }).optional().nullable()
+});
+var usagePageSchema = object({
+  totalUsageEventsCount: number2().int().nonnegative(),
+  usageEventsDisplay: array(unknown()).max(PAGE_SIZE)
+});
+var emptyUsagePageSchema = object({}).strict();
+function cursorAuthDatabase() {
+  if (process.platform === "darwin")
+    return path17.join(
+      os7.homedir(),
+      "Library/Application Support/Cursor/User/globalStorage/state.vscdb"
+    );
+  if (process.platform === "linux")
+    return path17.join(
+      os7.homedir(),
+      ".config/Cursor/User/globalStorage/state.vscdb"
+    );
   return null;
 }
-var CollectorLockBusyError = class extends Error {
-};
-function errorCauses(error2) {
-  const causes = [];
-  let current = error2 instanceof Error ? error2.cause : void 0;
-  while (current instanceof Error && causes.length < 4) {
+async function readCursorAuth() {
+  const filename = cursorAuthDatabase();
+  if (filename === null) return null;
+  let database;
+  try {
+    const { DatabaseSync } = await import("node:sqlite");
+    database = new DatabaseSync(filename, { readOnly: true });
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "SQLITE_CANTOPEN")
+      return null;
+    throw new Error("Could not open Cursor's local account database.", {
+      cause: error2
+    });
+  }
+  try {
+    const row = database.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/accessToken");
+    const parsed = string2().min(1).safeParse(row?.value);
+    if (!parsed.success) return null;
+    const email2 = string2().email().safeParse(
+      database.prepare("SELECT value FROM ItemTable WHERE key = ?").get("cursorAuth/cachedEmail")?.value
+    );
+    const identity = email2.success ? `email:${email2.data.toLowerCase()}` : `token:${parsed.data}`;
+    return {
+      token: parsed.data,
+      accountFingerprint: createHash7("sha256").update(identity).digest("hex")
+    };
+  } catch (error2) {
+    throw new Error("Could not read Cursor's local account token.", {
+      cause: error2
+    });
+  } finally {
+    database.close();
+  }
+}
+async function loadBillingState(filename) {
+  let contents;
+  try {
+    contents = await fs14.readFile(filename, "utf8");
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
+      return null;
+    throw new Error("Could not read Cursor billing sync state.", {
+      cause: error2
+    });
+  }
+  try {
+    return billingStateSchema.parse(JSON.parse(contents));
+  } catch (error2) {
+    throw new Error("Cursor billing sync state is invalid.", { cause: error2 });
+  }
+}
+async function saveBillingState(filename, state) {
+  const temporary = `${filename}.${process.pid}.tmp`;
+  const handle = await fs14.open(temporary, "w", 384);
+  try {
+    await handle.writeFile(`${JSON.stringify(state)}
+`, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await fs14.rename(temporary, filename);
+}
+function planCursorBillingSync(state, accountFingerprint, nowMs) {
+  if (state === null || state.accountFingerprint !== accountFingerprint)
+    return { mode: "history", startDateMs: 0, reconcileFromMs: null };
+  const audit = nowMs - state.lastAuditAtMs >= AUDIT_INTERVAL_MS;
+  const fetchDays = audit ? 36 : 8;
+  const reconcileDays = audit ? 35 : 7;
+  return {
+    mode: audit ? "audit" : "recent",
+    startDateMs: Math.max(
+      0,
+      Math.min(state.lastSyncedAtMs - DAY_MS, nowMs - fetchDays * DAY_MS)
+    ),
+    reconcileFromMs: Math.max(
+      0,
+      Math.min(state.lastSyncedAtMs, nowMs - reconcileDays * DAY_MS)
+    )
+  };
+}
+function cursorConversationIds(filenames) {
+  return new Set(
+    filenames.map((filename) => path17.basename(filename, ".jsonl")).filter((id) => UUID2.test(id))
+  );
+}
+function billingKind(kind) {
+  switch (kind) {
+    case "USAGE_EVENT_KIND_INCLUDED_IN_PRO":
+    case "USAGE_EVENT_KIND_INCLUDED_IN_BUSINESS":
+      return "included";
+    case "USAGE_EVENT_KIND_USAGE_BASED":
+      return "paid";
+    case "USAGE_EVENT_KIND_USER_API_KEY":
+      return "byok";
+    case "USAGE_EVENT_KIND_ERRORED_NOT_CHARGED":
+    case "USAGE_EVENT_KIND_ABORTED_NOT_CHARGED":
+      return "not_charged";
+    default:
+      return "unknown";
+  }
+}
+function paidUsd(value) {
+  if (value === null || value === void 0 || value === "-") return null;
+  if (!/^\$\d+(?:\.\d{1,6})?$/.test(value))
+    throw new Error("Cursor returned an invalid usage-based charge.");
+  return Number(value.slice(1));
+}
+function normalizeCursorUsageEvent(value, localConversations) {
+  const identity = object({ conversationId: string2().optional().nullable() }).safeParse(value);
+  if (!identity.success)
+    throw new Error("Cursor returned an invalid usage event.");
+  const conversationId = identity.data.conversationId;
+  if (conversationId === null || conversationId === void 0 || !localConversations.has(conversationId))
+    return null;
+  const parsed = usageEventSchema.safeParse(value);
+  if (!parsed.success)
+    throw new Error(
+      "Cursor returned an invalid usage event for a local transcript."
+    );
+  const row = parsed.data;
+  const usage2 = row.tokenUsage;
+  const kind = billingKind(row.kind);
+  return {
+    conversationId,
+    event: {
+      timestamp: row.timestamp,
+      kind,
+      inputTokens: usage2?.inputTokens ?? null,
+      outputTokens: usage2?.outputTokens ?? null,
+      cacheReadTokens: usage2?.cacheReadTokens ?? null,
+      cacheWriteTokens: usage2?.cacheWriteTokens ?? (usage2 === null || usage2 === void 0 ? null : 0),
+      paidUsd: kind === "paid" ? paidUsd(row.usageBasedCosts) : null
+    }
+  };
+}
+async function syncCursorBilling(config2, fetcher = collectorFetch, signal) {
+  const auth = await readCursorAuth();
+  if (auth === null)
+    return { sessions: 0, matched: 0, skipped: true, mode: null };
+  const localConversations = cursorConversationIds(
+    await cursorFiles(path17.join(config2.cursorHome, "projects"))
+  );
+  if (localConversations.size === 0)
+    return { sessions: 0, matched: 0, skipped: true, mode: null };
+  const stateFile = path17.join(config2.dataDirectory, "cursor-billing-sync.json");
+  const priorState = await loadBillingState(stateFile);
+  const nowMs = Date.now();
+  const plan = planCursorBillingSync(
+    priorState,
+    auth.accountFingerprint,
+    nowMs
+  );
+  const byConversation = /* @__PURE__ */ new Map();
+  for (let page = 1; page <= MAX_PAGES; page += 1) {
+    signal?.throwIfAborted();
+    const response = await fetch(CURSOR_USAGE_URL, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${auth.token}`,
+        "Content-Type": "application/json",
+        "Connect-Protocol-Version": "1"
+      },
+      body: JSON.stringify({
+        page,
+        pageSize: PAGE_SIZE,
+        startDate: String(plan.startDateMs)
+      }),
+      signal: AbortSignal.any([
+        AbortSignal.timeout(2e4),
+        ...signal ? [signal] : []
+      ])
+    });
+    if (!response.ok)
+      throw new Error(
+        `Cursor billing lookup failed with HTTP ${response.status}.`
+      );
+    const rawPage = await response.json();
+    if (emptyUsagePageSchema.safeParse(rawPage).success) {
+      if (page !== 1)
+        throw new Error(
+          "Cursor billing history ended before its reported count."
+        );
+      break;
+    }
+    const decoded = usagePageSchema.safeParse(rawPage);
+    if (!decoded.success)
+      throw new Error("Cursor returned an invalid billing page.");
+    for (const value of decoded.data.usageEventsDisplay) {
+      const normalized = normalizeCursorUsageEvent(value, localConversations);
+      if (normalized === null) continue;
+      const events = byConversation.get(normalized.conversationId) ?? [];
+      events.push(normalized.event);
+      if (events.length > 5e3)
+        throw new Error("Cursor conversation exceeds the billing sync limit.");
+      byConversation.set(normalized.conversationId, events);
+    }
+    if (page * PAGE_SIZE >= decoded.data.totalUsageEventsCount) break;
+    if (page === MAX_PAGES)
+      throw new Error("Cursor account exceeds the billing history page limit.");
+    if (decoded.data.usageEventsDisplay.length === 0)
+      throw new Error(
+        "Cursor billing history ended before its reported count."
+      );
+  }
+  const endpoint = new URL(config2.endpoint);
+  endpoint.pathname = "/api/traces/cursor-billing";
+  let matched = 0;
+  for (const [conversationId, events] of byConversation) {
+    signal?.throwIfAborted();
+    const request2 = cursorBillingRequestSchema.parse({
+      conversationId,
+      reconcileFromMs: plan.reconcileFromMs,
+      events
+    });
+    const response = await fetcher(endpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config2.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(request2),
+      signal: AbortSignal.any([
+        AbortSignal.timeout(9e4),
+        ...signal ? [signal] : []
+      ])
+    });
+    if (!response.ok)
+      throw new Error(
+        `Cursor billing sync failed with HTTP ${response.status}.`
+      );
+    const result = object({ matched: number2().int().nonnegative() }).safeParse(await response.json());
+    if (!result.success)
+      throw new Error("Iteration returned an invalid billing sync result.");
+    matched += result.data.matched;
+  }
+  await saveBillingState(stateFile, {
+    accountFingerprint: auth.accountFingerprint,
+    lastSyncedAtMs: nowMs,
+    lastAuditAtMs: plan.mode === "recent" ? priorState.lastAuditAtMs : nowMs
+  });
+  return {
+    sessions: byConversation.size,
+    matched,
+    skipped: false,
+    mode: plan.mode
+  };
+}
+
+// src/codex-billing.ts
+import { createHash as createHash8 } from "node:crypto";
+import { promises as fs15 } from "node:fs";
+import path18 from "node:path";
+var TASK_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage/thread_usage/query_v2";
+var UUID3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var DAY_MS2 = 24 * 60 * 60 * 1e3;
+var TASK_BATCH_SIZE = 50;
+var MAX_HEADER_BYTES = 3 * 1024 * 1024;
+var stateSchema2 = object({
+  accountFingerprint: string2().regex(/^[0-9a-f]{64}$/),
+  lastSyncedAtMs: number2().int().nonnegative(),
+  lastAuditAtMs: number2().int().nonnegative(),
+  unavailableThreadIds: array(uuid2())
+});
+var authSchema = object({
+  auth_mode: string2().optional(),
+  tokens: object({
+    access_token: string2().min(1),
+    account_id: string2().min(1)
+  }).optional()
+});
+var taskUsageSchema = object({
+  threads: array(
+    object({
+      thread_id: uuid2(),
+      data_status: _enum(["available", "partial", "unavailable"]),
+      usage_source: string2(),
+      balance_usage_credits: string2().nullable().optional()
+    })
+  ).max(TASK_BATCH_SIZE)
+});
+var sessionMetaSchema = object({
+  type: literal("session_meta"),
+  payload: object({
+    id: uuid2(),
+    timestamp: string2().optional(),
+    creator_account_id: string2().nullable().optional(),
+    model_provider: string2().nullable().optional(),
+    parent_thread_id: string2().nullable().optional(),
+    source: unknown().optional()
+  })
+});
+var subagentSourceSchema = object({
+  subagent: object({
+    thread_spawn: object({ parent_thread_id: string2() }).optional()
+  }).optional()
+});
+var syncResultSchema = object({ matched: number2().int().nonnegative() });
+function fingerprint(value) {
+  return createHash8("sha256").update(value).digest("hex");
+}
+async function readAuth(codexHome) {
+  let contents;
+  try {
+    contents = await fs15.readFile(path18.join(codexHome, "auth.json"), "utf8");
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
+      return {
+        accessToken: null,
+        accountId: null,
+        accountFingerprint: fingerprint(
+          "codex-local-auth-logs:no-chatgpt-token"
+        )
+      };
+    throw new Error("Could not read Codex authentication.", { cause: error2 });
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(contents);
+  } catch (error2) {
+    throw new Error("Codex authentication is not valid JSON.", {
+      cause: error2
+    });
+  }
+  const parsed = authSchema.safeParse(decoded);
+  if (!parsed.success)
+    throw new Error("Codex authentication has an unexpected shape.");
+  const accountId = parsed.data.tokens?.account_id ?? null;
+  return {
+    accessToken: parsed.data.auth_mode === "chatgpt" ? parsed.data.tokens?.access_token ?? null : null,
+    accountId,
+    accountFingerprint: fingerprint(
+      `${accountId ?? "codex-local-auth-logs"}:${parsed.data.auth_mode === "chatgpt" && parsed.data.tokens?.access_token ? "chatgpt" : "no-chatgpt-token"}`
+    )
+  };
+}
+async function readState(filename) {
+  let contents;
+  try {
+    contents = await fs15.readFile(filename, "utf8");
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
+      return null;
+    throw new Error("Could not read Codex billing sync state.", {
+      cause: error2
+    });
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(contents);
+  } catch (error2) {
+    throw new Error("Codex billing sync state is not valid JSON.", {
+      cause: error2
+    });
+  }
+  const parsed = stateSchema2.safeParse(decoded);
+  if (!parsed.success) throw new Error("Codex billing sync state is invalid.");
+  return parsed.data;
+}
+async function saveState2(filename, state) {
+  const temporary = `${filename}.${process.pid}.tmp`;
+  const handle = await fs15.open(temporary, "w", 384);
+  try {
+    await handle.writeFile(`${JSON.stringify(state)}
+`);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await fs15.rename(temporary, filename);
+}
+async function localThread(filename) {
+  const stat = await fs15.stat(filename);
+  const handle = await fs15.open(filename, "r");
+  let header = null;
+  try {
+    const buffer = Buffer.alloc(64 * 1024);
+    const chunks = [];
+    let offset = 0;
+    while (offset < Math.min(stat.size, MAX_HEADER_BYTES)) {
+      const read = await handle.read(
+        buffer,
+        0,
+        Math.min(buffer.length, MAX_HEADER_BYTES - offset),
+        offset
+      );
+      if (read.bytesRead === 0) break;
+      const newline = buffer.subarray(0, read.bytesRead).indexOf(10);
+      if (newline >= 0) {
+        chunks.push(Buffer.from(buffer.subarray(0, newline)));
+        header = Buffer.concat(chunks);
+        break;
+      }
+      chunks.push(Buffer.from(buffer.subarray(0, read.bytesRead)));
+      offset += read.bytesRead;
+    }
+  } finally {
+    await handle.close();
+  }
+  if (header === null) return null;
+  let raw;
+  try {
+    raw = JSON.parse(header.toString("utf8"));
+  } catch {
+    return null;
+  }
+  const record3 = sessionMetaSchema.safeParse(raw);
+  if (!record3.success) return null;
+  const payload = record3.data.payload;
+  if (!filename.endsWith(`${payload.id}.jsonl`)) return null;
+  const source = subagentSourceSchema.safeParse(payload.source);
+  const parentThreadId = payload.parent_thread_id ?? (source.success ? source.data.subagent?.thread_spawn?.parent_thread_id : null) ?? null;
+  if (parentThreadId !== null && !UUID3.test(parentThreadId)) return null;
+  return {
+    threadId: payload.id,
+    parentThreadId,
+    createdAt: payload.timestamp && !Number.isNaN(Date.parse(payload.timestamp)) ? new Date(payload.timestamp).toISOString() : null,
+    accountId: payload.creator_account_id ?? null,
+    modelProvider: payload.model_provider ?? null,
+    mtimeMs: stat.mtimeMs
+  };
+}
+function groupCodexTasks(threads, accountId) {
+  const byId = new Map(
+    threads.filter(
+      (thread) => thread.accountId === null || thread.accountId === accountId
+    ).map((thread) => [thread.threadId, thread])
+  );
+  const tasks = /* @__PURE__ */ new Map();
+  for (const thread of byId.values()) {
+    if (thread.parentThreadId === null)
+      tasks.set(thread.threadId, {
+        threadId: thread.threadId,
+        createdAt: thread.createdAt,
+        descendantThreadIds: [],
+        mtimeMs: thread.mtimeMs
+      });
+  }
+  for (const thread of byId.values()) {
+    if (thread.parentThreadId === null) continue;
+    let ancestor = thread.parentThreadId;
+    const seen = /* @__PURE__ */ new Set([thread.threadId]);
+    while (ancestor !== null && !seen.has(ancestor)) {
+      seen.add(ancestor);
+      const parent = byId.get(ancestor);
+      if (parent === void 0) break;
+      if (parent.parentThreadId === null) {
+        const task = tasks.get(parent.threadId);
+        if (task !== void 0) {
+          task.descendantThreadIds.push(thread.threadId);
+          task.mtimeMs = Math.max(task.mtimeMs, thread.mtimeMs);
+        }
+        break;
+      }
+      ancestor = parent.parentThreadId;
+    }
+  }
+  return [...tasks.values()].map((task) => ({
+    ...task,
+    descendantThreadIds: task.descendantThreadIds.sort()
+  }));
+}
+function parseCodexAuthLog(threadId, body) {
+  if (threadId === null || !UUID3.test(threadId) || body === null) return null;
+  const turn = /try_run_sampling_request\{turn_id=([0-9a-f-]{36})\b/i.exec(
+    body
+  );
+  const auth = /\bauth_mode=Some\(([^)]+)\)/.exec(body);
+  if (turn === null || auth === null || !UUID3.test(turn[1])) return null;
+  const mode = auth[1] === "Chatgpt" ? "chatgpt" : auth[1] === "ApiKey" || auth[1] === "BedrockApiKey" || auth[1] === "BedrockAccessKeys" ? "api_key" : "conflicting";
+  return { threadId, turnId: turn[1], mode };
+}
+async function localAuthTurns(codexHome, modelProviders) {
+  const filename = path18.join(codexHome, "logs_2.sqlite");
+  try {
+    await fs15.access(filename);
+  } catch (error2) {
+    if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT")
+      return [];
+    throw new Error("Could not access Codex's local logs.", { cause: error2 });
+  }
+  const { DatabaseSync } = await import("node:sqlite");
+  let database;
+  try {
+    database = new DatabaseSync(filename, { readOnly: true });
+  } catch (error2) {
+    throw new Error("Could not open Codex's local logs.", { cause: error2 });
+  }
+  const turns = /* @__PURE__ */ new Map();
+  const logRowSchema = object({
+    thread_id: string2().nullable(),
+    feedback_log_body: string2().nullable()
+  });
+  try {
+    const rows = database.prepare(
+      "SELECT thread_id, feedback_log_body FROM logs WHERE target = 'feedback_tags' AND feedback_log_body LIKE '%auth_mode=Some(%'"
+    ).iterate();
+    for (const raw of rows) {
+      const row = logRowSchema.safeParse(raw);
+      if (!row.success)
+        throw new Error("Codex's local log row has an invalid shape.");
+      if (row.data.thread_id === null || !modelProviders.has(row.data.thread_id))
+        continue;
+      const parsed = parseCodexAuthLog(
+        row.data.thread_id,
+        row.data.feedback_log_body
+      );
+      if (parsed === null) continue;
+      const mode = parsed.mode === "chatgpt" && modelProviders.get(parsed.threadId) !== "openai" ? "conflicting" : parsed.mode;
+      const key = `${parsed.threadId}:${parsed.turnId}`;
+      const prior = turns.get(key);
+      turns.set(key, {
+        ...parsed,
+        mode: prior === void 0 || prior.mode === mode ? mode : "conflicting"
+      });
+    }
+  } finally {
+    database.close();
+  }
+  return [...turns.values()];
+}
+async function queryTaskUsage(tasks, accessToken, accountId, signal) {
+  const response = await fetch(TASK_USAGE_URL, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "ChatGPT-Account-Id": accountId,
+      "Content-Type": "application/json",
+      "User-Agent": "codex-cli"
+    },
+    body: JSON.stringify({
+      threads: tasks.map((task) => ({
+        thread_id: task.threadId,
+        created_at: task.createdAt,
+        descendant_thread_ids: task.descendantThreadIds
+      }))
+    }),
+    signal: AbortSignal.any([
+      AbortSignal.timeout(2e4),
+      ...signal ? [signal] : []
+    ])
+  });
+  if (!response.ok)
+    throw new Error(
+      `Codex task usage lookup failed with HTTP ${response.status}.`
+    );
+  const parsed = taskUsageSchema.safeParse(await response.json());
+  if (!parsed.success) throw new Error("Codex returned invalid task usage.");
+  const requested = new Set(tasks.map((task) => task.threadId));
+  const byId = new Map(tasks.map((task) => [task.threadId, task]));
+  const result = /* @__PURE__ */ new Map();
+  for (const row of parsed.data.threads) {
+    if (!requested.has(row.thread_id) || result.has(row.thread_id))
+      throw new Error("Codex returned an unexpected task usage ID.");
+    const task = byId.get(row.thread_id);
+    result.set(row.thread_id, {
+      threadId: row.thread_id,
+      createdAt: task.createdAt,
+      descendantThreadIds: [...task.descendantThreadIds],
+      dataStatus: row.data_status,
+      usageSource: row.usage_source,
+      balanceUsageCredits: row.balance_usage_credits ?? null
+    });
+  }
+  return result;
+}
+async function syncCodexBilling(config2, fetcher = collectorFetch, signal) {
+  const auth = await readAuth(config2.codexHome);
+  const stateFile = path18.join(config2.dataDirectory, "codex-billing-sync.json");
+  const prior = await readState(stateFile);
+  const nowMs = Date.now();
+  const history = prior === null || prior.accountFingerprint !== auth.accountFingerprint;
+  const audit = !history && nowMs - prior.lastAuditAtMs >= 7 * DAY_MS2;
+  const cutoff = history ? 0 : Math.min(
+    prior.lastSyncedAtMs - DAY_MS2,
+    nowMs - (audit ? 35 : 7) * DAY_MS2
+  );
+  const filenames = await sourceFiles("codex", config2.codexHome);
+  const threads = [];
+  for (const filename of filenames) {
+    signal?.throwIfAborted();
+    const thread = await localThread(filename);
+    if (thread !== null) threads.push(thread);
+  }
+  const allTasks = groupCodexTasks(threads, auth.accountId);
+  const retryIds = new Set(audit ? prior?.unavailableThreadIds ?? [] : []);
+  const selected = allTasks.filter(
+    (task) => task.mtimeMs >= cutoff || retryIds.has(task.threadId)
+  );
+  if (selected.length === 0)
+    return {
+      tasks: 0,
+      included: 0,
+      creditTasks: 0,
+      apiTurns: 0,
+      skipped: false
+    };
+  const selectedIds = new Set(
+    selected.flatMap((task) => [task.threadId, ...task.descendantThreadIds])
+  );
+  const modelProviders = new Map(
+    threads.filter((thread) => selectedIds.has(thread.threadId)).map((thread) => [thread.threadId, thread.modelProvider])
+  );
+  const authTurns = await localAuthTurns(config2.codexHome, modelProviders);
+  const byThread = /* @__PURE__ */ new Map();
+  for (const turn of authTurns) {
+    const turns = byThread.get(turn.threadId) ?? [];
+    turns.push(turn);
+    byThread.set(turn.threadId, turns);
+  }
+  const localTaskIds = new Set(allTasks.map((task) => task.threadId));
+  const unavailable = new Set(
+    history ? [] : (prior?.unavailableThreadIds ?? []).filter(
+      (id) => localTaskIds.has(id)
+    )
+  );
+  let included = 0;
+  let creditTasks = 0;
+  let apiTurns = 0;
+  const endpoint = new URL(config2.endpoint);
+  endpoint.pathname = "/api/traces/codex-billing";
+  const batches = [];
+  let current = [];
+  let currentIds = 0;
+  let currentTurns = 0;
+  for (const task of selected) {
+    const size = 1 + task.descendantThreadIds.length;
+    const turns = [task.threadId, ...task.descendantThreadIds].reduce(
+      (total, threadId) => total + (byThread.get(threadId)?.length ?? 0),
+      0
+    );
+    if (size > 1e3)
+      throw new Error("Codex task exceeds the billing thread limit.");
+    if (current.length >= TASK_BATCH_SIZE || currentIds + size > 1e3 || currentTurns + turns > 5e3) {
+      if (current.length > 0) batches.push(current);
+      current = [];
+      currentIds = 0;
+      currentTurns = 0;
+    }
+    current.push(task);
+    currentIds += size;
+    currentTurns += turns;
+    if (turns > 5e3) {
+      batches.push(current);
+      current = [];
+      currentIds = 0;
+      currentTurns = 0;
+    }
+  }
+  if (current.length > 0) batches.push(current);
+  for (const batch of batches) {
+    signal?.throwIfAborted();
+    const responseTasks = auth.accessToken === null || auth.accountId === null ? /* @__PURE__ */ new Map() : await queryTaskUsage(batch, auth.accessToken, auth.accountId, signal);
+    const tasks = batch.map((task) => {
+      const response = responseTasks.get(task.threadId);
+      return response ?? {
+        threadId: task.threadId,
+        createdAt: task.createdAt,
+        descendantThreadIds: [...task.descendantThreadIds],
+        dataStatus: auth.accessToken === null || auth.accountId === null ? "not_queried" : "unavailable",
+        usageSource: "",
+        balanceUsageCredits: null
+      };
+    });
+    const batchTurns = batch.flatMap(
+      (task) => [task.threadId, ...task.descendantThreadIds].flatMap(
+        (threadId) => byThread.get(threadId) ?? []
+      )
+    );
+    let serverIncomplete = false;
+    for (let offset = 0; offset < Math.max(1, batchTurns.length); offset += 5e3) {
+      const request2 = codexBillingRequestSchema.parse({
+        accountFingerprint: auth.accountFingerprint,
+        reconcile: offset === 0,
+        tasks,
+        authTurns: batchTurns.slice(offset, offset + 5e3)
+      });
+      const response = await fetcher(endpoint, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${config2.token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(request2),
+        signal: AbortSignal.any([
+          AbortSignal.timeout(9e4),
+          ...signal ? [signal] : []
+        ])
+      });
+      if (!response.ok)
+        throw new Error(
+          `Codex billing sync failed with HTTP ${response.status}.`
+        );
+      const result = syncResultSchema.safeParse(await response.json());
+      if (!result.success || result.data.matched > tasks.length)
+        throw new Error("Iteration returned an invalid Codex billing result.");
+      if (result.data.matched < tasks.length) serverIncomplete = true;
+    }
+    for (const task of tasks) {
+      if (task.dataStatus === "available" && task.balanceUsageCredits !== null && (task.usageSource === "included_plan" || task.usageSource === "plan_and_credits"))
+        unavailable.delete(task.threadId);
+      else if (task.dataStatus !== "not_queried")
+        unavailable.add(task.threadId);
+      if (serverIncomplete) unavailable.add(task.threadId);
+      if (task.dataStatus === "available" && task.balanceUsageCredits !== null && (task.usageSource === "included_plan" || task.usageSource === "plan_and_credits")) {
+        if (codexCreditSign(task.balanceUsageCredits) === 0 && task.usageSource === "included_plan")
+          included += 1;
+        else if (codexCreditSign(task.balanceUsageCredits) > 0)
+          creditTasks += 1;
+      }
+    }
+    apiTurns += batchTurns.filter((turn) => turn.mode === "api_key").length;
+  }
+  await saveState2(stateFile, {
+    accountFingerprint: auth.accountFingerprint,
+    lastSyncedAtMs: nowMs,
+    lastAuditAtMs: history || audit ? nowMs : prior.lastAuditAtMs,
+    unavailableThreadIds: [...unavailable]
+  });
+  return {
+    tasks: selected.length,
+    included,
+    creditTasks,
+    apiTurns,
+    skipped: false
+  };
+}
+
+// src/service.ts
+function errorCode2(error2) {
+  if (error2 instanceof Error && "code" in error2) return String(error2.code);
+  return null;
+}
+var CollectorLockBusyError = class extends Error {
+};
+function errorCauses(error2) {
+  const causes = [];
+  let current = error2 instanceof Error ? error2.cause : void 0;
+  while (current instanceof Error && causes.length < 4) {
     causes.push({
       name: current.name,
       code: errorCode2(current),
@@ -16994,26 +18048,26 @@ async function persistHealth(health, paths) {
   }
 }
 async function acquireCollectorLock(paths) {
-  await ensurePrivateDirectory(path16.dirname(paths.lock));
+  await ensurePrivateDirectory(path19.dirname(paths.lock));
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const handle = await fs13.open(paths.lock, "wx", 384);
+      const handle = await fs16.open(paths.lock, "wx", 384);
       await handle.writeFile(`${process.pid}
 `, "utf8");
       await handle.sync();
       await handle.close();
       return async () => {
-        const current = await fs13.readFile(paths.lock, "utf8").catch(() => "");
+        const current = await fs16.readFile(paths.lock, "utf8").catch(() => "");
         if (current.trim() === String(process.pid)) {
-          await fs13.rm(paths.lock, { force: true });
+          await fs16.rm(paths.lock, { force: true });
         }
       };
     } catch (error2) {
       if (errorCode2(error2) !== "EEXIST") throw error2;
-      const lockContents = await fs13.readFile(paths.lock, "utf8").catch(() => "");
+      const lockContents = await fs16.readFile(paths.lock, "utf8").catch(() => "");
       const lockPid = Number(lockContents.trim());
       if (!Number.isSafeInteger(lockPid) || lockPid < 2) {
-        await fs13.rm(paths.lock, { force: true });
+        await fs16.rm(paths.lock, { force: true });
         continue;
       }
       try {
@@ -17021,7 +18075,7 @@ async function acquireCollectorLock(paths) {
         throw new CollectorLockBusyError("Collector is already running.");
       } catch (processError) {
         if (errorCode2(processError) !== "ESRCH") throw processError;
-        await fs13.rm(paths.lock, { force: true });
+        await fs16.rm(paths.lock, { force: true });
       }
     }
   }
@@ -17111,11 +18165,13 @@ async function runCollector(directory, expectedSource) {
     if ("cursorHome" in config2) {
       await ensureCursorHistoryBackfill(config2.cursorHome, paths);
       await installCursorHooks(config2.cursorHome, config2.dataDirectory);
-    } else if ("claudeHome" in config2)
+    } else if ("claudeHome" in config2) {
       await ensureClaudeHistoryBackfill(config2.claudeHome, paths);
-    else await ensureHistoryBackfill(config2.codexHome, paths);
+      await installTurnSummary(config2);
+    } else await ensureHistoryBackfill(config2.codexHome, paths);
     const summariesRefreshedAt = /* @__PURE__ */ new Map();
     let lastAutoCheckAt = 0;
+    let lastBillingSyncAt = 0;
     const runtimeVersion = process.env.ITERATION_RUNTIME_VERSION;
     let lastRuntimeCheckAt = 0;
     let trialSettled = runtimeVersion === void 0;
@@ -17177,6 +18233,7 @@ async function runCollector(directory, expectedSource) {
         }
       }
       let acknowledgedAtMs = null;
+      let billingReady = false;
       try {
         const result = await collectorTick(
           config2,
@@ -17187,6 +18244,7 @@ async function runCollector(directory, expectedSource) {
             acknowledgedAtMs = Date.now();
           }
         );
+        billingReady = result.historyCaughtUp && result.outboxBytes === 0;
         if (acknowledgedAtMs !== null || health.lastFailure !== null || result.historyCaughtUp && health.historyCaughtUpAtMs === null) {
           health = {
             lastUploadAtMs: acknowledgedAtMs ?? health.lastUploadAtMs,
@@ -17262,6 +18320,60 @@ async function runCollector(directory, expectedSource) {
           })
         );
       }
+      if ("cursorHome" in config2 && billingReady && Date.now() - lastBillingSyncAt >= 6 * 60 * 60 * 1e3) {
+        try {
+          const billing = await syncCursorBilling(
+            config2,
+            collectorFetch,
+            controller.signal
+          );
+          lastBillingSyncAt = billing.skipped ? Date.now() - 6 * 60 * 60 * 1e3 + 5 * 60 * 1e3 : Date.now();
+          console.info(
+            JSON.stringify({
+              level: "info",
+              operation: "sync_cursor_billing",
+              ...billing
+            })
+          );
+        } catch (error2) {
+          if (controller.signal.aborted) break;
+          lastBillingSyncAt = Date.now() - 6 * 60 * 60 * 1e3 + 5 * 60 * 1e3;
+          console.error(
+            JSON.stringify({
+              level: "warning",
+              operation: "sync_cursor_billing",
+              message: error2 instanceof Error ? error2.message : "Cursor billing sync failed."
+            })
+          );
+        }
+      }
+      if ("codexHome" in config2 && billingReady && Date.now() - lastBillingSyncAt >= 6 * 60 * 60 * 1e3) {
+        try {
+          const billing = await syncCodexBilling(
+            config2,
+            collectorFetch,
+            controller.signal
+          );
+          lastBillingSyncAt = billing.skipped ? Date.now() - 6 * 60 * 60 * 1e3 + 5 * 60 * 1e3 : Date.now();
+          console.info(
+            JSON.stringify({
+              level: "info",
+              operation: "sync_codex_billing",
+              ...billing
+            })
+          );
+        } catch (error2) {
+          if (controller.signal.aborted) break;
+          lastBillingSyncAt = Date.now() - 6 * 60 * 60 * 1e3 + 5 * 60 * 1e3;
+          console.error(
+            JSON.stringify({
+              level: "warning",
+              operation: "sync_codex_billing",
+              message: error2 instanceof Error ? error2.message : "Codex billing sync failed."
+            })
+          );
+        }
+      }
       try {
         await delay3(retryDelayMs, void 0, { signal: controller.signal });
       } catch (error2) {
@@ -17289,7 +18401,7 @@ async function importSourceHistory(config2, paths, confirmed, control = backgrou
   const source = collectorSource(config2);
   const directory = collectorSourceDirectory(config2);
   const state = await loadState(paths);
-  if (!state.initialized || state.sourceDirectory !== path17.resolve(directory)) {
+  if (!state.initialized || state.sourceDirectory !== path20.resolve(directory)) {
     throw new Error(
       `Connect the ${source} source before importing its history.`
     );
@@ -17478,7 +18590,7 @@ function renderHome(status2, nowMs = Date.now(), source = "codex") {
   } else if (status2.hookFailureAtMs !== null && status2.hookFailureAtMs !== void 0) {
     lines.push(
       `${name} hook capture needs attention`,
-      `A Cursor hook failed ${relativeTime(status2.hookFailureAtMs, nowMs)}. Some data may be missing. See iteration status cursor.`
+      `A ${name} hook failed ${relativeTime(status2.hookFailureAtMs, nowMs)}. Some data may be missing. See iteration status ${source}.`
     );
   } else if (!status2.healthAvailable) {
     lines.push(
@@ -17588,7 +18700,7 @@ function renderDetailedStatus(status2, nowMs = Date.now(), source = "codex") {
   }
   if (status2.hookFailureAtMs !== null && status2.hookFailureAtMs !== void 0)
     lines.push(
-      `Last Cursor hook capture failure: ${relativeTime(status2.hookFailureAtMs, nowMs)}. Some data may be missing; inspect Cursor hook logs.`
+      `Last ${name} hook capture failure: ${relativeTime(status2.hookFailureAtMs, nowMs)}. Some data may be missing; inspect ${name} hook logs.`
     );
   if (status2.turnSummaryNeedsApproval) lines.push(CODEX_APPROVAL_STEP);
   if (!status2.running) lines.push(`Resume: iteration start ${source}`);
@@ -17718,7 +18830,7 @@ function usage(command) {
 }
 async function fileExists(filename) {
   try {
-    await fs14.access(filename);
+    await fs17.access(filename);
     return true;
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
@@ -17768,7 +18880,7 @@ ${missing2.map(collectorSourceLabel).join(" and ")} found on this computer but n
   await connectAll({});
 }
 function dataDirectory(source, values) {
-  return path18.resolve(
+  return path21.resolve(
     optionalString(values, "data-directory") ?? defaultCollectorDirectory(source)
   );
 }
@@ -17789,12 +18901,12 @@ async function initialize(source, values) {
   requireCollectorPlatform();
   const endpoint = optionalString(values, "endpoint") ?? DEFAULT_INGEST_ENDPOINT;
   const endpointUrl = validateCollectorEndpoint(endpoint);
-  const deviceName = optionalString(values, "device-name") ?? os7.hostname();
+  const deviceName = optionalString(values, "device-name") ?? os8.hostname();
   const organizationId = optionalString(values, "organization-id");
   const directory = dataDirectory(source, values);
   const paths = collectorPaths(directory);
-  const selectedHome = path18.resolve(
-    source === "codex" ? optionalString(values, "codex-home") ?? process.env.CODEX_HOME ?? path18.join(os7.homedir(), ".codex") : source === "claude" ? optionalString(values, "claude-home") ?? process.env.CLAUDE_CONFIG_DIR ?? path18.join(os7.homedir(), ".claude") : optionalString(values, "cursor-home") ?? path18.join(os7.homedir(), ".cursor")
+  const selectedHome = path21.resolve(
+    source === "codex" ? optionalString(values, "codex-home") ?? process.env.CODEX_HOME ?? path21.join(os8.homedir(), ".codex") : source === "claude" ? optionalString(values, "claude-home") ?? process.env.CLAUDE_CONFIG_DIR ?? path21.join(os8.homedir(), ".claude") : optionalString(values, "cursor-home") ?? path21.join(os8.homedir(), ".cursor")
   );
   await assertFreshCollectorDirectory(paths, source);
   const preparedState = await prepareSourceInitialState(
@@ -17877,13 +18989,13 @@ async function connectAll(values) {
   }
   const configs = await Promise.all(COLLECTOR_SOURCES.map(connectedConfig));
   const sourceHomes = {
-    codex: path18.resolve(
+    codex: path21.resolve(
       optionalString(values, "codex-home") ?? (configs[0] && "codexHome" in configs[0] ? configs[0].codexHome : sourceHome("codex"))
     ),
-    claude: path18.resolve(
+    claude: path21.resolve(
       optionalString(values, "claude-home") ?? (configs[1] && "claudeHome" in configs[1] ? configs[1].claudeHome : sourceHome("claude"))
     ),
-    cursor: path18.resolve(
+    cursor: path21.resolve(
       optionalString(values, "cursor-home") ?? (configs[2] && "cursorHome" in configs[2] ? configs[2].cursorHome : sourceHome("cursor"))
     )
   };
@@ -18066,7 +19178,7 @@ async function statusSnapshot(source, values) {
     historyScanProgress(collectorSourceDirectory(config2), paths, source),
     healthSnapshot(paths),
     codexTurnSummaryApproval(config2),
-    source === "cursor" ? cursorHookFailureAtMs(config2.dataDirectory) : Promise.resolve(null)
+    source === "cursor" ? cursorHookFailureAtMs(config2.dataDirectory) : source === "claude" ? claudeGitHookFailureAtMs(config2.dataDirectory) : Promise.resolve(null)
   ]);
   const pendingEvents = size === 0 ? 0 : ids.size;
   const pendingBytes = ids.size === 0 ? 0 : size;
@@ -18231,6 +19343,18 @@ async function update(setting, values) {
 `);
 }
 async function main() {
+  if (process.argv[2] === "claude-git-hook") {
+    const directory = process.argv[3];
+    if (!directory || process.argv.length !== 4)
+      throw new Error("Invalid Claude Git hook command.");
+    try {
+      await captureClaudeGit(directory);
+    } catch (error2) {
+      await recordClaudeGitHookFailure(directory);
+      throw error2;
+    }
+    return;
+  }
   const delegated = await delegateToInstalledVersion();
   if (delegated !== null) {
     process.exitCode = delegated;