iteration-cli 0.11.1 → 0.12.0

package/dist/cli.js

@@ -934,8 +934,8 @@ var require_src = __commonJS({
 // src/cli.ts
 import { spawnSync } from "node:child_process";
 import os8 from "node:os";
-import path20 from "node:path";
-import { promises as fs16 } from "node:fs";
+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, path21) {
-  if (!path21)
+function getElementAtPath(obj, path22) {
+  if (!path22)
     return obj;
-  return path21.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(path21, issues) {
+function prefixIssues(path22, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path21);
+    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, path21 = []) => {
+  const processError = (error3, path22 = []) => {
     for (const issue2 of error3.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path21, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path21, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path21, ...issue2.path];
+        const fullpath = [...path22, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -7557,6 +7557,34 @@ var cursorBillingRequestSchema = object({
     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;
@@ -11278,11 +11306,11 @@ function requireLodash_sortby() {
     function baseForOwn(object3, iteratee) {
       return object3 && baseFor(object3, iteratee, keys);
     }
-    function baseGet(object3, path21) {
-      path21 = isKey(path21, object3) ? [path21] : castPath(path21);
-      var index = 0, length = path21.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(path21[index++])];
+        object3 = object3[toKey(path22[index++])];
       }
       return index && index == length ? object3 : void 0;
     }
@@ -11409,13 +11437,13 @@ function requireLodash_sortby() {
         return object3 === source || baseIsMatch(object3, source, matchData);
       };
     }
-    function baseMatchesProperty(path21, srcValue) {
-      if (isKey(path21) && isStrictComparable(srcValue)) {
-        return matchesStrictComparable(toKey(path21), srcValue);
+    function baseMatchesProperty(path22, srcValue) {
+      if (isKey(path22) && isStrictComparable(srcValue)) {
+        return matchesStrictComparable(toKey(path22), srcValue);
       }
       return function(object3) {
-        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);
+        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) {
@@ -11431,9 +11459,9 @@ function requireLodash_sortby() {
         return compareMultiple(object3, other, orders);
       });
     }
-    function basePropertyDeep(path21) {
+    function basePropertyDeep(path22) {
       return function(object3) {
-        return baseGet(object3, path21);
+        return baseGet(object3, path22);
       };
     }
     function baseRest(func, start2) {
@@ -11688,11 +11716,11 @@ function requireLodash_sortby() {
         return result;
       };
     }
-    function hasPath(object3, path21, hasFunc) {
-      path21 = isKey(path21, object3) ? [path21] : castPath(path21);
-      var result, index = -1, length = path21.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(path21[index]);
+        var key = toKey(path22[index]);
         if (!(result = object3 != null && hasFunc(object3, key))) {
           break;
         }
@@ -11847,12 +11875,12 @@ function requireLodash_sortby() {
     function toString(value) {
       return value == null ? "" : baseToString(value);
     }
-    function get(object3, path21, defaultValue) {
-      var result = object3 == null ? void 0 : baseGet(object3, path21);
+    function get(object3, path22, defaultValue) {
+      var result = object3 == null ? void 0 : baseGet(object3, path22);
       return result === void 0 ? defaultValue : result;
     }
-    function hasIn(object3, path21) {
-      return object3 != null && hasPath(object3, path21, baseHasIn);
+    function hasIn(object3, path22) {
+      return object3 != null && hasPath(object3, path22, baseHasIn);
     }
     function keys(object3) {
       return isArrayLike(object3) ? arrayLikeKeys(object3) : baseKeys(object3);
@@ -11860,8 +11888,8 @@ function requireLodash_sortby() {
     function identity(value) {
       return value;
     }
-    function property(path21) {
-      return isKey(path21) ? baseProperty(toKey(path21)) : basePropertyDeep(path21);
+    function property(path22) {
+      return isKey(path22) ? baseProperty(toKey(path22)) : basePropertyDeep(path22);
     }
     module.exports = sortBy;
   })(lodash_sortby, lodash_sortby.exports);
@@ -12292,16 +12320,16 @@ async function reportIfFoundPrivateKeyP12Format({ source, context, t }) {
     return;
   }
   try {
-    const fs17 = await import("node:fs");
-    const path21 = await import("node:path");
-    const pfxBytes = new Uint8Array(fs17.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: path21.basename(source.filePath)
+        FILE_NAME: path22.basename(source.filePath)
       }),
       range: [0, source.content.length]
     });
@@ -15966,11 +15994,11 @@ async function connectedConfig(source) {
 }
 
 // src/history-import.ts
-import path19 from "node:path";
+import path20 from "node:path";
 
 // src/service.ts
-import { promises as fs15 } from "node:fs";
-import path18 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
@@ -17500,6 +17528,485 @@ async function syncCursorBilling(config2, fetcher = collectorFetch, signal) {
   };
 }
 
+// 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);
@@ -17541,26 +18048,26 @@ async function persistHealth(health, paths) {
   }
 }
 async function acquireCollectorLock(paths) {
-  await ensurePrivateDirectory(path18.dirname(paths.lock));
+  await ensurePrivateDirectory(path19.dirname(paths.lock));
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      const handle = await fs15.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 fs15.readFile(paths.lock, "utf8").catch(() => "");
+        const current = await fs16.readFile(paths.lock, "utf8").catch(() => "");
         if (current.trim() === String(process.pid)) {
-          await fs15.rm(paths.lock, { force: true });
+          await fs16.rm(paths.lock, { force: true });
         }
       };
     } catch (error2) {
       if (errorCode2(error2) !== "EEXIST") throw error2;
-      const lockContents = await fs15.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 fs15.rm(paths.lock, { force: true });
+        await fs16.rm(paths.lock, { force: true });
         continue;
       }
       try {
@@ -17568,7 +18075,7 @@ async function acquireCollectorLock(paths) {
         throw new CollectorLockBusyError("Collector is already running.");
       } catch (processError) {
         if (errorCode2(processError) !== "ESRCH") throw processError;
-        await fs15.rm(paths.lock, { force: true });
+        await fs16.rm(paths.lock, { force: true });
       }
     }
   }
@@ -17840,6 +18347,33 @@ async function runCollector(directory, expectedSource) {
           );
         }
       }
+      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) {
@@ -17867,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 !== path19.resolve(directory)) {
+  if (!state.initialized || state.sourceDirectory !== path20.resolve(directory)) {
     throw new Error(
       `Connect the ${source} source before importing its history.`
     );
@@ -18296,7 +18830,7 @@ function usage(command) {
 }
 async function fileExists(filename) {
   try {
-    await fs16.access(filename);
+    await fs17.access(filename);
     return true;
   } catch (error2) {
     if (error2 instanceof Error && "code" in error2 && error2.code === "ENOENT") {
@@ -18346,7 +18880,7 @@ ${missing2.map(collectorSourceLabel).join(" and ")} found on this computer but n
   await connectAll({});
 }
 function dataDirectory(source, values) {
-  return path20.resolve(
+  return path21.resolve(
     optionalString(values, "data-directory") ?? defaultCollectorDirectory(source)
   );
 }
@@ -18371,8 +18905,8 @@ async function initialize(source, values) {
   const organizationId = optionalString(values, "organization-id");
   const directory = dataDirectory(source, values);
   const paths = collectorPaths(directory);
-  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")
+  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(
@@ -18455,13 +18989,13 @@ async function connectAll(values) {
   }
   const configs = await Promise.all(COLLECTOR_SOURCES.map(connectedConfig));
   const sourceHomes = {
-    codex: path20.resolve(
+    codex: path21.resolve(
       optionalString(values, "codex-home") ?? (configs[0] && "codexHome" in configs[0] ? configs[0].codexHome : sourceHome("codex"))
     ),
-    claude: path20.resolve(
+    claude: path21.resolve(
       optionalString(values, "claude-home") ?? (configs[1] && "claudeHome" in configs[1] ? configs[1].claudeHome : sourceHome("claude"))
     ),
-    cursor: path20.resolve(
+    cursor: path21.resolve(
       optionalString(values, "cursor-home") ?? (configs[2] && "cursorHome" in configs[2] ? configs[2].cursorHome : sourceHome("cursor"))
     )
   };

package/dist/cursor-hook-entry.js

@@ -7285,6 +7285,31 @@ function superRefine(fn, params) {
   return _superRefine(fn, params);
 }
 
+// ../../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);
+}
+
 // src/cursor-hooks.ts
 import path2 from "node:path";
 
@@ -7340,6 +7365,28 @@ var cursorBillingRequestSchema = object({
     paidUsd: number2().finite().nonnegative().nullable()
   }).strict()).max(5e3)
 }).strict();
+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;

package/dist/launcher.js

@@ -6364,6 +6364,31 @@ function superRefine(fn, params) {
   return _superRefine(fn, params);
 }
 
+// ../../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);
+}
+
 // ../trace-contracts/dist/index.js
 var TRACE_EVENT_TYPES = [
   "user_message",
@@ -6416,6 +6441,28 @@ var cursorBillingRequestSchema = object({
     paidUsd: number2().finite().nonnegative().nullable()
   }).strict()).max(5e3)
 }).strict();
+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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iteration-cli",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -22,7 +22,7 @@
     "@secretlint/secretlint-rule-preset-recommend": "13.0.6",
     "esbuild": "0.28.2",
     "zod": "4.6.4",
-    "iteration-trace-contracts": "0.8.0"
+    "iteration-trace-contracts": "0.9.0"
   },
   "scripts": {
     "build": "pnpm --filter iteration-trace-contracts build && tsc -p tsconfig.json --noEmit && node build.mjs"