@indigoai-us/hq-cloud 6.14.29 → 6.14.31

package/src/telemetry.ts

@@ -7,9 +7,8 @@
  * (`hq-sync-runner`, `hq-cli`, mobile wrappers) emits telemetry uniformly.
  *
  * What it does: after each successful sync (`all-complete` arm of
- * `bin/sync-runner.ts`), walks `~/.claude/projects/**\/*.jsonl`, diffs each
- * file against a persisted byte-offset cursor at `~/.hq/telemetry-cursor.json`,
- * sanitizes new rows through a tight allowlist that matches the server's
+ * `bin/sync-runner.ts`), walks Claude session logs plus live and archived Codex
+ * rollouts, then diffs each file against the persisted byte-offset cursor at `~/.hq/telemetry-cursor.json`, sanitizes new rows through a tight allowlist that matches the server's
  * KEEP_FIELDS set in `apps/hq-pro/src/vault-service/handlers/usage.ts`,
  * batches into server-sized POST bodies, and ships them to `/v1/usage`.
  *
@@ -23,6 +22,7 @@
  * transient outage retries automatically on the next sync.
  */
 
+import { createHash } from "node:crypto";
 import { promises as fs } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -75,6 +75,12 @@ export interface CollectTelemetryOptions {
   hqRoot?: string;
   /** Override `~/.claude/projects` for tests. */
   claudeProjectsRoot?: string;
+  /** Override `~/.codex` for tests. Both live and archived rollouts are scanned. */
+  codexRoot?: string;
+  /** Override the per-runtime scan budget for deterministic tests. */
+  maxScanBytesPerSource?: number;
+  /** Override the upload batch cap for deterministic tests. */
+  maxBatchesPerRun?: number;
   /** Override `~/.hq/telemetry-cursor.json` for tests. */
   cursorPath?: string;
   /** Override `~/.hq/menubar.json` (the offline opt-in fallback) for tests. */
@@ -98,14 +104,28 @@ export interface CollectTelemetryResult {
 
 // ── Cursor schema ─────────────────────────────────────────────────────────────
 
+interface CodexUsageContext {
+  session_id?: string;
+  cwd?: string;
+  git_branch?: string;
+  session_model?: string;
+  collaboration_model?: string;
+  turn_model?: string;
+  discarding_partial_line?: boolean;
+}
+
 interface CursorEntry {
   offset: number;
   mtime: number;
+  /** Runtime context needed to resume a Codex rollout from a byte offset. */
+  context?: CodexUsageContext;
 }
 
 interface TelemetryCursor {
   version: string;
   files: Record<string, CursorEntry>;
+  /** Preserved for cursor compatibility with the desktop collector. */
+  codex_next_rollout?: string;
 }
 
 function emptyCursor(): TelemetryCursor {
@@ -117,7 +137,13 @@ async function loadCursor(cursorPath: string): Promise<TelemetryCursor> {
     const raw = await fs.readFile(cursorPath, "utf-8");
     const parsed = JSON.parse(raw) as Partial<TelemetryCursor>;
     if (parsed && typeof parsed === "object" && parsed.files && typeof parsed.files === "object") {
-      return { version: parsed.version ?? "1", files: parsed.files as Record<string, CursorEntry> };
+      return {
+        version: parsed.version ?? "1",
+        files: parsed.files as Record<string, CursorEntry>,
+        ...(typeof parsed.codex_next_rollout === "string"
+          ? { codex_next_rollout: parsed.codex_next_rollout }
+          : {}),
+      };
     }
   } catch {
     // Missing / unparseable — start fresh.
@@ -377,16 +403,196 @@ async function listJsonlFiles(root: string): Promise<string[]> {
   return out;
 }
 
+// ── Codex rollout adapter ────────────────────────────────────────────────────
+
+const MAX_ID_BYTES = 256;
+const MAX_TIMESTAMP_BYTES = 128;
+const MAX_PATH_BYTES = 4 * 1024;
+const MAX_MODEL_BYTES = 256;
+
+function boundedString(value: unknown, maxBytes: number): string | undefined {
+  return typeof value === "string" &&
+    value.length > 0 &&
+    Buffer.byteLength(value, "utf-8") <= maxBytes
+    ? value
+    : undefined;
+}
+
+function tokenCount(value: unknown): number {
+  return typeof value === "number" &&
+    Number.isSafeInteger(value) &&
+    value >= 0
+    ? value
+    : 0;
+}
+
+function cloneCodexContext(context: CodexUsageContext): CodexUsageContext {
+  return { ...context };
+}
+
+function codexModel(context: CodexUsageContext): string | undefined {
+  return context.turn_model ?? context.collaboration_model ?? context.session_model;
+}
+
+function codexGitBranch(payload: Record<string, unknown>): string | undefined {
+  const direct =
+    boundedString(payload.gitBranch, MAX_PATH_BYTES) ??
+    boundedString(payload.git_branch, MAX_PATH_BYTES);
+  if (direct) return direct;
+  const git = payload.git;
+  return git && typeof git === "object" && !Array.isArray(git)
+    ? boundedString((git as Record<string, unknown>).branch, MAX_PATH_BYTES)
+    : undefined;
+}
+
+function collaborationModel(
+  payload: Record<string, unknown>,
+): string | undefined {
+  const settings = payload.settings;
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+    return undefined;
+  }
+  return boundedString((settings as Record<string, unknown>).model, MAX_MODEL_BYTES);
+}
+
+function stableCodexEventId(
+  rolloutIdentity: string,
+  startOffset: number,
+  endOffset: number,
+): string {
+  const offsets = Buffer.alloc(16);
+  offsets.writeBigUInt64BE(BigInt(startOffset), 0);
+  offsets.writeBigUInt64BE(BigInt(endOffset), 8);
+  return "codex-" + createHash("sha256")
+    .update(rolloutIdentity)
+    .update(Buffer.from([0]))
+    .update(offsets)
+    .digest("hex");
+}
+
+/** Adapt a Codex rollout record to the Claude-shaped sanitizer input. */
+function codexUsageRow(
+  row: unknown,
+  context: CodexUsageContext,
+  rolloutIdentity: string,
+  startOffset: number,
+  endOffset: number,
+): Record<string, unknown> | null {
+  if (!row || typeof row !== "object" || Array.isArray(row)) return null;
+  const obj = row as Record<string, unknown>;
+  const kind = obj.type;
+  const rawPayload = obj.payload;
+  const payload =
+    rawPayload && typeof rawPayload === "object" && !Array.isArray(rawPayload)
+      ? (rawPayload as Record<string, unknown>)
+      : undefined;
+
+  if (kind === "session_meta") {
+    if (!payload) return null;
+    context.session_id = boundedString(payload.id, MAX_ID_BYTES) ?? context.session_id;
+    context.cwd = boundedString(payload.cwd, MAX_PATH_BYTES);
+    context.git_branch = codexGitBranch(payload);
+    context.session_model = boundedString(payload.model, MAX_MODEL_BYTES);
+    return null;
+  }
+  if (kind === "turn_context") {
+    context.turn_model = payload
+      ? boundedString(payload.model, MAX_MODEL_BYTES)
+      : undefined;
+    const mode = payload?.collaboration_mode;
+    if (mode && typeof mode === "object" && !Array.isArray(mode)) {
+      const model = collaborationModel(mode as Record<string, unknown>);
+      if (model) context.collaboration_model = model;
+    }
+    return null;
+  }
+  if (kind === "collaboration_mode") {
+    context.collaboration_model = payload
+      ? collaborationModel(payload)
+      : undefined;
+    return null;
+  }
+  if (kind !== "event_msg" || !payload) return null;
+  if (payload.type === "collaboration_mode") {
+    context.collaboration_model = collaborationModel(payload);
+    return null;
+  }
+  if (payload.type !== "token_count") return null;
+
+  const info = payload.info;
+  if (!info || typeof info !== "object" || Array.isArray(info)) return null;
+  const last = (info as Record<string, unknown>).last_token_usage;
+  if (!last || typeof last !== "object" || Array.isArray(last)) return null;
+  const usage = last as Record<string, unknown>;
+  const outputTokens =
+    tokenCount(usage.output_tokens) + tokenCount(usage.reasoning_output_tokens);
+  const model = codexModel(context);
+  const normalized: Record<string, unknown> = {
+    uuid:
+      boundedString(obj.uuid, MAX_ID_BYTES) ??
+      stableCodexEventId(rolloutIdentity, startOffset, endOffset),
+    message: {
+      usage: {
+        input_tokens: tokenCount(usage.input_tokens),
+        output_tokens: outputTokens,
+        ...(typeof usage.cached_input_tokens === "number"
+          ? { cache_read_input_tokens: tokenCount(usage.cached_input_tokens) }
+          : {}),
+      },
+      ...(model ? { model } : {}),
+    },
+  };
+  if (context.session_id) normalized.sessionId = context.session_id;
+  const timestamp = boundedString(obj.timestamp, MAX_TIMESTAMP_BYTES);
+  if (timestamp) normalized.timestamp = timestamp;
+  if (context.cwd) normalized.cwd = context.cwd;
+  if (context.git_branch) normalized.gitBranch = context.git_branch;
+  return normalized;
+}
+
+async function sortFilesFreshestFirst(files: string[]): Promise<string[]> {
+  const ranked = await Promise.all(
+    files.map(async (filePath) => {
+      try {
+        return { filePath, mtime: (await fs.stat(filePath)).mtimeMs };
+      } catch {
+        return { filePath, mtime: 0 };
+      }
+    }),
+  );
+  ranked.sort(
+    (left, right) =>
+      right.mtime - left.mtime || left.filePath.localeCompare(right.filePath),
+  );
+  return ranked.map(({ filePath }) => filePath);
+}
+
+async function listCodexRolloutFiles(codexRoot: string): Promise<string[]> {
+  const [live, archived] = await Promise.all([
+    listJsonlFiles(path.join(codexRoot, "sessions")),
+    listJsonlFiles(path.join(codexRoot, "archived_sessions")),
+  ]);
+  return sortFilesFreshestFirst(
+    [...live, ...archived].filter((file) =>
+      path.basename(file).startsWith("rollout-"),
+    ),
+  );
+}
+
 // ── Batching primitives ───────────────────────────────────────────────────────
 
 const MAX_BATCH_EVENTS = 100;
 const MAX_BATCH_BYTES = 240 * 1024;
+const MAX_SCAN_BYTES_PER_SOURCE = 4 * 1024 * 1024;
+const MAX_BATCHES_PER_RUN = 4;
+const MAX_PARTIAL_LINE_BYTES = 64 * 1024;
 const ROW_TRUNCATION_SUFFIX = "...[truncated]";
 
 interface RowSource {
   filePath: string;
   endOffset: number;
   mtime: number;
+  context?: CodexUsageContext;
 }
 
 /**
@@ -455,7 +661,7 @@ function boundRowForPost(
 // ── Main entry point ──────────────────────────────────────────────────────────
 
 /**
- * Scan, sanitize, and POST any new Claude Code session rows.
+ * Scan, sanitize, and POST new Claude Code and Codex usage rows.
  *
  * Fire-and-forget from the caller's perspective: errors are caught internally
  * and surfaced only via `log`. The returned summary lets observers (e.g.
@@ -467,9 +673,13 @@ export async function collectAndSendTelemetry(
 ): Promise<CollectTelemetryResult> {
   const home = os.homedir();
   const claudeProjectsRoot = opts.claudeProjectsRoot ?? path.join(home, ".claude", "projects");
+  const codexRoot = opts.codexRoot ?? path.join(home, ".codex");
   const cursorPath = opts.cursorPath ?? path.join(home, ".hq", "telemetry-cursor.json");
   const menubarPath = opts.menubarPath ?? path.join(home, ".hq", "menubar.json");
   const log = opts.log ?? (() => {});
+  const maxScanBytesPerSource =
+    opts.maxScanBytesPerSource ?? MAX_SCAN_BYTES_PER_SOURCE;
+  const maxBatchesPerRun = opts.maxBatchesPerRun ?? MAX_BATCHES_PER_RUN;
 
   // Company attribution (US-002): parse the manifest ONCE per run and reuse the
   // repo-path→companyUid map for every event below. No per-event manifest read.
@@ -565,7 +775,17 @@ export async function collectAndSendTelemetry(
   const rotationResets: Record<string, CursorEntry> = {};
   const newlyCommitted: Record<string, CursorEntry> = {};
 
-  const files = await listJsonlFiles(claudeProjectsRoot);
+  const [claudeFilesUnsorted, codexFiles] = await Promise.all([
+    listJsonlFiles(claudeProjectsRoot),
+    listCodexRolloutFiles(codexRoot),
+  ]);
+  const claudeFiles = await sortFilesFreshestFirst(claudeFilesUnsorted);
+  // Codex goes first so a fresh Linux install cannot spend its entire bounded
+  // pass replaying an older Claude backlog before reporting current Codex use.
+  const files: Array<{ filePath: string; kind: "claude" | "codex" }> = [
+    ...codexFiles.map((filePath) => ({ filePath, kind: "codex" as const })),
+    ...claudeFiles.map((filePath) => ({ filePath, kind: "claude" as const })),
+  ];
 
   // 3. Walk each file, sanitize new rows, batch, flush at the server contract.
   //
@@ -581,15 +801,45 @@ export async function collectAndSendTelemetry(
   let batchBytes = ENVELOPE_BYTES;
   let eventsSent = 0;
   let batchesSent = 0;
+  let uploadFailed = false;
+  let batchLimitReached = false;
+  const scannedBytes = { claude: 0, codex: 0 };
 
-  const flush = async (): Promise<void> => {
-    if (batchEvents.length === 0) return;
+  const commitSources = (sources: RowSource[]): void => {
+    const maxPerFile = new Map<
+      string,
+      { mtime: number; offset: number; context?: CodexUsageContext }
+    >();
+    for (const source of sources) {
+      const current = maxPerFile.get(source.filePath);
+      if (!current || source.endOffset > current.offset) {
+        maxPerFile.set(source.filePath, {
+          mtime: source.mtime,
+          offset: source.endOffset,
+          ...(source.context
+            ? { context: cloneCodexContext(source.context) }
+            : {}),
+        });
+      }
+    }
+    for (const [filePath, entry] of maxPerFile) {
+      const current = newlyCommitted[filePath];
+      if (!current || entry.offset > current.offset) {
+        newlyCommitted[filePath] = entry;
+      }
+    }
+  };
+
+  const flush = async (): Promise<boolean> => {
     const events = batchEvents;
     const sources = batchSources;
     batchEvents = [];
     batchSources = [];
     batchBytes = ENVELOPE_BYTES;
-
+    if (events.length === 0) {
+      commitSources(sources);
+      return true;
+    }
     try {
       await opts.client.postUsage({
         machineId: opts.machineId,
@@ -598,24 +848,26 @@ export async function collectAndSendTelemetry(
       });
       batchesSent++;
       eventsSent += events.length;
-      // Advance cursor to max(endOffset) per file in this batch.
-      const maxPerFile = new Map<string, { mtime: number; offset: number }>();
-      for (const src of sources) {
-        const cur = maxPerFile.get(src.filePath);
-        if (!cur || src.endOffset > cur.offset) {
-          maxPerFile.set(src.filePath, { mtime: src.mtime, offset: src.endOffset });
-        }
-      }
-      for (const [fp, entry] of maxPerFile) {
-        newlyCommitted[fp] = { offset: entry.offset, mtime: entry.mtime };
-      }
+      commitSources(sources);
+      return true;
     } catch (err) {
-      log(`[telemetry] postUsage failed (${(err as Error).message ?? err}) — cursor not advanced for ${sources.length} rows`);
-      // Cursor intentionally left un-advanced — next sync retries.
+      log(
+        "[telemetry] postUsage failed (" +
+          ((err as Error).message ?? err) +
+          ") — cursor not advanced for " +
+          sources.length +
+          " rows",
+      );
+      return false;
     }
   };
 
-  for (const filePath of files) {
+  filesLoop: for (const { filePath, kind } of files) {
+    if (uploadFailed || batchLimitReached) break;
+    const sourceBudgetRemaining =
+      maxScanBytesPerSource - scannedBytes[kind];
+    if (sourceBudgetRemaining <= 0) continue;
+
     let stat;
     try {
       stat = await fs.stat(filePath);
@@ -624,116 +876,216 @@ export async function collectAndSendTelemetry(
     }
     const currentSize = stat.size;
     const currentMtime = Math.floor(stat.mtimeMs / 1000);
-
     const stored = cursor.files[filePath] ?? { offset: 0, mtime: 0 };
     let offset = stored.offset;
-
+    let codexContext: CodexUsageContext | undefined =
+      kind === "codex" ? cloneCodexContext(stored.context ?? {}) : undefined;
     const rotated =
       currentSize < offset || (stored.mtime > 0 && currentMtime < stored.mtime);
     if (rotated) {
       offset = 0;
+      if (kind === "codex") codexContext = {};
       rotationResets[filePath] = { offset: 0, mtime: currentMtime };
     }
-
     if (offset >= currentSize && !rotated) continue;
 
     let content: string;
+    let bytesRead = 0;
+    let readBuffer = Buffer.alloc(0);
     try {
-      const fh = await fs.open(filePath, "r");
+      const fileHandle = await fs.open(filePath, "r");
       try {
-        const length = Math.max(0, currentSize - offset);
-        const buf = Buffer.alloc(length);
-        await fh.read(buf, 0, length, offset);
-        content = buf.toString("utf-8");
+        const length = Math.max(
+          0,
+          Math.min(currentSize - offset, sourceBudgetRemaining),
+        );
+        readBuffer = Buffer.alloc(length);
+        ({ bytesRead } = await fileHandle.read(
+          readBuffer,
+          0,
+          length,
+          offset,
+        ));
+        content = readBuffer.toString("utf-8", 0, bytesRead);
       } finally {
-        await fh.close();
+        await fileHandle.close();
       }
     } catch {
       continue;
     }
-    if (content.length === 0) continue;
+    if (bytesRead === 0) continue;
+
+    // Resume a previously discarded oversized Codex row using raw byte
+    // positions. Decoding from the middle of a multibyte UTF-8 codepoint would
+    // otherwise skew byte offsets and could skip or replay later rows.
+    if (codexContext?.discarding_partial_line) {
+      const newlineIndex = readBuffer.subarray(0, bytesRead).indexOf(0x0a);
+      const discardedBytes = newlineIndex >= 0 ? newlineIndex + 1 : bytesRead;
+      codexContext.discarding_partial_line = newlineIndex < 0;
+      scannedBytes[kind] += discardedBytes;
+      batchSources.push({
+        filePath,
+        endOffset: offset + discardedBytes,
+        mtime: currentMtime,
+        context: cloneCodexContext(codexContext),
+      });
+      if (newlineIndex < 0) continue;
+      offset += discardedBytes;
+      bytesRead -= discardedBytes;
+      readBuffer = readBuffer.subarray(discardedBytes);
+      content = readBuffer.toString("utf-8", 0, bytesRead);
+      if (bytesRead === 0) continue;
+    }
 
+    const reachedPhysicalEof = offset + bytesRead >= currentSize;
     const segments = content.split("\n");
     const lineEndOffsets: number[] = [];
     let cumulative = 0;
     for (let i = 0; i < segments.length; i++) {
       cumulative += Buffer.byteLength(segments[i], "utf-8");
-      if (i < segments.length - 1) cumulative += 1; // newline byte
+      if (i < segments.length - 1) cumulative += 1;
       lineEndOffsets.push(offset + cumulative);
     }
 
     for (let i = 0; i < segments.length; i++) {
+      const startOffset = i === 0 ? offset : lineEndOffsets[i - 1];
+      const hasNewline = i < segments.length - 1;
+      const endOffset =
+        !hasNewline && !reachedPhysicalEof
+          ? offset + bytesRead
+          : lineEndOffsets[i];
+      const lineBytes = endOffset - startOffset;
+      if (!hasNewline && !reachedPhysicalEof) {
+        const discarding = codexContext?.discarding_partial_line === true;
+        if (discarding || lineBytes >= MAX_PARTIAL_LINE_BYTES) {
+          if (codexContext) codexContext.discarding_partial_line = true;
+          scannedBytes[kind] += lineBytes;
+          batchSources.push({
+            filePath,
+            endOffset,
+            mtime: currentMtime,
+            ...(codexContext
+              ? { context: cloneCodexContext(codexContext) }
+              : {}),
+          });
+        }
+        break;
+      }
+
+      scannedBytes[kind] += lineBytes;
+      const source = (): RowSource => ({
+        filePath,
+        endOffset,
+        mtime: currentMtime,
+        ...(codexContext
+          ? { context: cloneCodexContext(codexContext) }
+          : {}),
+      });
+      if (codexContext?.discarding_partial_line) {
+        codexContext.discarding_partial_line = false;
+        batchSources.push(source());
+        continue;
+      }
       const trimmed = segments[i].trim();
-      if (trimmed.length === 0) continue;
+      if (trimmed.length === 0) {
+        batchSources.push(source());
+        continue;
+      }
       let parsed: unknown;
       try {
         parsed = JSON.parse(trimmed);
       } catch {
+        batchSources.push(source());
         continue;
       }
-      // Resolve this row's cwd → owning company (cmp_* uid) before sanitizing,
-      // using the per-run map. Unresolved → undefined → companyUid omitted.
+      const sourceRow =
+        kind === "codex"
+          ? codexUsageRow(
+              parsed,
+              codexContext!,
+              filePath,
+              startOffset,
+              endOffset,
+            )
+          : parsed;
       const rowCwd =
-        parsed && typeof parsed === "object" && !Array.isArray(parsed)
-          ? (parsed as Record<string, unknown>).cwd
+        sourceRow && typeof sourceRow === "object" && !Array.isArray(sourceRow)
+          ? (sourceRow as Record<string, unknown>).cwd
           : undefined;
       const companyUid = resolveCompanyForCwd(
         typeof rowCwd === "string" ? rowCwd : undefined,
         repoCompanyMap,
       );
-      const sanitized = sanitizeRow(parsed, companyUid);
-      if (!sanitized) continue;
+      const sanitized = sanitizeRow(sourceRow, companyUid);
+      if (!sanitized) {
+        batchSources.push(source());
+        continue;
+      }
+
       const maxRowBytes = MAX_BATCH_BYTES - ENVELOPE_BYTES;
       const wasOversized = jsonBytes(sanitized) > maxRowBytes;
       const bounded = boundRowForPost(sanitized, maxRowBytes);
       if (!bounded) {
         log(
-          `[telemetry] oversized row dropped before send (${filePath}:${i + 1})`,
+          "[telemetry] oversized row dropped before send (" +
+            filePath +
+            ":" +
+            (i + 1) +
+            ")",
         );
+        batchSources.push(source());
         continue;
       }
       if (wasOversized) {
         log(
-          `[telemetry] oversized row truncated before send (${filePath}:${i + 1})`,
+          "[telemetry] oversized row truncated before send (" +
+            filePath +
+            ":" +
+            (i + 1) +
+            ")",
         );
       }
 
-      // Cost of appending this row to the current batch: the row's JSON
-      // length plus 1 byte for the leading comma when there's already at
-      // least one row. (No comma when the batch is empty — the row sits
-      // alone inside the events array.)
-      const rowJsonBytes = Buffer.byteLength(JSON.stringify(bounded), "utf-8");
+      const rowJsonBytes = jsonBytes(bounded);
       const addCost = rowJsonBytes + (batchEvents.length > 0 ? 1 : 0);
-
       if (
         batchEvents.length > 0 &&
         (batchEvents.length >= MAX_BATCH_EVENTS ||
           batchBytes + addCost > MAX_BATCH_BYTES)
       ) {
-        await flush();
-        // After flush, batchEvents is empty → no comma needed for the first row.
+        if (!(await flush())) {
+          uploadFailed = true;
+          break filesLoop;
+        }
+        if (batchesSent >= maxBatchesPerRun) {
+          batchLimitReached = true;
+          break filesLoop;
+        }
         batchBytes = ENVELOPE_BYTES + rowJsonBytes;
       } else {
         batchBytes += addCost;
       }
-
       batchEvents.push(bounded);
-      batchSources.push({
-        filePath,
-        endOffset: lineEndOffsets[i],
-        mtime: currentMtime,
-      });
+      batchSources.push(source());
     }
   }
 
-  await flush();
+  if (!uploadFailed && !batchLimitReached) {
+    uploadFailed = !(await flush());
+  }
 
   // 4. Persist cursor: loaded < rotation_resets < newly_committed.
   const finalFiles: Record<string, CursorEntry> = { ...loadedFiles };
   for (const [fp, entry] of Object.entries(rotationResets)) finalFiles[fp] = entry;
   for (const [fp, entry] of Object.entries(newlyCommitted)) finalFiles[fp] = entry;
 
-  await saveCursor(cursorPath, { version: "1", files: finalFiles });
+  await saveCursor(cursorPath, {
+    version: "1",
+    files: finalFiles,
+    ...(cursor.codex_next_rollout
+      ? { codex_next_rollout: cursor.codex_next_rollout }
+      : {}),
+  });
 
   return {
     enabled: true,