@indigoai-us/hq-cloud 6.14.29 → 6.14.31

package/dist/telemetry.d.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`.
  *
@@ -58,6 +57,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. */
@@ -124,7 +129,7 @@ export declare function extractServices(message: unknown): Record<string, number
  */
 export declare function sanitizeRow(row: unknown, companyUid?: string): Record<string, unknown> | null;
 /**
- * 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.

package/dist/telemetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAWH,OAAO,KAAK,EACV,sBAAsB,EACtB,UAAU,EACV,iBAAiB,EAClB,MAAM,mBAAmB,CAAC;AAI3B;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,iBAAiB,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACrD,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACzD;;;OAGG;IACH,iBAAiB,CAAC,CAChB,OAAO,EAAE,OAAO,EAChB,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/B,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,oJAAoJ;IACpJ,SAAS,EAAE,MAAM,CAAC;IAClB,+HAA+H;IAC/H,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACrC,gIAAgI;IAChI,OAAO,EAAE,OAAO,CAAC;IACjB,wFAAwF;IACxF,WAAW,EAAE,QAAQ,GAAG,kBAAkB,GAAG,oBAAoB,GAAG,SAAS,CAAC;IAC9E,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IACrB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,EAAE,MAAM,CAAC;CACrB;AAsID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,OAAO,GACf,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAyBpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,EACZ,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CA4ChC;AA0GD;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,sBAAsB,CAAC,CAsRjC"}
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAYH,OAAO,KAAK,EACV,sBAAsB,EACtB,UAAU,EACV,iBAAiB,EAClB,MAAM,mBAAmB,CAAC;AAI3B;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,iBAAiB,IAAI,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACrD,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACzD;;;OAGG;IACH,iBAAiB,CAAC,CAChB,OAAO,EAAE,OAAO,EAChB,IAAI,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/B,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,oJAAoJ;IACpJ,SAAS,EAAE,MAAM,CAAC;IAClB,+HAA+H;IAC/H,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,oEAAoE;IACpE,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,sBAAsB;IACrC,gIAAgI;IAChI,OAAO,EAAE,OAAO,CAAC;IACjB,wFAAwF;IACxF,WAAW,EAAE,QAAQ,GAAG,kBAAkB,GAAG,oBAAoB,GAAG,SAAS,CAAC;IAC9E,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IACrB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,EAAE,MAAM,CAAC;CACrB;AA0JD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,OAAO,GACf,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAyBpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,OAAO,EACZ,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CA4ChC;AA8RD;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,sBAAsB,CAAC,CAwajC"}

package/dist/telemetry.js

@@ -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`.
  *
@@ -22,6 +21,7 @@
  * sync. The cursor is only advanced for batches the server 2xx'd, so a
  * 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";
@@ -34,7 +34,13 @@ async function loadCursor(cursorPath) {
         const raw = await fs.readFile(cursorPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed && typeof parsed === "object" && parsed.files && typeof parsed.files === "object") {
-            return { version: parsed.version ?? "1", files: parsed.files };
+            return {
+                version: parsed.version ?? "1",
+                files: parsed.files,
+                ...(typeof parsed.codex_next_rollout === "string"
+                    ? { codex_next_rollout: parsed.codex_next_rollout }
+                    : {}),
+            };
         }
     }
     catch {
@@ -274,9 +280,162 @@ async function listJsonlFiles(root) {
     await walk(root);
     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, maxBytes) {
+    return typeof value === "string" &&
+        value.length > 0 &&
+        Buffer.byteLength(value, "utf-8") <= maxBytes
+        ? value
+        : undefined;
+}
+function tokenCount(value) {
+    return typeof value === "number" &&
+        Number.isSafeInteger(value) &&
+        value >= 0
+        ? value
+        : 0;
+}
+function cloneCodexContext(context) {
+    return { ...context };
+}
+function codexModel(context) {
+    return context.turn_model ?? context.collaboration_model ?? context.session_model;
+}
+function codexGitBranch(payload) {
+    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.branch, MAX_PATH_BYTES)
+        : undefined;
+}
+function collaborationModel(payload) {
+    const settings = payload.settings;
+    if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+        return undefined;
+    }
+    return boundedString(settings.model, MAX_MODEL_BYTES);
+}
+function stableCodexEventId(rolloutIdentity, startOffset, endOffset) {
+    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, context, rolloutIdentity, startOffset, endOffset) {
+    if (!row || typeof row !== "object" || Array.isArray(row))
+        return null;
+    const obj = row;
+    const kind = obj.type;
+    const rawPayload = obj.payload;
+    const payload = rawPayload && typeof rawPayload === "object" && !Array.isArray(rawPayload)
+        ? rawPayload
+        : 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);
+            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.last_token_usage;
+    if (!last || typeof last !== "object" || Array.isArray(last))
+        return null;
+    const usage = last;
+    const outputTokens = tokenCount(usage.output_tokens) + tokenCount(usage.reasoning_output_tokens);
+    const model = codexModel(context);
+    const normalized = {
+        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) {
+    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) {
+    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]";
 /**
  * Byte cost of the fixed wire-payload skeleton:
@@ -335,7 +494,7 @@ function boundRowForPost(row, maxRowBytes) {
 }
 // ── 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.
@@ -345,9 +504,12 @@ function boundRowForPost(row, maxRowBytes) {
 export async function collectAndSendTelemetry(opts) {
     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.
     // When `hqRoot` is omitted the map is empty → every event stays unattributed.
@@ -431,7 +593,17 @@ export async function collectAndSendTelemetry(opts) {
     const loadedFiles = { ...cursor.files };
     const rotationResets = {};
     const newlyCommitted = {};
-    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 = [
+        ...codexFiles.map((filePath) => ({ filePath, kind: "codex" })),
+        ...claudeFiles.map((filePath) => ({ filePath, kind: "claude" })),
+    ];
     // 3. Walk each file, sanitize new rows, batch, flush at the server contract.
     //
     // Byte accounting is incremental: we track `batchBytes` as the projected
@@ -446,14 +618,40 @@ export async function collectAndSendTelemetry(opts) {
     let batchBytes = ENVELOPE_BYTES;
     let eventsSent = 0;
     let batchesSent = 0;
+    let uploadFailed = false;
+    let batchLimitReached = false;
+    const scannedBytes = { claude: 0, codex: 0 };
+    const commitSources = (sources) => {
+        const maxPerFile = new Map();
+        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 () => {
-        if (batchEvents.length === 0)
-            return;
         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,
@@ -462,24 +660,24 @@ export async function collectAndSendTelemetry(opts) {
             });
             batchesSent++;
             eventsSent += events.length;
-            // Advance cursor to max(endOffset) per file in this batch.
-            const maxPerFile = new Map();
-            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.message ?? err}) — cursor not advanced for ${sources.length} rows`);
-            // Cursor intentionally left un-advanced — next sync retries.
+            log("[telemetry] postUsage failed (" +
+                (err.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);
@@ -491,102 +689,189 @@ export async function collectAndSendTelemetry(opts) {
         const currentMtime = Math.floor(stat.mtimeMs / 1000);
         const stored = cursor.files[filePath] ?? { offset: 0, mtime: 0 };
         let offset = stored.offset;
+        let codexContext = 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;
+        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)
+        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 = [];
         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
+                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 = () => ({
+                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)
+            if (trimmed.length === 0) {
+                batchSources.push(source());
                 continue;
+            }
             let parsed;
             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 rowCwd = parsed && typeof parsed === "object" && !Array.isArray(parsed)
-                ? parsed.cwd
+            const sourceRow = kind === "codex"
+                ? codexUsageRow(parsed, codexContext, filePath, startOffset, endOffset)
+                : parsed;
+            const rowCwd = sourceRow && typeof sourceRow === "object" && !Array.isArray(sourceRow)
+                ? sourceRow.cwd
                 : undefined;
             const companyUid = resolveCompanyForCwd(typeof rowCwd === "string" ? rowCwd : undefined, repoCompanyMap);
-            const sanitized = sanitizeRow(parsed, companyUid);
-            if (!sanitized)
+            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})`);
+                log("[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})`);
+                log("[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 = { ...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,
         optInSource,