iteration-cli 0.11.1 → 0.13.0

package/README.md

@@ -1,13 +1,19 @@
 # Iteration CLI
 
-Install one CLI for Iteration's supported coding-agent sources:
+Connect a computer with the command shown on your Iteration workspace's overview:
+
+```sh
+npx iteration-cli connect --workspace <workspace ID>
+```
+
+`--workspace` connects to that workspace without a prompt. The collectors keep running from their own copy of the CLI, so the command does not need a global install. To keep the `iteration` command for status and later changes, install it globally:
 
 ```sh
 npm install --global iteration-cli
 iteration connect
 ```
 
-The collectors run on macOS or Linux with Node.js 22 or later. Cursor's local Agents window collector is tested on macOS. Linux needs systemd. The CLI automatically enables background collection after logout and installs a user service that starts at boot and restarts on failure. If server policy does not let the user enable this, an administrator must allow background services for the account. The setting applies to the whole Linux account and remains enabled after `iteration disconnect`; the CLI does not turn off other user services. `iteration connect` finds supported agents with local session directories, asks once before uploading their saved sessions and future activity, and connects them to one workspace. A connected collector checks for newly detected supported agents and connects them under that approval. Each source has its own background process, local checkpoint, and upload queue. Run `iteration` to see connected sources, `iteration status cursor` for Cursor details, and `iteration help` for other commands. Source-specific connect commands remain available for advanced setups.
+The collectors run on macOS or Linux with Node.js 22 or later. Cursor's local Agents window collector is tested on macOS. Linux needs systemd. The CLI automatically enables background collection after logout and installs a user service that starts at boot and restarts on failure. If server policy does not let the user enable this, an administrator must allow background services for the account. The setting applies to the whole Linux account and remains enabled after `iteration disconnect`; the CLI does not turn off other user services. `iteration connect` finds supported agents with local session directories, shows how many saved sessions each one has, asks once before uploading them and future activity, and connects them to one workspace. Saved sessions import newest first, and each collector reports its import progress to Iteration until it completes. A connected collector checks for newly detected supported agents and connects them under that approval. Each source has its own background process, local checkpoint, and upload queue. Run `iteration` to see connected sources, `iteration status cursor` for Cursor details, and `iteration help` for other commands. Source-specific connect commands remain available for advanced setups.
 
 Cursor's **This Mac** Agents sessions are read from `~/.cursor/projects/*/agent-transcripts/<conversation>/<conversation>.jsonl`. Connecting Cursor also installs user-level hooks in `~/.cursor/hooks.json` automatically. They capture tool output, thought blocks, model and usage fields, subagent transcripts, and other lifecycle records that the main transcript omits; the collector queues those records locally before upload. Existing hooks are preserved, and `iteration disconnect cursor` removes only Iteration's entries. No Cursor approval or settings step is needed. A custom Cursor directory can be selected with `iteration connect cursor --cursor-home DIR`. Local history predating connection has transcript messages and tool calls, but tool results that Cursor never wrote to its transcript cannot be recovered. Cloud Agents are outside this local collector.
 

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;
@@ -7605,6 +7633,12 @@ var acknowledgementSchema = object({
 }).strict();
 var episodeCountSchema = number2().int().min(0).max(Number.MAX_SAFE_INTEGER);
 var collectorFrictionSummarySchema = object({ weekEpisodes: episodeCountSchema, dayEpisodes: episodeCountSchema }).strict().refine((summary) => summary.dayEpisodes <= summary.weekEpisodes, "The last day cannot have more friction episodes than the last week.");
+var sessionCountSchema = number2().int().min(0).max(1e6);
+var collectorHistoryProgressSchema = object({
+  sessions: sessionCountSchema,
+  readSessions: sessionCountSchema,
+  complete: boolean2()
+}).strict().refine((progress) => progress.readSessions <= progress.sessions, "Read sessions cannot exceed listed sessions.").refine((progress) => !progress.complete || progress.readSessions === progress.sessions, "A complete import has read every listed session.");
 var collectorEnrollmentRequestSchema = object({
   deviceName: string2().trim().min(1).max(160),
   organizationId: string2().regex(UUID_PATTERN).optional(),
@@ -7905,7 +7939,7 @@ async function clerkDeviceSignIn(configuration) {
   );
   const verificationUrl = challenge.verification_uri_complete ?? challenge.verification_uri;
   process.stdout.write(
-    "Sign in to Iteration to authorize this collector.\nCode: " + challenge.user_code + "\nLink: " + verificationUrl + "\n"
+    "Sign in to Iteration in your browser and confirm this code.\nCode: " + challenge.user_code + "\nLink: " + verificationUrl + "\n"
   );
   await openBrowser(verificationUrl);
   return pollForAccessToken(
@@ -7953,7 +7987,7 @@ async function chooseOrganization(organizations, hasMore) {
     );
   }
   if (process.stdin.isTTY !== true) {
-    throw new Error("Run iteration interactively or pass --organization-id.");
+    throw new Error("Run iteration interactively or pass --workspace.");
   }
   const prompt = createInterface({
     input: process.stdin,
@@ -11278,11 +11312,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 +11443,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 +11465,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 +11722,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 +11881,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 +11894,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 +12326,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]
     });
@@ -15053,6 +15087,38 @@ async function claudeFiles(root) {
   }
   return files.sort();
 }
+function isSessionFile(filename) {
+  return !filename.includes(`${path8.sep}subagents${path8.sep}`);
+}
+async function countSavedSessions(source, home) {
+  return (await sourceFiles(source, home)).filter(isSessionFile).length;
+}
+async function sourceFilesNewestFirst(source, home) {
+  const files = await sourceFiles(source, home);
+  const listed = [];
+  for (let start2 = 0; start2 < files.length; start2 += 64) {
+    const batch = files.slice(start2, start2 + 64);
+    const stats = await Promise.all(batch.map((filename) => fs8.stat(filename)));
+    for (const [index, stat] of stats.entries()) {
+      const filename = batch[index];
+      if (filename === void 0) continue;
+      listed.push({
+        filename,
+        size: stat.size,
+        modifiedMs: stat.mtimeMs,
+        session: isSessionFile(filename)
+      });
+    }
+  }
+  listed.sort(
+    (left, right) => right.modifiedMs - left.modifiedMs || left.filename.localeCompare(right.filename)
+  );
+  return listed.map(({ filename, size, session }) => ({
+    filename,
+    size,
+    session
+  }));
+}
 function sourceFiles(source, home) {
   const directory = path8.resolve(home);
   if (source === "codex") return rolloutFiles(path8.join(directory, "sessions"));
@@ -15966,11 +16032,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
@@ -16993,9 +17059,13 @@ async function scanSourceOnce(config2, paths, signal) {
   }
   const cursors = { ...state.cursors };
   const skipping = new Set(state.skipping);
+  const sessionFiles = await sourceFilesNewestFirst(source, sourceDirectory);
+  const listedSizes = new Map(
+    sessionFiles.map((file) => [file.filename, file.size])
+  );
   const files = [
     ...source === "claude" ? await claudeGitHookFiles(config2.dataDirectory) : [],
-    ...await sourceFiles(source, sourceDirectory),
+    ...sessionFiles.map((file) => file.filename),
     ...source === "cursor" ? await cursorHookFiles(config2.dataDirectory) : []
   ];
   const completedHooks = [];
@@ -17011,15 +17081,15 @@ async function scanSourceOnce(config2, paths, signal) {
       caughtUp = false;
       break;
     }
-    const stats = await fs13.stat(filename);
+    const size = listedSizes.get(filename) ?? (await fs13.stat(filename)).size;
     let offset = cursors[filename] ?? 0;
-    if (offset > stats.size) {
+    if (offset > size) {
       logGap(filename, offset, "rollout_file_shrank_resetting_cursor");
       offset = 0;
       skipping.delete(filename);
     }
     const bytesToRead = Math.min(
-      stats.size - offset,
+      size - offset,
       MAX_SCAN_BYTES_PER_FILE,
       remainingBudget
     );
@@ -17039,7 +17109,7 @@ async function scanSourceOnce(config2, paths, signal) {
     } finally {
       await handle.close();
     }
-    if (readEnd < stats.size) caughtUp = false;
+    if (readEnd < size) caughtUp = false;
     if (skipping.has(filename)) {
       const newline = buffer.indexOf(10);
       if (newline < 0) {
@@ -17102,7 +17172,7 @@ async function scanSourceOnce(config2, paths, signal) {
       lineStart = buffer.length;
     }
     cursors[filename] = offset + lineStart;
-    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)
+    if ((source === "cursor" && filename.includes(`${path16.sep}cursor-hooks${path16.sep}`) || source === "claude" && filename.includes(`${path16.sep}git-queue${path16.sep}`)) && cursors[filename] === size)
       completedHooks.push(filename);
   }
   await appendEvents(events, paths);
@@ -17119,7 +17189,17 @@ async function scanSourceOnce(config2, paths, signal) {
     },
     paths
   );
-  return { discovered: events.length, caughtUp };
+  const sessions = sessionFiles.filter((file) => file.session);
+  return {
+    discovered: events.length,
+    caughtUp,
+    history: {
+      sessions: sessions.length,
+      readSessions: sessions.filter(
+        (file) => (cursors[file.filename] ?? 0) >= file.size
+      ).length
+    }
+  };
 }
 async function uploadPendingOnce(config2, paths, fetcher = collectorFetch, signal, onAcknowledged) {
   let uploaded = 0;
@@ -17189,7 +17269,7 @@ async function collectorTick(config2, paths, fetcher = collectorFetch, signal, o
     signal,
     onAcknowledged
   );
-  const scan = await outboxSize(paths) >= SCAN_PAUSE_OUTBOX_BYTES ? { discovered: 0, caughtUp: false } : await scanSourceOnce(config2, paths, signal);
+  const scan = await outboxSize(paths) >= SCAN_PAUSE_OUTBOX_BYTES ? { discovered: 0, caughtUp: false, history: null } : await scanSourceOnce(config2, paths, signal);
   uploaded += await uploadPendingOnce(
     config2,
     paths,
@@ -17201,10 +17281,66 @@ async function collectorTick(config2, paths, fetcher = collectorFetch, signal, o
     discovered: scan.discovered,
     uploaded,
     outboxBytes: await outboxSize(paths),
-    historyCaughtUp: scan.caughtUp
+    historyCaughtUp: scan.caughtUp,
+    history: scan.history
   };
 }
 
+// src/history-progress.ts
+var REQUEST_TIMEOUT_MS3 = 15e3;
+var REPORT_INTERVAL_MS = 1e4;
+var HistoryProgressError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "HistoryProgressError";
+  }
+};
+function unchanged(left, right) {
+  return right !== null && left.sessions === right.sessions && left.readSessions === right.readSessions && left.complete === right.complete;
+}
+var HistoryProgressReporter = class {
+  #sent = null;
+  #sentAtMs = Number.NEGATIVE_INFINITY;
+  #completed = false;
+  async report(config2, progress, fetcher, signal, nowMs) {
+    if (this.#completed || unchanged(progress, this.#sent)) return;
+    if (!progress.complete && nowMs - this.#sentAtMs < REPORT_INTERVAL_MS)
+      return;
+    let response;
+    try {
+      response = await fetcher(
+        new URL("/api/traces/collector-progress", config2.endpoint),
+        {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${config2.token}`,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify(progress),
+          signal: AbortSignal.any([
+            signal,
+            AbortSignal.timeout(REQUEST_TIMEOUT_MS3)
+          ])
+        }
+      );
+    } catch (error2) {
+      if (signal.aborted) throw error2;
+      throw new HistoryProgressError(
+        "History progress could not reach Iteration.",
+        { cause: error2 }
+      );
+    }
+    if (response.status !== 204) {
+      throw new HistoryProgressError(
+        `History progress failed with HTTP ${response.status}.`
+      );
+    }
+    this.#sent = progress;
+    this.#sentAtMs = nowMs;
+    this.#completed = progress.complete;
+  }
+};
+
 // src/cursor-billing.ts
 import { createHash as createHash7 } from "node:crypto";
 import { promises as fs14 } from "node:fs";
@@ -17500,6 +17636,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 +18156,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 +18183,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 });
       }
     }
   }
@@ -17665,6 +18280,7 @@ async function runCollector(directory, expectedSource) {
     const summariesRefreshedAt = /* @__PURE__ */ new Map();
     let lastAutoCheckAt = 0;
     let lastBillingSyncAt = 0;
+    const historyProgress = new HistoryProgressReporter();
     const runtimeVersion = process.env.ITERATION_RUNTIME_VERSION;
     let lastRuntimeCheckAt = 0;
     let trialSettled = runtimeVersion === void 0;
@@ -17727,6 +18343,7 @@ async function runCollector(directory, expectedSource) {
       }
       let acknowledgedAtMs = null;
       let billingReady = false;
+      let history = null;
       try {
         const result = await collectorTick(
           config2,
@@ -17738,6 +18355,12 @@ async function runCollector(directory, expectedSource) {
           }
         );
         billingReady = result.historyCaughtUp && result.outboxBytes === 0;
+        if (result.history !== null) {
+          history = {
+            ...result.history,
+            complete: billingReady && result.history.readSessions === result.history.sessions
+          };
+        }
         if (acknowledgedAtMs !== null || health.lastFailure !== null || result.historyCaughtUp && health.historyCaughtUpAtMs === null) {
           health = {
             lastUploadAtMs: acknowledgedAtMs ?? health.lastUploadAtMs,
@@ -17790,6 +18413,30 @@ async function runCollector(directory, expectedSource) {
         await persistHealth(health, paths);
         retryDelayMs = Math.min(retryDelayMs * 2, 6e4);
       }
+      if (history !== null) {
+        try {
+          await historyProgress.report(
+            config2,
+            history,
+            collectorFetch,
+            controller.signal,
+            Date.now()
+          );
+        } catch (error2) {
+          if (controller.signal.aborted) break;
+          console.error(
+            JSON.stringify({
+              level: "warning",
+              at: (/* @__PURE__ */ new Date()).toISOString(),
+              source,
+              operation: "report_history_progress",
+              errorName: error2 instanceof Error ? error2.name : "UnknownError",
+              causes: errorCauses(error2),
+              message: error2 instanceof Error ? error2.message : "Unknown history progress failure."
+            })
+          );
+        }
+      }
       try {
         if (source !== "cursor")
           await refreshTurnSummaries(
@@ -17840,6 +18487,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 +18541,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.`
     );
@@ -18219,7 +18893,7 @@ function argumentsForCli() {
       help: { type: "boolean" },
       endpoint: { type: "string" },
       "device-name": { type: "string" },
-      "organization-id": { type: "string" },
+      workspace: { type: "string" },
       "codex-home": { type: "string" },
       "claude-home": { type: "string" },
       "cursor-home": { type: "string" },
@@ -18263,7 +18937,7 @@ function usage(command) {
         "",
         "Options for advanced setups:",
         "  --device-name NAME      Name this computer in Iteration",
-        "  --organization-id UUID  Select a workspace without a prompt",
+        "  --workspace ID          Connect to this workspace without a prompt",
         "  --codex-home DIR        Use a different Codex data directory",
         "  --claude-home DIR       Use a different Claude data directory",
         "  --cursor-home DIR       Use a different Cursor data directory",
@@ -18296,7 +18970,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 +19020,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)
   );
 }
@@ -18368,11 +19042,11 @@ async function initialize(source, values) {
   const endpoint = optionalString(values, "endpoint") ?? DEFAULT_INGEST_ENDPOINT;
   const endpointUrl = validateCollectorEndpoint(endpoint);
   const deviceName = optionalString(values, "device-name") ?? os8.hostname();
-  const organizationId = optionalString(values, "organization-id");
+  const organizationId = optionalString(values, "workspace");
   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(
@@ -18415,13 +19089,15 @@ async function initialize(source, values) {
   }
   const notice = await turnSummaryNotice(config2);
   process.stdout.write(
-    `${collectorSourceLabel(source)} is connected to ${enrollment.organizationName}. Existing sessions are importing and new activity is collected automatically. Run iteration to check progress.${notice}
+    `${collectorSourceLabel(source)} is connected to ${enrollment.organizationName}. Existing sessions are importing, newest first, and new activity is collected automatically. Iteration shows the import as it runs.${notice}
 `
   );
   return config2;
 }
 async function approveAllSources(sources, workspaceName, yes) {
-  const names = sources.map(collectorSourceLabel).join(" and ");
+  const names = sources.map(
+    ({ source, sessions }) => `${collectorSourceLabel(source)} (${sessions.toLocaleString("en-US")} saved ${sessions === 1 ? "session" : "sessions"})`
+  ).join(" and ");
   const safeName = safeWorkspaceName(workspaceName);
   process.stdout.write(
     `Detected ${names || "no saved agent sessions"} on this computer.
@@ -18455,13 +19131,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"))
     )
   };
@@ -18498,14 +19174,19 @@ async function connectAll(values) {
       );
     }
   }
-  const requestedOrganizationId = optionalString(values, "organization-id");
+  const requestedOrganizationId = optionalString(values, "workspace");
   if (requestedOrganizationId && existingScopes[0] && requestedOrganizationId !== existingScopes[0].scope.organizationId) {
     throw new Error("The existing collector belongs to a different workspace.");
   }
   const previousConsent = await loadMachineConsent();
   if (previousConsent === null || anchorExisting === null || previousConsent.endpoint !== endpoint || previousConsent.anchorSource !== anchorSource || previousConsent.anchorDataDirectory !== anchorExisting.dataDirectory || previousConsent.organizationId !== existingScopes[0]?.scope.organizationId || previousConsent.sourceHomes.codex !== sourceHomes.codex || previousConsent.sourceHomes.claude !== sourceHomes.claude || previousConsent.sourceHomes.cursor !== sourceHomes.cursor) {
     await approveAllSources(
-      detected,
+      await Promise.all(
+        detected.map(async (source) => ({
+          source,
+          sessions: await countSavedSessions(source, sourceHomes[source])
+        }))
+      ),
       existingScopes[0]?.scope.organizationName ?? null,
       values.yes === true
     );

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;
@@ -7388,6 +7435,12 @@ var acknowledgementSchema = object({
 }).strict();
 var episodeCountSchema = number2().int().min(0).max(Number.MAX_SAFE_INTEGER);
 var collectorFrictionSummarySchema = object({ weekEpisodes: episodeCountSchema, dayEpisodes: episodeCountSchema }).strict().refine((summary) => summary.dayEpisodes <= summary.weekEpisodes, "The last day cannot have more friction episodes than the last week.");
+var sessionCountSchema = number2().int().min(0).max(1e6);
+var collectorHistoryProgressSchema = object({
+  sessions: sessionCountSchema,
+  readSessions: sessionCountSchema,
+  complete: boolean2()
+}).strict().refine((progress) => progress.readSessions <= progress.sessions, "Read sessions cannot exceed listed sessions.").refine((progress) => !progress.complete || progress.readSessions === progress.sessions, "A complete import has read every listed session.");
 var collectorEnrollmentRequestSchema = object({
   deviceName: string2().trim().min(1).max(160),
   organizationId: string2().regex(UUID_PATTERN).optional(),

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;
@@ -6464,6 +6511,12 @@ var acknowledgementSchema = object({
 }).strict();
 var episodeCountSchema = number2().int().min(0).max(Number.MAX_SAFE_INTEGER);
 var collectorFrictionSummarySchema = object({ weekEpisodes: episodeCountSchema, dayEpisodes: episodeCountSchema }).strict().refine((summary) => summary.dayEpisodes <= summary.weekEpisodes, "The last day cannot have more friction episodes than the last week.");
+var sessionCountSchema = number2().int().min(0).max(1e6);
+var collectorHistoryProgressSchema = object({
+  sessions: sessionCountSchema,
+  readSessions: sessionCountSchema,
+  complete: boolean2()
+}).strict().refine((progress) => progress.readSessions <= progress.sessions, "Read sessions cannot exceed listed sessions.").refine((progress) => !progress.complete || progress.readSessions === progress.sessions, "A complete import has read every listed session.");
 var collectorEnrollmentRequestSchema = object({
   deviceName: string2().trim().min(1).max(160),
   organizationId: string2().regex(UUID_PATTERN).optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iteration-cli",
-  "version": "0.11.1",
+  "version": "0.13.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.10.0"
   },
   "scripts": {
     "build": "pnpm --filter iteration-trace-contracts build && tsc -p tsconfig.json --noEmit && node build.mjs"