@indigoai-us/hq-cloud 6.14.39 → 6.14.40

package/src/skill-telemetry.ts

@@ -106,6 +106,12 @@ export interface CollectSkillTelemetryOptions {
   cursorPath?: string;
   /** Override `~/.hq/menubar.json` (the offline opt-in fallback) for tests. */
   menubarPath?: string;
+  /**
+   * Maximum transcript bytes to inspect per source (Claude or Codex) in one
+   * collection pass. The next pass resumes from the last complete line.
+   * Override for deterministic bounded-scan tests.
+   */
+  maxScanBytesPerSource?: number;
   /**
    * Override skillVersion resolution (skills-first-class US-015). Given a skill
    * name, return its content-hash version marker (`sha256:<hex>`) or undefined.
@@ -156,14 +162,78 @@ const INCLUDE_ARGS_PREVIEW = false;
 
 // ── Cursor schema (independent from the token collector's) ──────────────────────
 
+type SkillTelemetrySource = "claude" | "codex";
+
+interface PendingLineCursor {
+  /** Offset of the unterminated JSONL record's first byte. */
+  start: number;
+  /** Furthest byte inspected for that record; no transcript bytes are stored. */
+  scannedOffset: number;
+}
+
+interface CodexCursorState {
+  /** Latest turn context, needed by function_call rows after a bounded resume. */
+  turnId?: string;
+  /** Dedupe keys from the active turn, so repeated skill reads stay collapsed. */
+  seen?: string[];
+}
+
 interface CursorEntry {
   offset: number;
   mtime: number;
+  pendingLine?: PendingLineCursor;
+  codex?: CodexCursorState;
 }
 
 interface SkillCursor {
   version: string;
   files: Record<string, CursorEntry>;
+  /** Rotate each runtime's file order so one growing backlog cannot starve peers. */
+  lastScannedBySource?: Partial<Record<SkillTelemetrySource, string>>;
+}
+
+function clonePendingLine(value: unknown): PendingLineCursor | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const pending = value as Partial<PendingLineCursor>;
+  const { start, scannedOffset } = pending;
+  if (
+    typeof start !== "number" ||
+    typeof scannedOffset !== "number" ||
+    !Number.isSafeInteger(start) ||
+    !Number.isSafeInteger(scannedOffset) ||
+    start < 0 ||
+    scannedOffset < start
+  ) {
+    return undefined;
+  }
+  return { start, scannedOffset };
+}
+
+function cloneCodexCursorState(value: unknown): CodexCursorState | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const state = value as Partial<CodexCursorState>;
+  const turnId = typeof state.turnId === "string" ? state.turnId : undefined;
+  const seen = Array.isArray(state.seen)
+    ? state.seen.filter((entry): entry is string => typeof entry === "string")
+    : [];
+  return turnId === undefined && seen.length === 0 ? undefined : { turnId, seen };
+}
+
+function snapshotCodexCursorState(
+  turnId: string | undefined,
+  seen: Set<string> | undefined,
+): CodexCursorState | undefined {
+  if (turnId === undefined && (seen === undefined || seen.size === 0)) return undefined;
+  return { turnId, ...(seen && seen.size > 0 ? { seen: [...seen] } : {}) };
+}
+
+function rotateFilesFromLast(
+  files: string[],
+  lastScanned: string | undefined,
+): string[] {
+  if (!lastScanned) return files;
+  const index = files.indexOf(lastScanned);
+  return index < 0 ? files : [...files.slice(index + 1), ...files.slice(0, index + 1)];
 }
 
 async function loadCursor(cursorPath: string): Promise<SkillCursor> {
@@ -171,7 +241,17 @@ async function loadCursor(cursorPath: string): Promise<SkillCursor> {
     const raw = await fs.readFile(cursorPath, "utf-8");
     const parsed = JSON.parse(raw) as Partial<SkillCursor>;
     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>,
+        ...(parsed.lastScannedBySource && typeof parsed.lastScannedBySource === "object"
+          ? {
+              lastScannedBySource: parsed.lastScannedBySource as Partial<
+                Record<SkillTelemetrySource, string>
+              >,
+            }
+          : {}),
+      };
     }
   } catch {
     // Missing / unparseable — start fresh.
@@ -718,7 +798,7 @@ async function listJsonlFiles(root: string): Promise<string[]> {
     }
   }
   await walk(root);
-  return out;
+  return out.sort((a, b) => a.localeCompare(b));
 }
 
 // Codex's `session_meta` is always the first, small line of a rollout. Read a
@@ -737,6 +817,18 @@ const CODEX_META_PREFIX_BYTES = 64 * 1024;
  */
 const MAX_FS_READ_CHUNK_BYTES = 256 * 1024 * 1024;
 
+/**
+ * A sync pass must never turn an unbounded transcript tail into one V8 string.
+ * Node aborts the process once Buffer#toString receives a length >= 2**31; this
+ * conservative cap is also below the smaller practical string ceilings across
+ * supported Node versions. Keep this assertion close to the call site so a
+ * future increase cannot reintroduce the native SIGTRAP failure.
+ */
+export const MAX_DECODE_BYTES = 256 * 1024 * 1024;
+if (MAX_DECODE_BYTES >= 2 ** 31) {
+  throw new Error("MAX_DECODE_BYTES must remain below the V8 string length limit");
+}
+
 /** Minimal structural view of the `FileHandle.read` we depend on. */
 type ReadableFileHandle = {
   read(
@@ -796,6 +888,7 @@ async function readCodexSessionContext(
 
 const MAX_BATCH_EVENTS = 100;
 const MAX_BATCH_BYTES = 240 * 1024;
+const MAX_SCAN_BYTES_PER_SOURCE = 4 * 1024 * 1024;
 const ROW_TRUNCATION_SUFFIX = "...[truncated]";
 
 function jsonBytes(value: unknown): number {
@@ -847,11 +940,13 @@ function boundRowForPost(
  * Scan, extract, and POST any new skill-invocation events.
  *
  * Cursor model (per-batch commit, matching the token collector for robustness):
- * each file is scanned from its stored byte offset to EOF; extracted events
- * carry the byte offset of the line they came from. Events are flushed in
- * server-sized batches, and the cursor advances **per successful batch** — so if one
- * batch in a large (e.g. first-run backfill) fails, the batches that already
- * succeeded stay committed and only the rest re-send next sync.
+ * each file is scanned from its stored byte offset through a bounded region;
+ * extracted events carry the byte offset of the line they came from. Events are
+ * flushed in server-sized batches, and the cursor advances **per successful
+ * batch** — so if one batch in a large (e.g. first-run backfill) fails, the
+ * batches that already succeeded stay committed and only the rest re-send next
+ * sync. A bounded region settles only at a complete-line boundary, preventing
+ * a cursor from skipping an unread tail or resuming mid-line.
  *
  * Per-file commit rule:
  *   - All of a file's events sent OK (including zero-event files) → commit EOF,
@@ -873,6 +968,12 @@ export async function collectAndSendSkillTelemetry(
     opts.cursorPath ?? path.join(home, ".hq", "skill-telemetry-cursor.json");
   const menubarPath = opts.menubarPath ?? path.join(home, ".hq", "menubar.json");
   const log = opts.log ?? (() => {});
+  // Match the usage collector's per-runtime budget, with an independent hard
+  // decode ceiling as defence in depth for future callers/configuration.
+  const maxScanBytesPerSource = Math.min(
+    opts.maxScanBytesPerSource ?? MAX_SCAN_BYTES_PER_SOURCE,
+    MAX_DECODE_BYTES,
+  );
 
   // Normalize the scope path once (drop a single trailing slash, keeping "/").
   const normalizePath = (p: string): string => (p.length > 1 ? p.replace(/\/+$/, "") : p);
@@ -928,9 +1029,15 @@ export async function collectAndSendSkillTelemetry(
   const cursor = await loadCursor(cursorPath);
   const claudeFiles = await listJsonlFiles(claudeProjectsRoot);
   const codexFiles = await listJsonlFiles(codexSessionsRoot);
-  const files: { filePath: string; kind: "claude" | "codex" }[] = [
-    ...claudeFiles.map((f) => ({ filePath: f, kind: "claude" as const })),
-    ...codexFiles.map((f) => ({ filePath: f, kind: "codex" as const })),
+  const files: { filePath: string; kind: SkillTelemetrySource }[] = [
+    ...rotateFilesFromLast(
+      claudeFiles,
+      cursor.lastScannedBySource?.claude,
+    ).map((f) => ({ filePath: f, kind: "claude" as const })),
+    ...rotateFilesFromLast(
+      codexFiles,
+      cursor.lastScannedBySource?.codex,
+    ).map((f) => ({ filePath: f, kind: "codex" as const })),
   ];
 
   // 3. Scan every file from its stored offset, collecting events tagged with
@@ -939,15 +1046,22 @@ export async function collectAndSendSkillTelemetry(
     eof: number;
     mtime: number;
     eventCount: number; // events extracted from this file this run
+    pendingLine?: PendingLineCursor;
+    codex?: CodexCursorState;
   }
   interface Sourced {
     row: Record<string, unknown>;
     filePath: string;
     endOffset: number; // absolute byte offset at the end of the source line
+    codex?: CodexCursorState;
   }
 
   const fileScans: Record<string, FileScan> = {};
   const rotationResets: Record<string, CursorEntry> = {};
+  const scannedBytes: Record<SkillTelemetrySource, number> = { claude: 0, codex: 0 };
+  const lastScannedBySource: Partial<Record<SkillTelemetrySource, string>> = {
+    ...cursor.lastScannedBySource,
+  };
   const sourced: Sourced[] = [];
   const envelopeBytes = Buffer.byteLength(
     JSON.stringify({ machineId: opts.machineId, installerVersion: opts.installerVersion, events: [] }),
@@ -956,6 +1070,9 @@ export async function collectAndSendSkillTelemetry(
   const maxRowBytes = MAX_BATCH_BYTES - envelopeBytes;
 
   for (const { filePath, kind } of files) {
+    const sourceBudgetRemaining = maxScanBytesPerSource - scannedBytes[kind];
+    if (sourceBudgetRemaining <= 0) continue;
+
     let stat;
     try {
       stat = await fs.stat(filePath);
@@ -967,32 +1084,57 @@ export async function collectAndSendSkillTelemetry(
 
     const stored = cursor.files[filePath] ?? { offset: 0, mtime: 0 };
     let offset = stored.offset;
+    let pendingLine = clonePendingLine(stored.pendingLine);
+    let codexCursor = kind === "codex" ? cloneCodexCursorState(stored.codex) : undefined;
 
     // Rotation / truncation → re-read from the top.
     const rotated =
       currentSize < offset || (stored.mtime > 0 && currentMtime < stored.mtime);
     if (rotated) {
       offset = 0;
+      pendingLine = undefined;
+      codexCursor = undefined;
       rotationResets[filePath] = { offset: 0, mtime: currentMtime };
     }
+    // A malformed/stale pending continuation is never allowed to move the
+    // durable complete-line cursor. Start scanning fresh from that cursor.
+    if (
+      pendingLine &&
+      (pendingLine.start !== offset || pendingLine.scannedOffset > currentSize)
+    ) {
+      pendingLine = undefined;
+    }
+    const scanOffset = pendingLine?.scannedOffset ?? offset;
 
     // Record the scan even when there are no new bytes — a fully-drained file
     // (eventCount 0, offset already at EOF) should still settle at EOF below.
-    fileScans[filePath] = { eof: currentSize, mtime: currentMtime, eventCount: 0 };
+    fileScans[filePath] = {
+      eof: currentSize,
+      mtime: currentMtime,
+      eventCount: 0,
+      ...(pendingLine ? { pendingLine } : {}),
+      ...(codexCursor ? { codex: codexCursor } : {}),
+    };
 
     if (offset >= currentSize && !rotated) continue;
 
     let content: string;
+    let bytesRead = 0;
+    let readBuffer = Buffer.alloc(0);
     try {
       const fh = await fs.open(filePath, "r");
       try {
-        const length = Math.max(0, currentSize - offset);
-        const buf = Buffer.alloc(length);
+        const length = Math.max(
+          0,
+          Math.min(currentSize - scanOffset, sourceBudgetRemaining, MAX_DECODE_BYTES),
+        );
+        readBuffer = Buffer.alloc(length);
         // Chunked: a single fh.read() with length > Int32 aborts the process
-        // with SIGABRT (HQ-SYNC-WEB-15). `bytesRead` may be < length if the
-        // file was truncated since stat — bound the decode to it.
-        const bytesRead = await readFileRegion(fh, buf, offset, length);
-        content = buf.toString("utf-8", 0, bytesRead);
+        // with SIGABRT (HQ-SYNC-WEB-15). `MAX_DECODE_BYTES` separately keeps
+        // the following toString below V8's fatal >= 2**31 boundary; an
+        // oversized configured budget cannot bypass this guard.
+        bytesRead = await readFileRegion(fh, readBuffer, scanOffset, length);
+        content = readBuffer.toString("utf-8", 0, Math.min(bytesRead, MAX_DECODE_BYTES));
       } finally {
         await fh.close();
       }
@@ -1001,6 +1143,70 @@ export async function collectAndSendSkillTelemetry(
       delete fileScans[filePath];
       continue;
     }
+    scannedBytes[kind] += bytesRead;
+    if (bytesRead > 0) lastScannedBySource[kind] = filePath;
+
+    let reachedPhysicalEof = scanOffset + bytesRead >= currentSize;
+    if (!reachedPhysicalEof) {
+      log(`[skill-telemetry] scan budget reached; deferring unread transcript bytes (${filePath})`);
+    }
+
+    let completedPendingLine = false;
+    if (pendingLine) {
+      const newlineIndex = readBuffer.subarray(0, bytesRead).indexOf(0x0a);
+      if (newlineIndex < 0 && !reachedPhysicalEof) {
+        // The record itself is larger than the normal per-pass budget. Persist
+        // only byte positions and continue searching from this new suffix next
+        // pass — never the transcript's contents, and never the same prefix.
+        fileScans[filePath].eof = offset;
+        fileScans[filePath].pendingLine = {
+          start: offset,
+          scannedOffset: scanOffset + bytesRead,
+        };
+        log(`[skill-telemetry] continuing oversized JSONL record on a later pass (${filePath})`);
+        continue;
+      }
+
+      const lineEnd =
+        newlineIndex >= 0 ? scanOffset + newlineIndex + 1 : scanOffset + bytesRead;
+      const lineLength = lineEnd - offset;
+      if (lineLength > MAX_DECODE_BYTES) {
+        // This guard still makes the failure recoverable rather than allowing a
+        // native V8 abort. Keep the byte-only continuation so a later file
+        // rotation/truncation can reset it safely; diagnostics reveal the
+        // exceptional transcript without leaking its contents.
+        fileScans[filePath].eof = offset;
+        fileScans[filePath].pendingLine = { start: offset, scannedOffset: lineEnd };
+        log(`[skill-telemetry] JSONL record exceeds safe decode limit (${filePath})`);
+        continue;
+      }
+
+      try {
+        const fh = await fs.open(filePath, "r");
+        try {
+          readBuffer = Buffer.alloc(lineLength);
+          bytesRead = await readFileRegion(fh, readBuffer, offset, lineLength);
+          if (bytesRead !== lineLength) {
+            fileScans[filePath].eof = offset;
+            fileScans[filePath].pendingLine = {
+              start: offset,
+              scannedOffset: offset + bytesRead,
+            };
+            continue;
+          }
+          content = readBuffer.toString("utf-8", 0, bytesRead);
+        } finally {
+          await fh.close();
+        }
+      } catch {
+        delete fileScans[filePath];
+        continue;
+      }
+      reachedPhysicalEof = lineEnd >= currentSize;
+      completedPendingLine = true;
+      pendingLine = undefined;
+      delete fileScans[filePath].pendingLine;
+    }
 
     // Codex events lack per-row cwd/sessionId — they live in the file's leading
     // `session_meta` line, which we read from the top regardless of the cursor.
@@ -1009,19 +1215,33 @@ export async function collectAndSendSkillTelemetry(
     // Per-file dedup of model-driven Codex skill loads: a single skill use
     // re-reads SKILL.md several times within one turn, so collapse them to one
     // event per (session, turn, skill). Scoped per file = per Codex session.
-    const codexSeen = kind === "codex" ? new Set<string>() : undefined;
+    const codexSeen =
+      kind === "codex" ? new Set(codexCursor?.seen ?? []) : undefined;
     // Running turn id for Codex: the `function_call` exec shape carries no
     // turn_id of its own, so we track the latest one seen (from `turn_context`,
     // which precedes a turn's execs) and attribute those execs to it.
-    let codexTurnId: string | undefined;
+    let codexTurnId: string | undefined = codexCursor?.turnId;
 
-    // Compute the absolute end-byte offset of each line in the read region.
+    // A region capped before EOF can end part-way through a JSONL row (and even
+    // part-way through a multibyte UTF-8 character). Only process its newline-
+    // terminated segments; the next pass resumes at the last settled boundary.
+    // At physical EOF retain today's behaviour of handling a final newline-less
+    // record in the same pass.
     const segments = content.split("\n");
+    const completeSegmentCount = reachedPhysicalEof
+      ? segments.length
+      : Math.max(0, segments.length - 1);
     let cumulative = offset;
-    for (let i = 0; i < segments.length; i++) {
+    let settledOffset = offset;
+    for (let i = 0; i < completeSegmentCount; i++) {
       cumulative += Buffer.byteLength(segments[i], "utf-8");
       if (i < segments.length - 1) cumulative += 1; // the split newline byte
-      const endOffset = cumulative;
+      // For the final physical-EOF segment, use the bytes actually returned by
+      // fs rather than re-encoding it. This preserves byte-exact cursor
+      // offsets even if a writer left an invalid/incomplete UTF-8 tail.
+      const endOffset =
+        i === segments.length - 1 ? offset + bytesRead : cumulative;
+      settledOffset = endOffset;
 
       const trimmed = segments[i].trim();
       if (trimmed.length === 0) continue;
@@ -1033,7 +1253,10 @@ export async function collectAndSendSkillTelemetry(
       }
       if (kind === "codex") {
         const t = codexRowTurnId(parsed);
-        if (t !== undefined) codexTurnId = t;
+        if (t !== undefined) {
+          if (t !== codexTurnId) codexSeen?.clear();
+          codexTurnId = t;
+        }
       }
       const events =
         kind === "codex"
@@ -1083,10 +1306,34 @@ export async function collectAndSendSkillTelemetry(
             `[skill-telemetry] oversized row truncated before send (${filePath}:${i + 1})`,
           );
         }
-        sourced.push({ row: bounded, filePath, endOffset });
+        sourced.push({
+          row: bounded,
+          filePath,
+          endOffset,
+          ...(kind === "codex"
+            ? { codex: snapshotCodexCursorState(codexTurnId, codexSeen) }
+            : {}),
+        });
         fileScans[filePath].eventCount++;
       }
     }
+    // Commit only bytes that reached a complete record boundary. In particular,
+    // never claim currentSize merely because the first budgeted region was read.
+    fileScans[filePath].eof = settledOffset;
+    if (!completedPendingLine && !reachedPhysicalEof) {
+      const lastNewline = readBuffer.subarray(0, bytesRead).lastIndexOf(0x0a);
+      const partialStart = offset + lastNewline + 1;
+      const inspectedThrough = offset + bytesRead;
+      if (partialStart < inspectedThrough) {
+        fileScans[filePath].pendingLine = {
+          start: partialStart,
+          scannedOffset: inspectedThrough,
+        };
+      }
+    }
+    if (kind === "codex") {
+      fileScans[filePath].codex = snapshotCodexCursorState(codexTurnId, codexSeen);
+    }
   }
 
   // 4. Flush in server-sized batches, advancing per-file progress on each 2xx.
@@ -1095,7 +1342,7 @@ export async function collectAndSendSkillTelemetry(
 
   // Per file: count of events successfully sent + max committed byte offset.
   const sentCount: Record<string, number> = {};
-  const committedOffset: Record<string, number> = {};
+  const committed: Record<string, { offset: number; codex?: CodexCursorState }> = {};
 
   let batch: Sourced[] = [];
   let batchBytes = envelopeBytes;
@@ -1116,8 +1363,13 @@ export async function collectAndSendSkillTelemetry(
       // Advance per-file progress for the events in this (successful) batch.
       for (const s of toSend) {
         sentCount[s.filePath] = (sentCount[s.filePath] ?? 0) + 1;
-        const prev = committedOffset[s.filePath] ?? 0;
-        if (s.endOffset > prev) committedOffset[s.filePath] = s.endOffset;
+        const prev = committed[s.filePath];
+        if (!prev || s.endOffset > prev.offset) {
+          committed[s.filePath] = {
+            offset: s.endOffset,
+            ...(s.codex ? { codex: s.codex } : {}),
+          };
+        }
       }
       return true;
     } catch (err) {
@@ -1155,13 +1407,27 @@ export async function collectAndSendSkillTelemetry(
   for (const [fp, entry] of Object.entries(rotationResets)) finalFiles[fp] = entry;
   for (const [fp, scan] of Object.entries(fileScans)) {
     if ((sentCount[fp] ?? 0) >= scan.eventCount) {
-      finalFiles[fp] = { offset: scan.eof, mtime: scan.mtime };
-    } else if (fp in committedOffset) {
-      finalFiles[fp] = { offset: committedOffset[fp], mtime: scan.mtime };
+      finalFiles[fp] = {
+        offset: scan.eof,
+        mtime: scan.mtime,
+        ...(scan.pendingLine ? { pendingLine: scan.pendingLine } : {}),
+        ...(scan.codex ? { codex: scan.codex } : {}),
+      };
+    } else if (fp in committed) {
+      const entry = committed[fp];
+      finalFiles[fp] = {
+        offset: entry.offset,
+        mtime: scan.mtime,
+        ...(entry.codex ? { codex: entry.codex } : {}),
+      };
     }
     // else: no progress for this file — leave loaded/rotation-reset offset.
   }
-  await saveCursor(cursorPath, { version: "1", files: finalFiles });
+  await saveCursor(cursorPath, {
+    version: "1",
+    files: finalFiles,
+    ...(Object.keys(lastScannedBySource).length > 0 ? { lastScannedBySource } : {}),
+  });
 
   return {
     enabled: true,

package/test/e2e/sync/skill-telemetry-oversized-transcript.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { spawn } from "node:child_process";
+import { pathToFileURL } from "node:url";
+
+type ChildResult = {
+  code: number | null;
+  signal: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+};
+
+function runNode(scriptPath: string, env: NodeJS.ProcessEnv): Promise<ChildResult> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [scriptPath], {
+      env,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf-8");
+    child.stderr.setEncoding("utf-8");
+    child.stdout.on("data", (chunk: string) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk: string) => {
+      stderr += chunk;
+    });
+    child.once("error", reject);
+    child.once("close", (code, signal) => {
+      resolve({ code, signal, stdout, stderr });
+    });
+  });
+}
+
+describe("built sync runner — oversized skill transcript", () => {
+  it("drains a multi-budget transcript in a child process without a fatal abort", async () => {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "hqcloud-skill-e2e-"));
+    try {
+      const home = path.join(tmp, "home");
+      const hqRoot = path.join(home, "hq");
+      const sessionDir = path.join(home, ".claude", "projects", "-hq");
+      await fs.mkdir(sessionDir, { recursive: true });
+      await fs.mkdir(hqRoot, { recursive: true });
+
+      // Five 1.5 MiB JSONL records exceed the runner's default 4 MiB source
+      // budget. The normal runner entrypoint must therefore advance over three
+      // bounded passes instead of allocating/decoding the whole transcript.
+      const filler = "x".repeat(1_500_000);
+      const expectedSkills = Array.from({ length: 5 }, (_, i) => `deploy-${i}`);
+      const transcript = expectedSkills
+        .map((skill, i) =>
+          JSON.stringify({
+            type: "user",
+            sessionId: "oversized-session",
+            timestamp: `2026-08-02T12:0${i}:00.000Z`,
+            cwd: hqRoot,
+            uuid: `oversized-${i}`,
+            message: {
+              role: "user",
+              content: `<command-name>/${skill}</command-name><command-args>${filler}</command-args>`,
+            },
+          }),
+        )
+        .join("\n") + "\n";
+      const transcriptPath = path.join(sessionDir, "oversized.jsonl");
+      await fs.writeFile(transcriptPath, transcript, "utf-8");
+
+      const runnerUrl = pathToFileURL(
+        path.join(process.cwd(), "dist", "bin", "sync-runner.js"),
+      ).href;
+      const wrapperPath = path.join(tmp, "run-built-telemetry.mjs");
+      await fs.writeFile(
+        wrapperPath,
+        `import { promises as fs } from "node:fs";
+         import path from "node:path";
+         import { defaultCollectTelemetry } from ${JSON.stringify(runnerUrl)};
+         const hqRoot = process.env.TEST_HQ_ROOT;
+         const cursorPath = path.join(process.env.HOME, ".hq", "skill-telemetry-cursor.json");
+         const postedSkills = [];
+         const client = {
+           entity: { listByType: async () => [{ uid: "prs_skill_telemetry_e2e", type: "person", slug: "skill-telemetry-e2e", status: "active", bucketName: "hq-vault-prs_skill_telemetry_e2e", createdAt: "2026-08-02T00:00:00Z" }] },
+           getTelemetryOptIn: async () => ({ enabled: true, updatedAt: null }),
+           postUsage: async () => ({ ok: true, written: 0, skipped: [] }),
+           postSkillInvocations: async (batch) => { postedSkills.push(...batch.events.map((event) => event.skill)); return { ok: true, written: batch.events.length, skipped: [] }; },
+           postOutcomeEvents: async () => ({ ok: true, written: 0, skipped: [] }),
+         };
+         const offsets = [];
+         for (let pass = 0; pass < 3; pass += 1) {
+           await defaultCollectTelemetry(client, false, hqRoot);
+           const cursor = JSON.parse(await fs.readFile(cursorPath, "utf-8"));
+           offsets.push(cursor.files[process.env.TEST_TRANSCRIPT_PATH]?.offset ?? 0);
+         }
+         process.stdout.write(JSON.stringify({ offsets, postedSkills }));\n`,
+        "utf-8",
+      );
+
+      const result = await runNode(wrapperPath, {
+        ...process.env,
+        HOME: home,
+        TEST_HQ_ROOT: hqRoot,
+        TEST_TRANSCRIPT_PATH: transcriptPath,
+      });
+
+      expect(result.signal).toBeNull();
+      expect(result.code).toBe(0);
+      expect(result.stderr).not.toContain("Fatal error");
+      expect(result.stderr).not.toContain("Check failed: i::kMaxInt >= len");
+      const output = JSON.parse(result.stdout) as {
+        offsets: number[];
+        postedSkills: string[];
+      };
+      expect(output.offsets[0]).toBeGreaterThan(0);
+      expect(output.offsets[0]).toBeLessThan(output.offsets[1]);
+      expect(output.offsets[1]).toBeLessThan(output.offsets[2]);
+      expect(output.offsets[2]).toBe(Buffer.byteLength(transcript, "utf-8"));
+      expect(output.postedSkills).toEqual(expectedSkills);
+    } finally {
+      await fs.rm(tmp, { recursive: true, force: true });
+    }
+  }, 30_000);
+});