tokentracker-cli 0.79.8 → 0.80.0

package/src/lib/rollout.js

@@ -1514,6 +1514,16 @@ async function parseRolloutFile({
   let currentCwd = null;
   let currentDate = null;
   let isForkedRollout = false;
+  // The replay prefix only ever exists at the head of a freshly-forked file. A
+  // resumed scan (startOffset > 0) can never see it — and never re-reads the
+  // session_meta line, so isForkedRollout stays false there anyway — but gate
+  // on the offset explicitly so correctness does not hinge on that distant
+  // invariant. Known accepted limitation: if a sync's read races the fork's
+  // single-flush write and persists a cursor INSIDE the burst, the resumed
+  // scan counts the remaining burst tail (bounded over-count, ms-wide window;
+  // self-heals on any inode-changing rescan and never drops genuine usage).
+  let replayPrefixActive = startOffset === 0;
+  let prevForkedTokenMs = null;
   const rolloutDate = rolloutDateFromPath(filePath);
   let currentProjectRef = projectRef || null;
   let currentProjectKey = projectKey || null;
@@ -1591,8 +1601,50 @@ async function parseRolloutFile({
       totals = totalUsage;
     }
 
-    // date matching is conservative; same-day fork replays are still counted.
-    if (isForkedReplayToken({ isForkedRollout, rolloutDate, currentDate })) continue;
+    // Forked Codex rollouts replay the parent session's entire token history
+    // into the child file the moment the fork is created. The date guard below
+    // (current_date < rolloutDate) catches cross-day forks, but same-day forks
+    // share the parent's current_date and slip through it. The replay is written
+    // in a single flush, so its rows carry near-identical timestamps (sub-ms to a
+    // few ms apart across observed 0.129–0.137 samples), while the first genuine
+    // live turn lands seconds later (≥11s in every sampled fork). We therefore
+    // skip the *leading* run of densely-spaced token_count rows and latch off
+    // permanently at the first multi-second gap: a lone fast turn (always
+    // preceded by a large gap) is never dropped, and an arbitrarily large replay
+    // is fully skipped regardless of length. The threshold sits far above the
+    // flush spacing and well below genuine turn cadence (≥~4.6s observed). The
+    // first replayed row cannot be identified without lookahead, so it is still
+    // counted (a bounded, <1% residual over-count); dropping real usage is the
+    // worse failure, so we bias against it. `totals` is already advanced above,
+    // keeping the cumulative-delta baseline correct for the live turns we keep.
+    // Scoped to forked codex rollouts. (issue #169 follow-up.)
+    let forkedReplaySkip = false;
+    if (isForkedRollout && source === DEFAULT_SOURCE && replayPrefixActive) {
+      const tokenMs = Date.parse(tokenTimestamp);
+      // Fail open on anything the burst heuristic was not measured against:
+      // an unparseable timestamp or a backwards clock step permanently ends
+      // the prefix, so no later row can be skipped off a stale baseline.
+      // Replay flushes are monotonic in every sampled rollout (2,116 gaps,
+      // min 0ms), so this never fires on genuine replays.
+      if (!Number.isFinite(tokenMs) || (prevForkedTokenMs !== null && tokenMs < prevForkedTokenMs)) {
+        replayPrefixActive = false;
+      } else {
+        if (prevForkedTokenMs !== null && tokenMs - prevForkedTokenMs >= CODEX_FORK_REPLAY_GAP_MS) {
+          replayPrefixActive = false;
+        }
+        forkedReplaySkip =
+          replayPrefixActive &&
+          prevForkedTokenMs !== null &&
+          tokenMs - prevForkedTokenMs < CODEX_FORK_REPLAY_GAP_MS;
+        prevForkedTokenMs = tokenMs;
+      }
+    }
+
+    // date matching is conservative; same-day fork replays are caught by the
+    // burst detector above rather than this cross-day date guard.
+    if (forkedReplaySkip || isForkedReplayToken({ isForkedRollout, rolloutDate, currentDate })) {
+      continue;
+    }
 
     const bucketStart = toUtcHalfHourStart(tokenTimestamp);
     if (!bucketStart) continue;
@@ -2694,6 +2746,15 @@ function normalizeIsoDate(value) {
   return match ? match[1] : null;
 }
 
+// Max inter-row gap (ms) still treated as part of a forked rollout's replay
+// burst. Empirically the replay flush spaces rows sub-ms to a few ms apart while
+// genuine live turns arrive ≥~4.6s apart and the replay→live break is ≥11s, so
+// any value in the ~0.25–2s band separates them with a wide margin; 500ms biases
+// toward the low end because merging a real fast turn (under-count) is worse than
+// leaving a slow replay counted (bounded over-count). See the skip site in
+// parseRolloutFile. (issue #169 follow-up.)
+const CODEX_FORK_REPLAY_GAP_MS = 500;
+
 function isForkedReplayToken({ isForkedRollout, rolloutDate, currentDate }) {
   return Boolean(isForkedRollout && rolloutDate && currentDate && currentDate < rolloutDate);
 }

package/src/lib/usage-limits.js

@@ -2823,6 +2823,7 @@ async function fetchUsageLimitsUncached({
   requestFn,
   now = new Date(),
   providerTimeoutMs = DEFAULT_PROVIDER_TIMEOUT_MS,
+  forceRefresh = false,
 } = {}) {
   const nowMs = Date.now();
 
@@ -2870,11 +2871,14 @@ async function fetchUsageLimitsUncached({
   // Skip the upstream Claude call entirely while a 429 cooldown is active — calling again
   // just renews the penalty. The result handling below serves cache or a cooldown message.
   const claudeRetryAtMs = claudeToken ? readClaudeRateLimitRetryAtMs({ home, nowMs }) : null;
-  // Also avoid cross-process hammering after a recent successful read. The macOS app can
-  // restart its embedded Node server or force-refresh the limits page, both of which clear
-  // the in-memory cache; the disk cache keeps those paths from immediately spending
-  // another Claude OAuth usage request.
-  const freshClaudeCache = claudeToken ? readFreshClaudeLimitsCache({ home, nowMs }) : null;
+  // Also avoid cross-process hammering after a recent successful read: embedded-server
+  // restarts and background polls read the disk cache instead of spending another Claude
+  // OAuth usage request. An explicit user refresh (refresh=1 → forceRefresh) punches
+  // through this cache — but never through the 429 cooldown above, which is exactly the
+  // hammering the cooldown exists to prevent.
+  const freshClaudeCache = claudeToken && !forceRefresh
+    ? readFreshClaudeLimitsCache({ home, nowMs })
+    : null;
 
   const providerFetch = withFetchTimeout(fetchImpl, providerTimeoutMs);
   const [claudeResult, codexResult, cursor, kimi, gemini, kiro, antigravity, copilot, grok, zcode, opencodeGo] = await Promise.all([