iteration-cli 0.10.1 → 0.11.1

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 path20 from "node:path";
+import { promises as fs16 } 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, path21) {
+  if (!path21)
     return obj;
-  return path19.reduce((acc, key) => acc?.[key], obj);
+  return path21.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(path21, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path19);
+    iss.path.unshift(path21);
     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, path21 = []) => {
     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 }, [...path21, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path19, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
       } else {
-        const fullpath = [...path19, ...issue2.path];
+        const fullpath = [...path21, ...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,25 @@ 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();
 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 +8019,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 +9374,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 +10296,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 +11278,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, path21) {
+      path21 = isKey(path21, object3) ? [path21] : castPath(path21);
+      var index = 0, length = path21.length;
       while (object3 != null && index < length) {
-        object3 = object3[toKey(path19[index++])];
+        object3 = object3[toKey(path21[index++])];
       }
       return index && index == length ? object3 : void 0;
     }
@@ -11279,13 +11409,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(path21, srcValue) {
+      if (isKey(path21) && isStrictComparable(srcValue)) {
+        return matchesStrictComparable(toKey(path21), 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, path21);
+        return objValue === void 0 && objValue === srcValue ? hasIn(object3, path21) : baseIsEqual(srcValue, objValue, void 0, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
       };
     }
     function baseOrderBy(collection, iteratees, orders) {
@@ -11301,9 +11431,9 @@ function requireLodash_sortby() {
         return compareMultiple(object3, other, orders);
       });
     }
-    function basePropertyDeep(path19) {
+    function basePropertyDeep(path21) {
       return function(object3) {
-        return baseGet(object3, path19);
+        return baseGet(object3, path21);
       };
     }
     function baseRest(func, start2) {
@@ -11558,11 +11688,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, path21, hasFunc) {
+      path21 = isKey(path21, object3) ? [path21] : castPath(path21);
+      var result, index = -1, length = path21.length;
       while (++index < length) {
-        var key = toKey(path19[index]);
+        var key = toKey(path21[index]);
         if (!(result = object3 != null && hasFunc(object3, key))) {
           break;
         }
@@ -11717,12 +11847,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, path21, defaultValue) {
+      var result = object3 == null ? void 0 : baseGet(object3, path21);
       return result === void 0 ? defaultValue : result;
     }
-    function hasIn(object3, path19) {
-      return object3 != null && hasPath(object3, path19, baseHasIn);
+    function hasIn(object3, path21) {
+      return object3 != null && hasPath(object3, path21, baseHasIn);
     }
     function keys(object3) {
       return isArrayLike(object3) ? arrayLikeKeys(object3) : baseKeys(object3);
@@ -11730,8 +11860,8 @@ function requireLodash_sortby() {
     function identity(value) {
       return value;
     }
-    function property(path19) {
-      return isKey(path19) ? baseProperty(toKey(path19)) : basePropertyDeep(path19);
+    function property(path21) {
+      return isKey(path21) ? baseProperty(toKey(path21)) : basePropertyDeep(path21);
     }
     module.exports = sortBy;
   })(lodash_sortby, lodash_sortby.exports);
@@ -12162,16 +12292,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 fs17 = await import("node:fs");
+    const path21 = await import("node:path");
+    const pfxBytes = new Uint8Array(fs17.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: path21.basename(source.filePath)
       }),
       range: [0, source.content.length]
     });
@@ -12198,7 +12328,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 +14402,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 +14428,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 +14456,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 +14469,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 +14520,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 +14553,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 +14583,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 +14603,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 +14630,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 +14642,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 +14664,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 +14678,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 +14710,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 +14734,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 +14755,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 +14792,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 +14815,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 +14841,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 +14859,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 +14875,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 +14888,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 +14899,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 +14923,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 +14934,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 +14961,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 +14970,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 +15001,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 +15010,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 +15022,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 +15035,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 +15054,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 +15065,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 +15086,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 +15202,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 +15244,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 +15285,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 +15318,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 +15377,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 +15448,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 +15457,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 +15483,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 +15493,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 +15561,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 +15580,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 +15597,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 +15640,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 +15663,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 +15678,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 +15699,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 +15720,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 +15728,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 +15741,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 +15781,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 +15807,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 +15817,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 +15913,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 +15956,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 +15966,20 @@ async function connectedConfig(source) {
 }
 
 // src/history-import.ts
-import path17 from "node:path";
+import path19 from "node:path";
 
 // src/service.ts
-import { promises as fs13 } from "node:fs";
-import path16 from "node:path";
+import { promises as fs15 } from "node:fs";
+import path18 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 +16018,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 +16250,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 +16322,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 +16464,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 +16475,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 +16647,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 +16700,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 +16970,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 +16984,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 +16994,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 +17006,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 +17027,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 +17102,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,6 +17205,301 @@ async function collectorTick(config2, paths, fetcher = collectorFetch, signal, o
   };
 }
 
+// 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;
+}
+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/service.ts
 function errorCode2(error2) {
   if (error2 instanceof Error && "code" in error2) return String(error2.code);
@@ -16994,26 +17541,26 @@ async function persistHealth(health, paths) {
   }
 }
 async function acquireCollectorLock(paths) {
-  await ensurePrivateDirectory(path16.dirname(paths.lock));
+  await ensurePrivateDirectory(path18.dirname(paths.lock));
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const handle = await fs13.open(paths.lock, "wx", 384);
+      const handle = await fs15.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 fs15.readFile(paths.lock, "utf8").catch(() => "");
         if (current.trim() === String(process.pid)) {
-          await fs13.rm(paths.lock, { force: true });
+          await fs15.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 fs15.readFile(paths.lock, "utf8").catch(() => "");
       const lockPid = Number(lockContents.trim());
       if (!Number.isSafeInteger(lockPid) || lockPid < 2) {
-        await fs13.rm(paths.lock, { force: true });
+        await fs15.rm(paths.lock, { force: true });
         continue;
       }
       try {
@@ -17021,7 +17568,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 fs15.rm(paths.lock, { force: true });
       }
     }
   }
@@ -17111,11 +17658,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 +17726,7 @@ async function runCollector(directory, expectedSource) {
         }
       }
       let acknowledgedAtMs = null;
+      let billingReady = false;
       try {
         const result = await collectorTick(
           config2,
@@ -17187,6 +17737,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 +17813,33 @@ 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."
+            })
+          );
+        }
+      }
       try {
         await delay3(retryDelayMs, void 0, { signal: controller.signal });
       } catch (error2) {
@@ -17289,7 +17867,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 !== path19.resolve(directory)) {
     throw new Error(
       `Connect the ${source} source before importing its history.`
     );
@@ -17478,7 +18056,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 +18166,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 +18296,7 @@ function usage(command) {
 }
 async function fileExists(filename) {
   try {
-    await fs14.access(filename);
+    await fs16.access(filename);
     return true;
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
@@ -17768,7 +18346,7 @@ ${missing2.map(collectorSourceLabel).join(" and ")} found on this computer but n
   await connectAll({});
 }
 function dataDirectory(source, values) {
-  return path18.resolve(
+  return path20.resolve(
     optionalString(values, "data-directory") ?? defaultCollectorDirectory(source)
   );
 }
@@ -17789,12 +18367,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 = path20.resolve(
+    source === "codex" ? optionalString(values, "codex-home") ?? process.env.CODEX_HOME ?? path20.join(os8.homedir(), ".codex") : source === "claude" ? optionalString(values, "claude-home") ?? process.env.CLAUDE_CONFIG_DIR ?? path20.join(os8.homedir(), ".claude") : optionalString(values, "cursor-home") ?? path20.join(os8.homedir(), ".cursor")
   );
   await assertFreshCollectorDirectory(paths, source);
   const preparedState = await prepareSourceInitialState(
@@ -17877,13 +18455,13 @@ async function connectAll(values) {
   }
   const configs = await Promise.all(COLLECTOR_SOURCES.map(connectedConfig));
   const sourceHomes = {
-    codex: path18.resolve(
+    codex: path20.resolve(
       optionalString(values, "codex-home") ?? (configs[0] && "codexHome" in configs[0] ? configs[0].codexHome : sourceHome("codex"))
     ),
-    claude: path18.resolve(
+    claude: path20.resolve(
       optionalString(values, "claude-home") ?? (configs[1] && "claudeHome" in configs[1] ? configs[1].claudeHome : sourceHome("claude"))
     ),
-    cursor: path18.resolve(
+    cursor: path20.resolve(
       optionalString(values, "cursor-home") ?? (configs[2] && "cursorHome" in configs[2] ? configs[2].cursorHome : sourceHome("cursor"))
     )
   };
@@ -18066,7 +18644,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 +18809,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;