tokelytics 0.2.0 → 0.3.1

package/bin/tokelytics.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/config.ts
-import { promises as fs3 } from "node:fs";
-import * as path5 from "node:path";
+import { promises as fs4 } from "node:fs";
+import * as path6 from "node:path";
 
 // src/paths.ts
-import { promises as fs2 } from "node:fs";
+import { promises as fs3 } from "node:fs";
 import * as os3 from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import { randomUUID } from "node:crypto";
 
 // ../packages/core/dist/types.js
@@ -63,15 +63,134 @@ function hourOf(ts) {
 function rollupId(provider, day) {
   return `${provider}_${day}`;
 }
-function aggregateSession(sessionId, turns) {
-  const agg = {
-    sessionId,
-    provider: turns[0]?.provider ?? "claude",
-    project: "unknown",
-    gitBranch: "",
+var TIMELINE_BUCKET_MS = 5 * 60 * 1e3;
+var TIMELINE_RETENTION_MS = 8 * 24 * 60 * 60 * 1e3;
+
+// ../packages/core/dist/snapshot.js
+var SNAPSHOT_RECENT_TURNS = 32;
+var SNAPSHOT_SESSIONS = 100;
+var SNAPSHOT_RETENTION_DAYS = 120;
+var SNAPSHOT_TARGET_BYTES = 7e5;
+function emptyDashboardSnapshot(now = /* @__PURE__ */ new Date()) {
+  return {
+    version: 2,
+    updatedAt: now.toISOString(),
+    recentTurns: [],
+    sessions: [],
+    rollups: [],
+    limits: []
+  };
+}
+function mergeDashboardSnapshot(previous, turns, limits, device, now = /* @__PURE__ */ new Date()) {
+  const next = structuredClone(previous ?? emptyDashboardSnapshot(now));
+  next.version = 2;
+  if (turns.length > 0) {
+    next.recentTurns = mergeRecentTurns(next.recentTurns, turns);
+    next.sessions = mergeSessions(next.sessions, turns);
+    next.rollups = mergeRollups(next.rollups, turns, now);
+  }
+  if (limits.length > 0)
+    next.limits = mergeLimits(next.limits, limits);
+  if (device)
+    next.device = device;
+  if (turns.length > 0 || limits.length > 0 || device)
+    next.updatedAt = now.toISOString();
+  return next;
+}
+function prepareDashboardSnapshotForCloud(snapshot2, targetBytes = SNAPSHOT_TARGET_BYTES) {
+  const next = structuredClone(snapshot2);
+  next.recentTurns = next.recentTurns.map(sanitizeTurn);
+  next.sessions = next.sessions.map((session) => ({
+    ...session,
+    project: safeLabel(session.project),
+    gitBranch: safeLabel(session.gitBranch, 120)
+  }));
+  if (next.device)
+    next.device.name = safeLabel(next.device.name, 120);
+  while (snapshotBytes(next) > targetBytes && next.sessions.length > 20)
+    next.sessions.pop();
+  while (snapshotBytes(next) > targetBytes && next.rollups.length > 30)
+    next.rollups.shift();
+  while (snapshotBytes(next) > targetBytes && next.recentTurns.length > 8)
+    next.recentTurns.shift();
+  if (snapshotBytes(next) > targetBytes) {
+    next.recentTurns = next.recentTurns.map((turn) => ({ ...turn, fileReads: void 0 }));
+  }
+  if (snapshotBytes(next) > targetBytes) {
+    throw new Error(`Dashboard snapshot exceeds the ${targetBytes} byte safety limit after pruning.`);
+  }
+  return next;
+}
+function snapshotBytes(snapshot2) {
+  return new TextEncoder().encode(JSON.stringify(snapshot2)).byteLength;
+}
+function mergeRecentTurns(existing, incoming) {
+  const byId = new Map(existing.map((turn) => [turn.turnId, turn]));
+  for (const turn of incoming)
+    byId.set(turn.turnId, turn);
+  return [...byId.values()].sort((a, b) => a.ts.localeCompare(b.ts)).slice(-SNAPSHOT_RECENT_TURNS);
+}
+function sanitizeTurn(turn) {
+  return {
+    ...turn,
+    cwd: void 0,
+    project: safeLabel(turn.project),
+    gitBranch: safeLabel(turn.gitBranch, 120),
+    toolName: safeLabel(turn.toolName ?? void 0, 80) || void 0,
+    fileReads: turn.fileReads?.slice(0, 20).map((read) => ({
+      ...read,
+      path: safePath(read.path)
+    }))
+  };
+}
+function safeLabel(value, max = 160) {
+  if (!value)
+    return "";
+  return [...value].filter((character) => {
+    const code = character.charCodeAt(0);
+    return code > 31 && code !== 127;
+  }).join("").trim().slice(0, max);
+}
+function safePath(value) {
+  const normalized = value.replaceAll("\\", "/");
+  const parts = normalized.split("/").filter((part) => part && part !== "." && part !== ".." && !/^[A-Za-z]:$/.test(part));
+  return parts.slice(-3).join("/").slice(-200);
+}
+function mergeSessions(existing, turns) {
+  const byId = new Map(existing.map((session) => [session.sessionId, { ...session }]));
+  for (const turn of turns) {
+    const session = byId.get(turn.sessionId) ?? emptySession(turn);
+    session.turnCount++;
+    session.inputTokens += turn.inputTokens;
+    session.outputTokens += turn.outputTokens;
+    session.cacheReadTokens += turn.cacheReadTokens;
+    session.cacheCreationTokens += turn.cacheCreationTokens;
+    session.cachedInputTokens += turn.cachedInputTokens;
+    session.reasoningTokens += turn.reasoningTokens;
+    if (!session.firstTs || turn.ts < session.firstTs)
+      session.firstTs = turn.ts;
+    if (!session.lastTs || turn.ts > session.lastTs)
+      session.lastTs = turn.ts;
+    if (turn.project && session.project === "unknown")
+      session.project = turn.project;
+    if (turn.gitBranch && !session.gitBranch)
+      session.gitBranch = turn.gitBranch;
+    if (turn.model && (!session.model || modelPriority(turn.model) > modelPriority(session.model))) {
+      session.model = turn.model;
+    }
+    byId.set(turn.sessionId, session);
+  }
+  return [...byId.values()].sort((a, b) => b.lastTs.localeCompare(a.lastTs)).slice(0, SNAPSHOT_SESSIONS);
+}
+function emptySession(turn) {
+  return {
+    sessionId: turn.sessionId,
+    provider: turn.provider,
+    project: turn.project || "unknown",
+    gitBranch: turn.gitBranch || "",
     firstTs: "",
     lastTs: "",
-    model: "",
+    model: turn.model || "",
     turnCount: 0,
     inputTokens: 0,
     outputTokens: 0,
@@ -80,124 +199,59 @@ function aggregateSession(sessionId, turns) {
     cachedInputTokens: 0,
     reasoningTokens: 0
   };
-  for (const t of turns) {
-    agg.turnCount++;
-    agg.inputTokens += t.inputTokens;
-    agg.outputTokens += t.outputTokens;
-    agg.cacheReadTokens += t.cacheReadTokens;
-    agg.cacheCreationTokens += t.cacheCreationTokens;
-    agg.cachedInputTokens += t.cachedInputTokens;
-    agg.reasoningTokens += t.reasoningTokens;
-    if (t.ts && (!agg.firstTs || t.ts < agg.firstTs))
-      agg.firstTs = t.ts;
-    if (t.ts && (!agg.lastTs || t.ts > agg.lastTs))
-      agg.lastTs = t.ts;
-    if (t.project && agg.project === "unknown")
-      agg.project = t.project;
-    if (t.gitBranch && !agg.gitBranch)
-      agg.gitBranch = t.gitBranch;
-    if (t.model && modelPriority(t.model) > modelPriority(agg.model))
-      agg.model = t.model;
-  }
-  if (!agg.model) {
-    const withModel = turns.find((t) => t.model);
-    if (withModel)
-      agg.model = withModel.model;
-  }
-  return agg;
-}
-function emptyModelTotals(model) {
-  return {
-    model,
-    turns: 0,
-    inputTokens: 0,
-    outputTokens: 0,
-    cacheReadTokens: 0,
-    cacheCreationTokens: 0,
-    cachedInputTokens: 0,
-    reasoningTokens: 0
-  };
 }
-function buildRollup(provider, day, turns) {
-  const models = {};
-  const hours = /* @__PURE__ */ new Map();
-  for (const t of turns) {
-    const key = t.model || "unknown";
-    const m = models[key] ??= emptyModelTotals(key);
-    m.turns++;
-    m.inputTokens += t.inputTokens;
-    m.outputTokens += t.outputTokens;
-    m.cacheReadTokens += t.cacheReadTokens;
-    m.cacheCreationTokens += t.cacheCreationTokens;
-    m.cachedInputTokens += t.cachedInputTokens;
-    m.reasoningTokens += t.reasoningTokens;
-    const h = hourOf(t.ts);
-    if (h !== null) {
-      const bucket = hours.get(h) ?? { hour: h, output: 0, turns: 0 };
-      bucket.output += t.outputTokens;
+function mergeRollups(existing, turns, now) {
+  const byId = new Map(existing.map((rollup) => [rollup.id, structuredClone(rollup)]));
+  for (const turn of turns) {
+    const day = dayOf(turn.ts);
+    if (!day)
+      continue;
+    const id = rollupId(turn.provider, day);
+    const rollup = byId.get(id) ?? { id, provider: turn.provider, day, models: {}, hourly: [] };
+    const model = turn.model || "unknown";
+    const totals = rollup.models[model] ??= {
+      model,
+      turns: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheCreationTokens: 0,
+      cachedInputTokens: 0,
+      reasoningTokens: 0
+    };
+    totals.turns++;
+    totals.inputTokens += turn.inputTokens;
+    totals.outputTokens += turn.outputTokens;
+    totals.cacheReadTokens += turn.cacheReadTokens;
+    totals.cacheCreationTokens += turn.cacheCreationTokens;
+    totals.cachedInputTokens += turn.cachedInputTokens;
+    totals.reasoningTokens += turn.reasoningTokens;
+    const hour = hourOf(turn.ts);
+    if (hour !== null) {
+      const bucket = rollup.hourly.find((item) => item.hour === hour) ?? { hour, output: 0, turns: 0 };
+      bucket.output += turn.outputTokens;
       bucket.turns++;
-      hours.set(h, bucket);
+      if (!rollup.hourly.some((item) => item.hour === hour))
+        rollup.hourly.push(bucket);
+      rollup.hourly.sort((a, b) => a.hour - b.hour);
     }
+    byId.set(id, rollup);
   }
-  return {
-    id: rollupId(provider, day),
-    provider,
-    day,
-    models,
-    hourly: [...hours.values()].sort((a, b) => a.hour - b.hour)
-  };
-}
-var TIMELINE_BUCKET_MS = 5 * 60 * 1e3;
-var TIMELINE_RETENTION_MS = 8 * 24 * 60 * 60 * 1e3;
-function bucketStartMs(ts) {
-  const ms = Date.parse(ts);
-  if (!Number.isFinite(ms))
-    return null;
-  return Math.floor(ms / TIMELINE_BUCKET_MS) * TIMELINE_BUCKET_MS;
+  const cutoff = new Date(now);
+  cutoff.setUTCDate(cutoff.getUTCDate() - (SNAPSHOT_RETENTION_DAYS - 1));
+  const cutoffDay = cutoff.toISOString().slice(0, 10);
+  return [...byId.values()].filter((rollup) => rollup.day >= cutoffDay).sort((a, b) => a.day.localeCompare(b.day) || a.provider.localeCompare(b.provider));
 }
-function dayOfMs(t) {
-  return new Date(t).toISOString().slice(0, 10);
-}
-function buildTimelineBuckets(turns) {
-  const map = /* @__PURE__ */ new Map();
-  for (const t of turns) {
-    const start = bucketStartMs(t.ts);
-    if (start === null)
-      continue;
-    const bucket = map.get(start) ?? { t: start, models: {} };
-    const key = t.model || "unknown";
-    const m = bucket.models[key] ??= { i: 0, o: 0, cr: 0, cc: 0, ci: 0, rs: 0 };
-    m.i += t.inputTokens;
-    m.o += t.outputTokens;
-    m.cr += t.cacheReadTokens;
-    m.cc += t.cacheCreationTokens;
-    m.ci += t.cachedInputTokens;
-    m.rs += t.reasoningTokens;
-    map.set(start, bucket);
-  }
-  return [...map.values()].sort((a, b) => a.t - b.t);
-}
-function mergeTimeline(existing, recomputed, affectedDays, nowMs) {
-  const cutoff = nowMs - TIMELINE_RETENTION_MS;
-  const kept = existing.filter((b) => b.t >= cutoff && !affectedDays.has(dayOfMs(b.t)));
-  const fresh = recomputed.filter((b) => b.t >= cutoff);
-  return [...kept, ...fresh].sort((a, b) => a.t - b.t);
-}
-function affectedKeys(turns) {
-  const sessionIds = /* @__PURE__ */ new Set();
-  const dayBuckets = /* @__PURE__ */ new Map();
-  for (const t of turns) {
-    sessionIds.add(t.sessionId);
-    const day = dayOf(t.ts);
-    if (day)
-      dayBuckets.set(rollupId(t.provider, day), { provider: t.provider, day });
-  }
-  return { sessionIds: [...sessionIds], dayBuckets: [...dayBuckets.values()] };
+function mergeLimits(existing, incoming) {
+  const byProvider = new Map(existing.map((limit) => [limit.provider, limit]));
+  for (const limit of incoming)
+    byProvider.set(limit.provider, limit);
+  return [...byProvider.values()];
 }
 
 // ../packages/core/dist/providers/claude.js
 import * as os from "node:os";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 
 // ../packages/core/dist/fs-scan.js
 import { promises as fs } from "node:fs";
@@ -261,13 +315,144 @@ async function readJsonlFrom(filePath, fromLine) {
   return { totalLines: lines.length, entries };
 }
 
+// ../packages/core/dist/providers/file-read.js
+import { statSync } from "node:fs";
+import * as path2 from "node:path";
+var BYTES_PER_TOKEN = 4;
+var APPROX_BYTES_PER_LINE = 120;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".7z",
+  ".avif",
+  ".bmp",
+  ".class",
+  ".dll",
+  ".dylib",
+  ".exe",
+  ".gif",
+  ".gz",
+  ".ico",
+  ".jar",
+  ".jpeg",
+  ".jpg",
+  ".mov",
+  ".mp3",
+  ".mp4",
+  ".pdf",
+  ".png",
+  ".so",
+  ".tar",
+  ".wav",
+  ".webm",
+  ".webp",
+  ".zip"
+]);
+function isGeneratedPath(value) {
+  const normalized = value.replace(/\\/g, "/").toLowerCase();
+  return /(^|\/)(node_modules|dist|build|out|coverage|target|vendor|\.next|\.nuxt|\.cache)(\/|$)/.test(normalized) || /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|cargo\.lock)$/.test(normalized) || /\.(min\.(js|css)|map|bundle\.(js|css))$/.test(normalized) || /(^|\/)[^/]*bundle[^/]*\.(js|css)$/.test(normalized);
+}
+function isTextTokenCandidatePath(value) {
+  return !BINARY_EXTENSIONS.has(path2.extname(value).toLowerCase());
+}
+function displayPath(absolutePath, cwd) {
+  const normalized = absolutePath.replace(/\\/g, "/");
+  const normalizedCwd = cwd.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (normalizedCwd && normalized.toLowerCase().startsWith(`${normalizedCwd.toLowerCase()}/`)) {
+    return normalized.slice(normalizedCwd.length + 1);
+  }
+  const parts = normalized.split("/").filter(Boolean);
+  return parts.slice(-3).join("/") || path2.basename(absolutePath);
+}
+function fileReadFromPath(rawPath, cwd, limitLines) {
+  if (!rawPath.trim())
+    return null;
+  if (!isTextTokenCandidatePath(rawPath))
+    return null;
+  const rawIsAbsolute = path2.isAbsolute(rawPath);
+  const absolutePath = rawIsAbsolute ? path2.normalize(rawPath) : path2.resolve(cwd || process.cwd(), rawPath);
+  let bytes = 0;
+  try {
+    const stat4 = statSync(absolutePath);
+    if (!stat4.isFile())
+      return null;
+    bytes = stat4.size;
+  } catch {
+  }
+  if (limitLines && limitLines > 0 && bytes > 0) {
+    bytes = Math.min(bytes, limitLines * APPROX_BYTES_PER_LINE);
+  }
+  const normalizedRaw = rawPath.replace(/\\/g, "/").replace(/^\.\//, "");
+  const safePath2 = !rawIsAbsolute && !normalizedRaw.startsWith("../") ? normalizedRaw : displayPath(absolutePath, cwd);
+  return {
+    path: safePath2,
+    bytes,
+    estimatedTokens: bytes > 0 ? Math.ceil(bytes / BYTES_PER_TOKEN) : 0,
+    generated: isGeneratedPath(safePath2)
+  };
+}
+function parseJsonObject(value) {
+  if (typeof value !== "string")
+    return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function candidateAfterCommand(command, tool) {
+  const escaped = tool.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const rx = new RegExp(`(?:^|[;|&]\\s*)${escaped}\\s+(?:(?:-[\\w-]+)(?:\\s+\\d+)?\\s+)*(?:"([^"]+)"|'([^']+)'|([^\\s;|&]+))`, "gim");
+  const out = [];
+  for (const match of command.matchAll(rx)) {
+    const value = match[1] ?? match[2] ?? match[3];
+    if (value && !value.startsWith("-") && !value.startsWith("$") && !value.startsWith("(") && !value.startsWith("%")) {
+      out.push(value);
+    }
+  }
+  return out;
+}
+function fileReadsFromCodexCall(name, argsValue, fallbackCwd) {
+  const args = parseJsonObject(argsValue);
+  const cwd = typeof args["workdir"] === "string" ? args["workdir"] : fallbackCwd;
+  if (name === "view_image")
+    return [];
+  if (name !== "shell_command")
+    return [];
+  const command = typeof args["command"] === "string" ? args["command"] : "";
+  const candidates = [
+    ...candidateAfterCommand(command, "Get-Content"),
+    ...candidateAfterCommand(command, "gc"),
+    ...candidateAfterCommand(command, "cat"),
+    ...candidateAfterCommand(command, "type"),
+    ...candidateAfterCommand(command, "more"),
+    ...candidateAfterCommand(command, "head"),
+    ...candidateAfterCommand(command, "tail")
+  ];
+  return [...new Set(candidates)].flatMap((candidate) => {
+    const read = fileReadFromPath(candidate, cwd);
+    return read ? [read] : [];
+  });
+}
+function fillMissingReadEstimate(reads, output) {
+  if (typeof output !== "string" || output.length === 0)
+    return;
+  const missing = reads.filter((read) => read.estimatedTokens === 0);
+  if (missing.length === 0)
+    return;
+  const each = Math.max(1, Math.ceil(output.length / BYTES_PER_TOKEN / missing.length));
+  for (const read of missing) {
+    read.estimatedTokens = each;
+    read.bytes = each * BYTES_PER_TOKEN;
+  }
+}
+
 // ../packages/core/dist/providers/claude.js
 var MTIME_EPSILON_MS = 1;
 function defaultClaudeDirs(home = os.homedir()) {
   return [
-    path2.join(home, ".claude", "projects"),
+    path3.join(home, ".claude", "projects"),
     // Xcode coding-assistant integration (macOS); silently skipped if absent.
-    path2.join(home, "Library", "Developer", "Xcode", "CodingAssistant", "ClaudeAgentConfig", "projects")
+    path3.join(home, "Library", "Developer", "Xcode", "CodingAssistant", "ClaudeAgentConfig", "projects")
   ];
 }
 function parseClaudeEntries(entries) {
@@ -292,14 +477,20 @@ function parseClaudeEntries(entries) {
     if (inputTokens + outputTokens + cacheReadTokens + cacheCreationTokens === 0)
       continue;
     let toolName = null;
+    const fileReads = [];
+    const cwd = rec.cwd ?? "";
     for (const item of msg.content ?? []) {
       if (item && typeof item === "object" && item.type === "tool_use") {
-        toolName = item.name ?? null;
-        break;
+        toolName ??= item.name ?? null;
+        if (item.name === "Read" && typeof item.input?.file_path === "string") {
+          const limit = typeof item.input.limit === "number" ? item.input.limit : void 0;
+          const read = fileReadFromPath(item.input.file_path, cwd, limit);
+          if (read)
+            fileReads.push(read);
+        }
       }
     }
     const messageId = msg.id ?? "";
-    const cwd = rec.cwd ?? "";
     const turn = {
       provider: "claude",
       turnId: messageId ? `claude:${messageId}` : `claude:noid:${sessionId}:${lineNo}`,
@@ -313,6 +504,7 @@ function parseClaudeEntries(entries) {
       cachedInputTokens: 0,
       reasoningTokens: 0,
       toolName,
+      fileReads,
       project: projectNameFromCwd(cwd),
       cwd,
       gitBranch: rec.gitBranch ?? ""
@@ -324,6 +516,63 @@ function parseClaudeEntries(entries) {
   }
   return [...noId, ...seen.values()];
 }
+function asNumber(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+  return Number.isFinite(n) ? n : void 0;
+}
+function labelClaudeWindow(id) {
+  const k = id.toLowerCase();
+  if (k.includes("5") || k.includes("session"))
+    return "Session (5hr)";
+  if (k.includes("7") || k.includes("week"))
+    return "Weekly (7 day)";
+  return "Usage";
+}
+function collectClaudeWindows(value, prefix = "") {
+  if (!value || typeof value !== "object")
+    return [];
+  const obj = value;
+  const usedPercent = asNumber(obj["used_percentage"] ?? obj["usedPercent"] ?? obj["used_percent"]);
+  const resetsRaw = obj["resets_at"] ?? obj["resetsAt"] ?? obj["reset_at"];
+  const resetsAt = typeof resetsRaw === "string" ? resetsRaw : asNumber(resetsRaw) !== void 0 ? new Date(asNumber(resetsRaw) * 1e3).toISOString() : void 0;
+  const resetAfterSeconds = asNumber(obj["resets_in_seconds"] ?? obj["reset_after_seconds"] ?? obj["resetAfterSeconds"]);
+  const current = usedPercent === void 0 ? [] : [
+    {
+      id: prefix || "usage",
+      label: labelClaudeWindow(prefix || "usage"),
+      usedPercent,
+      resetsAt,
+      resetAfterSeconds
+    }
+  ];
+  for (const [key, child] of Object.entries(obj)) {
+    if (!child || typeof child !== "object")
+      continue;
+    current.push(...collectClaudeWindows(child, prefix ? `${prefix}.${key}` : key));
+  }
+  return current;
+}
+function parseClaudeLimitSnapshots(entries, syncedAt = /* @__PURE__ */ new Date()) {
+  let latest = null;
+  for (const { record } of entries) {
+    if (!record || typeof record !== "object")
+      continue;
+    const rec = record;
+    const rateLimits = rec.rateLimits ?? rec["rate_limits"];
+    if (!rateLimits)
+      continue;
+    const windows = collectClaudeWindows(rateLimits).filter((w, idx, arr) => arr.findIndex((x) => x.id === w.id) === idx);
+    if (windows.length === 0)
+      continue;
+    latest = {
+      provider: "claude",
+      source: "claude.rateLimits",
+      updatedAt: syncedAt.toISOString(),
+      windows
+    };
+  }
+  return latest ? [latest] : [];
+}
 var ClaudeConnector = class {
   id = "claude";
   dirs;
@@ -336,6 +585,7 @@ var ClaudeConnector = class {
   async collect(state) {
     const nextFiles = { ...state.files };
     const turns = [];
+    const scannedEntries = [];
     for (const dir of this.dirs) {
       const files = await walkFiles(dir, (name) => name.endsWith(".jsonl"));
       for (const filePath of files) {
@@ -348,22 +598,30 @@ var ClaudeConnector = class {
         }
         const fromLine = cursor ? cursor.lines : 0;
         const { totalLines, entries } = await readJsonlFrom(filePath, fromLine);
+        scannedEntries.push(...entries);
         if (entries.length > 0) {
           turns.push(...parseClaudeEntries(entries));
         }
         nextFiles[filePath] = { mtimeMs, lines: totalLines };
       }
     }
-    return { turns, state: { files: nextFiles } };
+    return { turns, limits: parseClaudeLimitSnapshots(scannedEntries), state: { files: nextFiles } };
   }
 };
 
 // ../packages/core/dist/providers/codex.js
+import { promises as fs2 } from "node:fs";
 import * as os2 from "node:os";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 var MTIME_EPSILON_MS2 = 1;
+var RATE_LIMIT_REFRESH_MS = 6e4;
+var MAX_RATE_LIMIT_LOG_BYTES = 16 * 1024 * 1024;
 function defaultCodexDirs(home = os2.homedir()) {
-  return [path3.join(home, ".codex", "sessions")];
+  return [path4.join(home, ".codex", "sessions")];
+}
+function defaultCodexRateLimitFiles(home = os2.homedir()) {
+  const base = path4.join(home, ".codex");
+  return [path4.join(base, "logs_2.sqlite"), path4.join(base, "logs_2.sqlite-wal")];
 }
 function usageFromObj(obj) {
   if (!obj || typeof obj !== "object")
@@ -452,8 +710,29 @@ function parseCodexEntries(fileId, entries) {
   let prevCumulative = null;
   let seq = 0;
   let runningModel = meta.model;
+  let pendingReads = [];
+  let pendingToolName = null;
+  const readsByCall = /* @__PURE__ */ new Map();
   for (const { record } of entries) {
-    const recModel = pickModel(record?.["payload"]) ?? pickModel(record);
+    const rec = record;
+    const payload = rec["payload"];
+    if (payload?.["type"] === "function_call") {
+      const name = typeof payload["name"] === "string" ? payload["name"] : "";
+      pendingToolName = name || pendingToolName;
+      const reads = fileReadsFromCodexCall(name, payload["arguments"], meta.cwd);
+      if (reads.length > 0) {
+        pendingReads = [...pendingReads, ...reads];
+        const callId = typeof payload["call_id"] === "string" ? payload["call_id"] : "";
+        if (callId)
+          readsByCall.set(callId, reads);
+      }
+    } else if (payload?.["type"] === "function_call_output") {
+      const callId = typeof payload["call_id"] === "string" ? payload["call_id"] : "";
+      const reads = readsByCall.get(callId);
+      if (reads)
+        fillMissingReadEstimate(reads, payload["output"]);
+    }
+    const recModel = pickModel(payload) ?? pickModel(record);
     if (recModel)
       runningModel = recModel;
     const ev = extractUsageEvent(record);
@@ -489,26 +768,148 @@ function parseCodexEntries(fileId, entries) {
       cacheCreationTokens: 0,
       cachedInputTokens: delta.cachedInput,
       reasoningTokens: delta.reasoning,
-      toolName: null,
+      toolName: pendingToolName,
+      fileReads: pendingReads,
       project: meta.project,
       cwd: meta.cwd,
       gitBranch: meta.gitBranch
     });
+    pendingReads = [];
+    pendingToolName = null;
+    readsByCall.clear();
     seq++;
   }
   return turns;
 }
 function codexFileId(filePath) {
-  return path3.basename(filePath).replace(/\.jsonl$/i, "");
+  return path4.basename(filePath).replace(/\.jsonl$/i, "");
+}
+function asNumber2(v) {
+  const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+  return Number.isFinite(n) ? n : void 0;
+}
+function codexWindowLabel(id, minutes) {
+  if (minutes === 300)
+    return "5 hour usage limit";
+  if (minutes === 10080)
+    return "Weekly usage limit";
+  return id === "primary" ? "Primary usage limit" : id === "secondary" ? "Secondary usage limit" : "Usage limit";
+}
+function toNativeWindow(id, raw) {
+  if (!raw)
+    return null;
+  const usedPercent = asNumber2(raw.used_percent);
+  if (usedPercent === void 0)
+    return null;
+  const windowMinutes = asNumber2(raw.window_minutes);
+  const resetAfterSeconds = asNumber2(raw.reset_after_seconds);
+  const resetAtSeconds = asNumber2(raw.reset_at);
+  return {
+    id,
+    label: codexWindowLabel(id, windowMinutes),
+    usedPercent,
+    windowMinutes,
+    resetsAt: resetAtSeconds ? new Date(resetAtSeconds * 1e3).toISOString() : void 0,
+    resetAfterSeconds
+  };
+}
+function extractJsonObject(text, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0)
+        return text.slice(start, i + 1);
+    }
+  }
+  return null;
+}
+function parseCodexRateLimitSnapshot(text, syncedAt = /* @__PURE__ */ new Date()) {
+  const needle = '"type":"codex.rate_limits"';
+  let pos = -1;
+  let latest = null;
+  while ((pos = text.indexOf(needle, pos + 1)) !== -1) {
+    const start = text.lastIndexOf("{", pos);
+    if (start < 0)
+      continue;
+    const json = extractJsonObject(text, start);
+    if (!json)
+      continue;
+    let payload;
+    try {
+      payload = JSON.parse(json);
+    } catch {
+      continue;
+    }
+    if (payload.type !== "codex.rate_limits")
+      continue;
+    const windows = [
+      toNativeWindow("primary", payload.rate_limits?.primary),
+      toNativeWindow("secondary", payload.rate_limits?.secondary)
+    ].filter((w) => Boolean(w));
+    if (windows.length === 0)
+      continue;
+    latest = {
+      provider: "codex",
+      source: "codex.rate_limits",
+      planType: typeof payload.plan_type === "string" ? payload.plan_type : void 0,
+      updatedAt: syncedAt.toISOString(),
+      windows
+    };
+  }
+  return latest;
+}
+async function readCodexRateLimits(files) {
+  const chunks = [];
+  for (const file of files) {
+    try {
+      const stat4 = await fs2.stat(file);
+      const length = Math.min(stat4.size, MAX_RATE_LIMIT_LOG_BYTES);
+      const handle = await fs2.open(file, "r");
+      try {
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, Math.max(0, stat4.size - length));
+        chunks.push(buffer.toString("latin1"));
+      } finally {
+        await handle.close();
+      }
+    } catch {
+    }
+  }
+  if (chunks.length === 0)
+    return [];
+  const snapshot2 = parseCodexRateLimitSnapshot(chunks.join("\n"), /* @__PURE__ */ new Date());
+  return snapshot2 ? [snapshot2] : [];
 }
 var CodexConnector = class {
   id = "codex";
   dirs;
-  constructor(dirs = defaultCodexDirs()) {
+  rateLimitFiles;
+  cachedLimits = [];
+  nextLimitReadAt = 0;
+  constructor(dirs = defaultCodexDirs(), rateLimitFiles = defaultCodexRateLimitFiles()) {
     this.dirs = dirs;
+    this.rateLimitFiles = rateLimitFiles;
   }
   watchPaths() {
-    return this.dirs;
+    return [...this.dirs, ...this.rateLimitFiles];
   }
   async collect(state) {
     const nextFiles = { ...state.files };
@@ -525,44 +926,71 @@ var CodexConnector = class {
         }
         const { totalLines, entries } = await readJsonlFrom(filePath, 0);
         if (entries.length > 0) {
-          turns.push(...parseCodexEntries(codexFileId(filePath), entries));
+          const parsed = parseCodexEntries(codexFileId(filePath), entries);
+          if (cursor && totalLines >= cursor.lines) {
+            const previousCount = parseCodexEntries(codexFileId(filePath), entries.filter((entry) => entry.lineNo <= cursor.lines)).length;
+            turns.push(...parsed.slice(previousCount));
+          } else {
+            turns.push(...parsed);
+          }
         }
         nextFiles[filePath] = { mtimeMs, lines: totalLines };
       }
     }
-    return { turns, state: { files: nextFiles } };
+    if (Date.now() >= this.nextLimitReadAt) {
+      const latest = await readCodexRateLimits(this.rateLimitFiles);
+      if (latest.length > 0)
+        this.cachedLimits = latest;
+      this.nextLimitReadAt = Date.now() + RATE_LIMIT_REFRESH_MS;
+    }
+    return { turns, limits: this.cachedLimits, state: { files: nextFiles } };
   }
 };
 
 // src/paths.ts
 function configDir() {
-  return process.env.TOKELYTICS_HOME ?? path4.join(os3.homedir(), ".tokelytics");
+  return process.env.TOKELYTICS_HOME ?? path5.join(os3.homedir(), ".tokelytics");
 }
-var statePath = () => path4.join(configDir(), "state.json");
-var credsPath = () => path4.join(configDir(), "credentials.json");
+var statePath = () => path5.join(configDir(), "state.json");
+var stateBackupPath = () => path5.join(configDir(), "state.backup.json");
+var credsPath = () => path5.join(configDir(), "credentials.json");
+var updatePath = () => path5.join(configDir(), "update.json");
+var watchLockPath = () => path5.join(configDir(), "watch.lock");
 async function ensureDir() {
-  await fs2.mkdir(configDir(), { recursive: true });
+  await fs3.mkdir(configDir(), { recursive: true });
 }
 async function readJson(file) {
   try {
-    return JSON.parse(await fs2.readFile(file, "utf-8"));
+    return JSON.parse(await fs3.readFile(file, "utf-8"));
   } catch {
     return null;
   }
 }
-async function writeJson(file, value) {
+async function writeJson(file, value, backup) {
   await ensureDir();
-  await fs2.writeFile(file, JSON.stringify(value, null, 2), "utf-8");
+  const temp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  await fs3.writeFile(temp, JSON.stringify(value, null, 2), "utf-8");
+  try {
+    if (backup) {
+      try {
+        await fs3.copyFile(file, backup);
+      } catch {
+      }
+    }
+    await fs3.rename(temp, file);
+  } finally {
+    await fs3.rm(temp, { force: true }).catch(() => void 0);
+  }
 }
 async function loadState() {
-  const s = await readJson(statePath());
+  const s = await readJson(statePath()) ?? await readJson(stateBackupPath());
   if (s && s.deviceId && s.scan) return s;
-  const fresh = { deviceId: randomUUID(), scan: emptyScanState() };
+  const fresh = { deviceId: randomUUID(), scan: emptyScanState(), publication: {} };
   await writeJson(statePath(), fresh);
   return fresh;
 }
 async function saveState(state) {
-  await writeJson(statePath(), state);
+  await writeJson(statePath(), state, stateBackupPath());
 }
 async function loadCredentials() {
   return readJson(credsPath());
@@ -570,16 +998,59 @@ async function loadCredentials() {
 async function saveCredentials(creds) {
   await writeJson(credsPath(), creds);
   try {
-    await fs2.chmod(credsPath(), 384);
+    await fs3.chmod(credsPath(), 384);
   } catch {
   }
 }
 async function clearCredentials() {
   try {
-    await fs2.rm(credsPath(), { force: true });
+    await fs3.rm(credsPath(), { force: true });
   } catch {
   }
 }
+async function loadUpdateState() {
+  return await readJson(updatePath()) ?? {};
+}
+async function saveUpdateState(state) {
+  await writeJson(updatePath(), state);
+}
+async function acquireWatchLock() {
+  await ensureDir();
+  const file = watchLockPath();
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const handle = await fs3.open(file, "wx");
+      await handle.writeFile(JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf-8");
+      await handle.close();
+      let released = false;
+      return {
+        async release() {
+          if (released) return;
+          released = true;
+          const lock = await readJson(file);
+          if (lock?.pid === process.pid) await fs3.rm(file, { force: true });
+        }
+      };
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") throw error;
+      const lock = await readJson(file);
+      if (lock?.pid && processIsAlive(lock.pid)) {
+        throw new Error(`Tokelytics is already running (PID ${lock.pid}).`, { cause: error });
+      }
+      await fs3.rm(file, { force: true });
+    }
+  }
+  throw new Error("Could not acquire the Tokelytics watcher lock.");
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
 
 // src/config.ts
 var DEFAULT_FIREBASE = {
@@ -613,7 +1084,7 @@ function fromEnv() {
 }
 async function fromFile() {
   try {
-    const raw = await fs3.readFile(path5.join(configDir(), "config.json"), "utf-8");
+    const raw = await fs4.readFile(path6.join(configDir(), "config.json"), "utf-8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -656,7 +1127,7 @@ function openBrowser(url) {
   }
 }
 function captureOAuthCode(buildUrl) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const server = http.createServer((req, res) => {
       const u = new URL(req.url ?? "/", "http://localhost");
       const code = u.searchParams.get("code");
@@ -666,7 +1137,7 @@ function captureOAuthCode(buildUrl) {
         `<html><body style="font-family:system-ui;padding:3rem;text-align:center"><h2>Tokelytics</h2><p>${code ? "You're signed in. You can close this tab." : "Sign-in failed: " + error}</p></body></html>`
       );
       server.close();
-      if (code) resolve3({ code });
+      if (code) resolve4({ code });
       else reject(new Error(`OAuth failed: ${error ?? "no code returned"}`));
     });
     server.listen(0, "127.0.0.1", () => {
@@ -761,13 +1232,13 @@ var CORS_HEADERS = {
   "Access-Control-Allow-Headers": "Content-Type"
 };
 function readBody(req) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let data = "";
     req.on("data", (chunk) => {
       data += chunk;
       if (data.length > 1e6) req.destroy();
     });
-    req.on("end", () => resolve3(data));
+    req.on("end", () => resolve4(data));
     req.on("error", reject);
   });
 }
@@ -784,10 +1255,9 @@ async function exchangeRefreshToken(cfg, refreshToken) {
 async function browserHandoffLogin(cfg) {
   const nonce = randomBytes(5).toString("hex").toUpperCase();
   const TIMEOUT_MS = 5 * 6e4;
-  const payload = await new Promise((resolve3, reject) => {
-    let timer;
+  const payload = await new Promise((resolve4, reject) => {
     function finish(act) {
-      if (timer) clearTimeout(timer);
+      clearTimeout(timer);
       server.close();
       act();
     }
@@ -817,10 +1287,10 @@ async function browserHandoffLogin(cfg) {
         }
         res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: true }));
-        finish(() => resolve3(body));
+        finish(() => resolve4(body));
       }).catch((err) => finish(() => reject(err)));
     });
-    timer = setTimeout(
+    const timer = setTimeout(
       () => finish(() => reject(new Error('Timed out waiting for browser sign-in. Run "tokelytics login" again.'))),
       TIMEOUT_MS
     );
@@ -876,13 +1346,300 @@ async function restoreSession(cfg) {
 }
 
 // src/runner.ts
-import * as os4 from "node:os";
+import * as os5 from "node:os";
 
 // src/connectors.ts
 function buildConnectors() {
   return [new ClaudeConnector(), new CodexConnector()];
 }
 
+// src/provider-limits.ts
+import { promises as fs5 } from "node:fs";
+import * as os4 from "node:os";
+import * as path7 from "node:path";
+var CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+var CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+var REQUEST_TIMEOUT_MS = 1e4;
+var REFRESH_INTERVAL_MS = 6e4;
+function asNumber3(value) {
+  const number = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+  return Number.isFinite(number) ? number : void 0;
+}
+function asIso(value) {
+  if (typeof value === "string") {
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : void 0;
+  }
+  const seconds = asNumber3(value);
+  if (seconds === void 0 || seconds <= 0) return void 0;
+  return new Date(seconds * 1e3).toISOString();
+}
+function snapshot(provider, source, status, message, updatedAt, windows = [], planType) {
+  return {
+    provider,
+    source,
+    status,
+    statusMessage: message,
+    planType,
+    updatedAt: updatedAt.toISOString(),
+    windows
+  };
+}
+function parseClaudeUsageResponse(value, updatedAt = /* @__PURE__ */ new Date(), planType) {
+  const response = value ?? {};
+  const windows = [];
+  const add = (id, label, minutes, bucket) => {
+    const usedPercent = asNumber3(bucket?.utilization);
+    if (usedPercent === void 0) return;
+    windows.push({
+      id,
+      label,
+      usedPercent,
+      windowMinutes: minutes,
+      resetsAt: asIso(bucket?.resets_at)
+    });
+  };
+  add("session", "5-hour", 300, response.five_hour);
+  add("weekly", "Weekly", 10080, response.seven_day);
+  return snapshot(
+    "claude",
+    "claude.oauth_usage",
+    windows.length > 0 ? "available" : "unavailable",
+    windows.length > 0 ? void 0 : "Claude did not return allowance windows. Retrying automatically.",
+    updatedAt,
+    windows,
+    planType
+  );
+}
+function parseCodexUsageResponse(value, updatedAt = /* @__PURE__ */ new Date()) {
+  const response = value ?? {};
+  const details = response.rate_limit;
+  const windows = [];
+  const add = (id, label, fallbackMinutes, window) => {
+    const usedPercent = asNumber3(window?.used_percent);
+    if (usedPercent === void 0) return;
+    const windowSeconds = asNumber3(window?.limit_window_seconds);
+    windows.push({
+      id,
+      label,
+      usedPercent,
+      windowMinutes: windowSeconds ? Math.round(windowSeconds / 60) : fallbackMinutes,
+      resetsAt: asIso(window?.reset_at)
+    });
+  };
+  add("primary", "5-hour", 300, details?.primary_window);
+  add("secondary", "Weekly", 10080, details?.secondary_window);
+  return snapshot(
+    "codex",
+    "codex.oauth_usage",
+    windows.length > 0 ? "available" : "unavailable",
+    windows.length > 0 ? void 0 : "Codex did not return allowance windows. Retrying automatically.",
+    updatedAt,
+    windows,
+    typeof response.plan_type === "string" ? response.plan_type : void 0
+  );
+}
+async function readJson2(file) {
+  try {
+    return JSON.parse(await fs5.readFile(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+async function readClaudeCredentials(home, env) {
+  const configDir2 = env.CLAUDE_CONFIG_DIR || path7.join(home, ".claude");
+  const root = await readJson2(path7.join(configDir2, ".credentials.json"));
+  const oauth = root?.["claudeAiOauth"];
+  if (!oauth || typeof oauth !== "object") return null;
+  const data = oauth;
+  const accessToken = data["accessToken"];
+  if (typeof accessToken !== "string" || !accessToken) return null;
+  return {
+    accessToken,
+    expiresAt: asNumber3(data["expiresAt"]),
+    planType: typeof data["subscriptionType"] === "string" ? data["subscriptionType"] : void 0
+  };
+}
+async function readCodexCredentials(home, env) {
+  const configDir2 = env.CODEX_HOME || path7.join(home, ".codex");
+  const root = await readJson2(path7.join(configDir2, "auth.json"));
+  const tokens = root?.["tokens"];
+  if (!tokens || typeof tokens !== "object") return null;
+  const data = tokens;
+  const accessToken = data["access_token"];
+  if (typeof accessToken !== "string" || !accessToken) return null;
+  return {
+    accessToken,
+    accountId: typeof data["account_id"] === "string" ? data["account_id"] : void 0
+  };
+}
+async function requestJson(fetcher, url, headers) {
+  const response = await fetcher(url, {
+    headers,
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) return { status: response.status };
+  try {
+    return { status: response.status, body: await response.json() };
+  } catch {
+    return { status: response.status };
+  }
+}
+function authMessage(provider) {
+  return `${provider} sign-in needs refresh. Open ${provider} Code once; Tokelytics will retry automatically.`;
+}
+var ClaudeLimitCollector = class {
+  constructor(options) {
+    this.options = options;
+  }
+  provider = "claude";
+  cached = null;
+  nextRefreshAt = 0;
+  async collect() {
+    const updatedAt = this.options.now();
+    if (this.cached && updatedAt.getTime() < this.nextRefreshAt) return this.cached;
+    this.nextRefreshAt = updatedAt.getTime() + REFRESH_INTERVAL_MS;
+    const fresh = await this.collectFresh(updatedAt);
+    if (fresh.status === "error" && this.cached?.status === "available") {
+      return {
+        ...this.cached,
+        statusMessage: "Latest refresh was delayed; showing the last provider-reported values."
+      };
+    }
+    this.cached = fresh;
+    return fresh;
+  }
+  async collectFresh(updatedAt) {
+    try {
+      const credentials = await readClaudeCredentials(this.options.home, this.options.env);
+      if (!credentials) {
+        return snapshot(
+          "claude",
+          "claude.oauth_usage",
+          "unavailable",
+          "Claude Code is not signed in on this machine.",
+          updatedAt
+        );
+      }
+      const result = await requestJson(this.options.fetcher, CLAUDE_USAGE_URL, {
+        Authorization: `Bearer ${credentials.accessToken}`,
+        "anthropic-beta": "oauth-2025-04-20"
+      });
+      if (result.status === 401 || result.status === 403) {
+        return snapshot("claude", "claude.oauth_usage", "error", authMessage("Claude"), updatedAt);
+      }
+      if (result.status === 429) {
+        return snapshot(
+          "claude",
+          "claude.oauth_usage",
+          "error",
+          "Claude temporarily limited usage checks. Retrying automatically.",
+          updatedAt
+        );
+      }
+      if (!result.body) {
+        return snapshot(
+          "claude",
+          "claude.oauth_usage",
+          "error",
+          "Claude usage service could not be reached. Retrying automatically.",
+          updatedAt
+        );
+      }
+      return parseClaudeUsageResponse(result.body, updatedAt, credentials.planType);
+    } catch {
+      return snapshot(
+        "claude",
+        "claude.oauth_usage",
+        "error",
+        "Claude usage service could not be reached. Retrying automatically.",
+        updatedAt
+      );
+    }
+  }
+};
+var CodexLimitCollector = class {
+  constructor(options) {
+    this.options = options;
+  }
+  provider = "codex";
+  cached = null;
+  nextRefreshAt = 0;
+  async collect() {
+    const updatedAt = this.options.now();
+    if (this.cached && updatedAt.getTime() < this.nextRefreshAt) return this.cached;
+    this.nextRefreshAt = updatedAt.getTime() + REFRESH_INTERVAL_MS;
+    const fresh = await this.collectFresh(updatedAt);
+    if (fresh.status === "error" && this.cached?.status === "available") {
+      return {
+        ...this.cached,
+        statusMessage: "Latest refresh was delayed; showing the last provider-reported values."
+      };
+    }
+    this.cached = fresh;
+    return fresh;
+  }
+  async collectFresh(updatedAt) {
+    try {
+      const credentials = await readCodexCredentials(this.options.home, this.options.env);
+      if (!credentials) {
+        return snapshot(
+          "codex",
+          "codex.oauth_usage",
+          "unavailable",
+          "Codex is not signed in on this machine.",
+          updatedAt
+        );
+      }
+      const headers = {
+        Authorization: `Bearer ${credentials.accessToken}`,
+        "User-Agent": "codex-cli"
+      };
+      if (credentials.accountId) headers["ChatGPT-Account-Id"] = credentials.accountId;
+      const result = await requestJson(this.options.fetcher, CODEX_USAGE_URL, headers);
+      if (result.status === 401 || result.status === 403) {
+        return snapshot("codex", "codex.oauth_usage", "error", authMessage("Codex"), updatedAt);
+      }
+      if (result.status === 429) {
+        return snapshot(
+          "codex",
+          "codex.oauth_usage",
+          "error",
+          "Codex temporarily limited usage checks. Retrying automatically.",
+          updatedAt
+        );
+      }
+      if (!result.body) {
+        return snapshot(
+          "codex",
+          "codex.oauth_usage",
+          "error",
+          "Codex usage service could not be reached. Retrying automatically.",
+          updatedAt
+        );
+      }
+      return parseCodexUsageResponse(result.body, updatedAt);
+    } catch {
+      return snapshot(
+        "codex",
+        "codex.oauth_usage",
+        "error",
+        "Codex usage service could not be reached. Retrying automatically.",
+        updatedAt
+      );
+    }
+  }
+};
+function buildNativeLimitCollectors(options = {}) {
+  const resolved = {
+    home: options.home ?? os4.homedir(),
+    env: options.env ?? process.env,
+    fetcher: options.fetcher ?? fetch,
+    now: options.now ?? (() => /* @__PURE__ */ new Date())
+  };
+  return [new ClaudeLimitCollector(resolved), new CodexLimitCollector(resolved)];
+}
+
 // src/firestore-rest.ts
 function encodeValue(v) {
   if (v === null || v === void 0) return { nullValue: null };
@@ -918,6 +1675,14 @@ function decodeFields(fields) {
   for (const [k, val] of Object.entries(fields)) out[k] = decodeValue(val);
   return out;
 }
+var FirestoreRestError = class extends Error {
+  constructor(message, status, retryAfterMs) {
+    super(message);
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "FirestoreRestError";
+  }
+};
 var FirestoreRest = class {
   projectId;
   getToken;
@@ -947,15 +1712,20 @@ var FirestoreRest = class {
     const res = await fetch(this.url(`${this.docsRoot()}:commit`), {
       method: "POST",
       headers: await this.headers(),
-      body: JSON.stringify({ writes })
+      body: JSON.stringify({ writes }),
+      signal: AbortSignal.timeout(15e3)
     });
-    if (!res.ok) throw new Error(`Firestore commit failed (${res.status}): ${await res.text()}`);
+    if (!res.ok) throw await firestoreError("commit", res);
   }
   /** Fetch a single document's decoded fields, or null if it doesn't exist. */
   async getDoc(name) {
-    const res = await fetch(this.url(name), { method: "GET", headers: await this.headers() });
+    const res = await fetch(this.url(name), {
+      method: "GET",
+      headers: await this.headers(),
+      signal: AbortSignal.timeout(15e3)
+    });
     if (res.status === 404) return null;
-    if (!res.ok) throw new Error(`Firestore get failed (${res.status}): ${await res.text()}`);
+    if (!res.ok) throw await firestoreError("get", res);
     const doc = await res.json();
     return doc.fields ? decodeFields(doc.fields) : {};
   }
@@ -973,127 +1743,190 @@ var FirestoreRest = class {
     const res = await fetch(this.url(`${parent}:runQuery`), {
       method: "POST",
       headers: await this.headers(),
-      body: JSON.stringify({ structuredQuery: { from: [{ collectionId }], where } })
+      body: JSON.stringify({ structuredQuery: { from: [{ collectionId }], where } }),
+      signal: AbortSignal.timeout(15e3)
     });
-    if (!res.ok) throw new Error(`Firestore query failed (${res.status}): ${await res.text()}`);
+    if (!res.ok) throw await firestoreError("query", res);
     const rows = await res.json();
     return rows.filter((r) => r.document?.fields).map((r) => decodeFields(r.document.fields));
   }
 };
-
-// src/sink.ts
-function timelineDaysByProvider(buckets, nowMs) {
-  const cutoffDay = new Date(nowMs - TIMELINE_RETENTION_MS).toISOString().slice(0, 10);
-  const out = /* @__PURE__ */ new Map();
-  for (const { provider, day } of buckets) {
-    if (day < cutoffDay) continue;
-    let set = out.get(provider);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      out.set(provider, set);
-    }
-    set.add(day);
-  }
-  return out;
+async function firestoreError(operation, response) {
+  const body = (await response.text()).slice(0, 800);
+  const retryAfter = response.headers.get("retry-after");
+  const seconds = retryAfter ? Number(retryAfter) : Number.NaN;
+  return new FirestoreRestError(
+    `Firestore ${operation} failed (${response.status}): ${body}`,
+    response.status,
+    Number.isFinite(seconds) ? seconds * 1e3 : void 0
+  );
 }
 
 // src/firestore-sink.ts
-var BATCH = 400;
 var FirestoreSink = class {
-  constructor(fs4, uid) {
-    this.fs = fs4;
+  constructor(fs6, uid) {
+    this.fs = fs6;
     this.uid = uid;
   }
-  async writeTurns(turns) {
-    for (let i = 0; i < turns.length; i += BATCH) {
-      const slice = turns.slice(i, i + BATCH);
-      await this.fs.upsert(
-        slice.map((t) => ({
-          name: this.fs.docName("users", this.uid, "turns", t.turnId),
-          fields: { ...t, day: dayOf(t.ts) }
-        }))
-      );
-    }
-  }
-  async turnsForSession(sessionId) {
-    const rows = await this.fs.queryEqual(["users", this.uid], "turns", [
-      { field: "sessionId", op: "EQUAL", value: sessionId }
-    ]);
-    return rows;
-  }
-  async turnsForBucket(provider, day) {
-    const rows = await this.fs.queryEqual(["users", this.uid], "turns", [
-      { field: "provider", op: "EQUAL", value: provider },
-      { field: "day", op: "EQUAL", value: day }
-    ]);
-    return rows;
-  }
-  async recomputeSessions(sessionIds) {
-    for (const sid of sessionIds) {
-      const turns = await this.turnsForSession(sid);
-      if (!turns.length) continue;
-      const agg = aggregateSession(sid, turns);
-      await this.fs.upsert([{ name: this.fs.docName("users", this.uid, "sessions", sid), fields: { ...agg } }]);
-    }
-  }
-  async recomputeRollups(buckets) {
-    for (const { provider, day } of buckets) {
-      const turns = await this.turnsForBucket(provider, day);
-      if (!turns.length) continue;
-      const rollup = buildRollup(provider, day, turns);
-      await this.fs.upsert([
-        { name: this.fs.docName("users", this.uid, "rollups", rollupId(provider, day)), fields: { ...rollup } }
-      ]);
-    }
-  }
-  async recomputeTimelines(buckets) {
-    const now = Date.now();
-    for (const [provider, days] of timelineDaysByProvider(buckets, now)) {
-      const recomputed = [];
-      for (const day of days) {
-        recomputed.push(...buildTimelineBuckets(await this.turnsForBucket(provider, day)));
-      }
-      const name = this.fs.docName("users", this.uid, "timelines", provider);
-      const existingDoc = await this.fs.getDoc(name);
-      const existing = existingDoc?.["buckets"] ?? [];
-      const merged = mergeTimeline(existing, recomputed, days, now);
-      await this.fs.upsert([
-        { name, fields: { provider, buckets: merged, updatedAt: new Date(now).toISOString() } }
-      ]);
-    }
-  }
-  async touchDevice(meta) {
+  async writeDashboardSnapshot(snapshot2) {
+    if (!snapshot2.device?.deviceId) throw new Error("Dashboard snapshot is missing its device id.");
+    const cloudSnapshot = prepareDashboardSnapshotForCloud(snapshot2);
     await this.fs.upsert([
-      { name: this.fs.docName("users", this.uid, "devices", meta.deviceId), fields: { ...meta } }
+      {
+        name: this.fs.docName("users", this.uid, "machines", snapshot2.device.deviceId),
+        fields: { ...cloudSnapshot }
+      }
     ]);
   }
 };
 
+// src/version.ts
+var AGENT_VERSION = "0.3.1";
+
 // src/sync.ts
-async function runSync(connectors, sink, state, device) {
+async function runSync(connectors, sink, state, device, limitCollectors = [], options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const refreshLimits = options.refreshLimits ?? true;
+  const publication = {
+    ...options.publication,
+    limitFingerprints: { ...options.publication?.limitFingerprints }
+  };
+  const cloudSyncIntervalMs = options.cloudSyncIntervalMs ?? 0;
+  const maxCloudWritesPerDay = options.maxCloudWritesPerDay ?? 16;
   let st = state;
   const collected = [];
+  const limits = [];
   const byProvider = {};
   for (const c of connectors) {
-    const { turns: turns2, state: next } = await c.collect(st);
+    const { turns: turns2, limits: nativeLimits2 = [], state: next } = await c.collect(st);
     st = next;
+    if (refreshLimits) limits.push(...nativeLimits2);
     for (const t of turns2) {
       collected.push(t);
       byProvider[t.provider] = (byProvider[t.provider] ?? 0) + 1;
     }
   }
+  if (refreshLimits) {
+    const providerLimits = await Promise.all(
+      limitCollectors.map(async (collector) => {
+        try {
+          return await collector.collect();
+        } catch {
+          return null;
+        }
+      })
+    );
+    limits.push(...providerLimits.filter((limit) => Boolean(limit)));
+  }
   const unique = /* @__PURE__ */ new Map();
   for (const t of collected) unique.set(t.turnId, t);
   const turns = [...unique.values()];
-  if (turns.length > 0) {
-    await sink.writeTurns(turns);
-    const { sessionIds, dayBuckets } = affectedKeys(turns);
-    await sink.recomputeSessions(sessionIds);
-    await sink.recomputeRollups(dayBuckets);
-    await sink.recomputeTimelines(dayBuckets);
+  const nativeLimits = refreshLimits ? dedupeLimits(limits) : [];
+  const changedLimits = nativeLimits.filter(
+    (limit) => publication.limitFingerprints?.[limit.provider] !== limitFingerprint(limit)
+  );
+  if (changedLimits.length > 0) {
+    publication.limitFingerprints ??= {};
+    for (const limit of changedLimits) {
+      publication.limitFingerprints[limit.provider] = limitFingerprint(limit);
+    }
+  }
+  if (refreshLimits) publication.lastLimitCheckAt = now.toISOString();
+  const heartbeatMs = options.deviceHeartbeatMs ?? 0;
+  const previousHeartbeat = Date.parse(publication.lastDeviceAt ?? "");
+  const heartbeatDue = heartbeatMs === 0 || !Number.isFinite(previousHeartbeat) || now.getTime() - previousHeartbeat >= heartbeatMs;
+  const updateDevice = turns.length > 0 || changedLimits.length > 0 || !options.dashboard?.device || options.forceDeviceHeartbeat || heartbeatDue;
+  const dashboard = mergeDashboardSnapshot(
+    options.dashboard,
+    turns,
+    changedLimits,
+    updateDevice ? { ...device, lastSyncAt: now.toISOString() } : void 0,
+    now
+  );
+  if (updateDevice) {
+    publication.lastDeviceAt = now.toISOString();
+  }
+  const changed = turns.length > 0 || changedLimits.length > 0 || updateDevice;
+  if (changed) publication.lastLocalEventAt = now.toISOString();
+  publication.dashboardDirty = Boolean(publication.dashboardDirty || changed);
+  resetDailyBudget(publication, now);
+  const lastCloudWrite = Date.parse(publication.lastCloudWriteAt ?? "");
+  const cloudWriteDue = options.forceCloudPublish || !Number.isFinite(lastCloudWrite) || now.getTime() - lastCloudWrite >= cloudSyncIntervalMs;
+  const hasBudget = (publication.cloudWritesToday ?? 0) < maxCloudWritesPerDay;
+  let published = false;
+  let publicationError;
+  dashboard.sync = {
+    agentVersion: AGENT_VERSION,
+    cloudWritesToday: publication.cloudWritesToday ?? 0,
+    maxCloudWritesPerDay,
+    localChangesPending: Boolean(publication.dashboardDirty),
+    lastLocalEventAt: publication.lastLocalEventAt,
+    lastCloudWriteAt: publication.lastCloudWriteAt
+  };
+  if (publication.dashboardDirty && cloudWriteDue && hasBudget) {
+    try {
+      dashboard.sync = {
+        ...dashboard.sync,
+        cloudWritesToday: (publication.cloudWritesToday ?? 0) + 1,
+        localChangesPending: false,
+        lastCloudWriteAt: now.toISOString()
+      };
+      await sink.writeDashboardSnapshot(dashboard);
+      publication.cloudWritesToday = (publication.cloudWritesToday ?? 0) + 1;
+      publication.lastCloudWriteAt = now.toISOString();
+      publication.dashboardDirty = false;
+      published = true;
+    } catch (error) {
+      dashboard.sync.localChangesPending = true;
+      publicationError = error;
+    }
   }
-  await sink.touchDevice({ ...device, lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
-  return { newTurns: turns.length, byProvider, state: st };
+  return {
+    processedTurns: turns.length,
+    processedLimits: changedLimits.length,
+    byProvider,
+    state: st,
+    dashboard,
+    publication,
+    published,
+    publicationError
+  };
+}
+function dedupeLimits(limits) {
+  const byProvider = /* @__PURE__ */ new Map();
+  for (const limit of limits) {
+    const current = byProvider.get(limit.provider);
+    if (!current || limitScore(limit) >= limitScore(current)) byProvider.set(limit.provider, limit);
+  }
+  return [...byProvider.values()];
+}
+function limitScore(limit) {
+  const available = (limit.status ?? (limit.windows.length > 0 ? "available" : "unavailable")) === "available";
+  const oauth = limit.source.endsWith("oauth_usage");
+  return (available ? 100 : 0) + (oauth ? 10 : 0) + limit.windows.length;
+}
+function limitFingerprint(limit) {
+  return JSON.stringify({
+    provider: limit.provider,
+    source: limit.source,
+    status: limit.status,
+    statusMessage: limit.statusMessage,
+    planType: limit.planType,
+    windows: limit.windows
+  });
+}
+function resetDailyBudget(publication, now) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: "America/Los_Angeles",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(now);
+  const value = (type) => parts.find((part) => part.type === type)?.value ?? "";
+  const day = `${value("year")}-${value("month")}-${value("day")}`;
+  if (publication.cloudWriteDay === day) return;
+  publication.cloudWriteDay = day;
+  publication.cloudWritesToday = 0;
 }
 
 // src/runner.ts
@@ -1102,6 +1935,7 @@ async function createRunner() {
   const session = await restoreSession(cfg);
   if (!session) throw new Error('Not signed in. Run "tokelytics login" first.');
   const connectors = buildConnectors();
+  const limitCollectors = buildNativeLimitCollectors();
   const rest = new FirestoreRest({
     projectId: cfg.firebase.projectId,
     getToken: () => session.getToken(),
@@ -1113,34 +1947,55 @@ async function createRunner() {
     watchPaths() {
       return connectors.flatMap((c) => c.watchPaths());
     },
-    async syncOnce() {
+    async syncOnce(options = {}) {
       const state = await loadState();
       const device = {
         deviceId: state.deviceId,
-        name: os4.hostname(),
+        name: os5.hostname(),
         lastSyncAt: "",
         providers: connectors.map((c) => c.id)
       };
-      const res = await runSync(connectors, sink, state.scan, device);
-      await saveState({ deviceId: state.deviceId, scan: res.state });
-      return { newTurns: res.newTurns, byProvider: res.byProvider };
+      const scan = state.dashboard ? state.scan : emptyScanState();
+      const res = await runSync(connectors, sink, scan, device, limitCollectors, {
+        ...options,
+        publication: state.publication,
+        dashboard: state.dashboard
+      });
+      const nextState = {
+        deviceId: state.deviceId,
+        scan: res.state,
+        dashboard: res.dashboard,
+        publication: res.publication
+      };
+      if (!sameState(state, nextState)) await saveState(nextState);
+      if (res.publicationError) throw res.publicationError;
+      return {
+        processedTurns: res.processedTurns,
+        processedLimits: res.processedLimits,
+        byProvider: res.byProvider,
+        published: res.published,
+        cloudWritesToday: res.publication.cloudWritesToday ?? 0
+      };
     }
   };
 }
+function sameState(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
 async function registerDevice(cfg, session) {
-  const rest = new FirestoreRest({
-    projectId: cfg.firebase.projectId,
-    getToken: () => session.getToken(),
-    emulatorHost: cfg.firestoreEmulatorHost
-  });
-  const sink = new FirestoreSink(rest, session.uid);
   const state = await loadState();
   const connectors = buildConnectors();
-  await sink.touchDevice({
+  const now = /* @__PURE__ */ new Date();
+  const device = {
     deviceId: state.deviceId,
-    name: os4.hostname(),
-    lastSyncAt: "",
+    name: os5.hostname(),
+    lastSyncAt: now.toISOString(),
     providers: connectors.map((c) => c.id)
+  };
+  await saveState({
+    ...state,
+    dashboard: mergeDashboardSnapshot(state.dashboard, [], [], device, now),
+    publication: { ...state.publication, dashboardDirty: true, lastDeviceAt: now.toISOString() }
   });
 }
 
@@ -1220,7 +2075,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path6) => statMethod(path6, { bigint: true });
+      this._stat = (path8) => statMethod(path8, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -1245,8 +2100,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path6, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path6));
+          const { path: path8, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path8));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -1286,21 +2141,21 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path6, depth) {
+  async _exploreDir(path8, depth) {
     let files;
     try {
-      files = await readdir(path6, this._rdOptions);
+      files = await readdir(path8, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path6 };
+    return { files, depth, path: path8 };
   }
-  async _formatEntry(dirent, path6) {
+  async _formatEntry(dirent, path8) {
     let entry;
-    const basename4 = this._isDirent ? dirent.name : dirent;
+    const basename5 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path6, basename4));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
+      const fullPath = presolve(pjoin(path8, basename5));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename5 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -1699,16 +2554,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path6, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path8, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path6);
-    emitRaw(rawEvent, evPath, { watchedPath: path6 });
-    if (evPath && path6 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path6, evPath), KEY_LISTENERS, sysPath.join(path6, evPath));
+    listener(path8);
+    emitRaw(rawEvent, evPath, { watchedPath: path8 });
+    if (evPath && path8 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path8, evPath), KEY_LISTENERS, sysPath.join(path8, evPath));
     }
   };
   try {
-    return fs_watch(path6, {
+    return fs_watch(path8, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -1724,12 +2579,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path6, fullPath, options, handlers) => {
+var setFsWatchListener = (path8, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path6, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path8, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -1740,7 +2595,7 @@ var setFsWatchListener = (path6, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path6,
+      path8,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -1755,7 +2610,7 @@ var setFsWatchListener = (path6, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path6, "r");
+          const fd = await open(path8, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -1786,7 +2641,7 @@ var setFsWatchListener = (path6, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path6, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path8, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -1808,7 +2663,7 @@ var setFsWatchFileListener = (path6, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path6, curr));
+          foreach(cont.listeners, (listener2) => listener2(path8, curr));
         }
       })
     };
@@ -1836,13 +2691,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path6, listener) {
+  _watchWithNodeFs(path8, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path6);
-    const basename4 = sysPath.basename(path6);
+    const directory = sysPath.dirname(path8);
+    const basename5 = sysPath.basename(path8);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename4);
-    const absolutePath = sysPath.resolve(path6);
+    parent.add(basename5);
+    const absolutePath = sysPath.resolve(path8);
     const options = {
       persistent: opts.persistent
     };
@@ -1851,13 +2706,13 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path6, absolutePath, options, {
+      options.interval = enableBin && isBinaryPath(basename5) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path8, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path6, absolutePath, options, {
+      closer = setFsWatchListener(path8, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -1874,12 +2729,12 @@ var NodeFsHandler = class {
       return;
     }
     const dirname3 = sysPath.dirname(file);
-    const basename4 = sysPath.basename(file);
+    const basename5 = sysPath.basename(file);
     const parent = this.fsw._getWatchedDir(dirname3);
     let prevStats = stats;
-    if (parent.has(basename4))
+    if (parent.has(basename5))
       return;
-    const listener = async (path6, newStats) => {
+    const listener = async (path8, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -1893,18 +2748,18 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path6);
+            this.fsw._closeFile(path8);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path6, closer2);
+              this.fsw._addPathCloser(path8, closer2);
           } else {
             prevStats = newStats2;
           }
         } catch (error) {
-          this.fsw._remove(dirname3, basename4);
+          this.fsw._remove(dirname3, basename5);
         }
-      } else if (parent.has(basename4)) {
+      } else if (parent.has(basename5)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -1929,7 +2784,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path6, item) {
+  async _handleSymlink(entry, directory, path8, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -1939,7 +2794,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path6);
+        linkPath = await fsrealpath(path8);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -1949,12 +2804,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path6, entry.stats);
+          this.fsw._emit(EV.CHANGE, path8, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path6, entry.stats);
+        this.fsw._emit(EV.ADD, path8, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -1983,9 +2838,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path6 = sysPath.join(directory, item);
+      let path8 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path6, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path8, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -1994,11 +2849,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path6 = sysPath.join(dir, sysPath.relative(dir, path6));
-        this._addToNodeFs(path6, initialAdd, wh, depth + 1);
+        path8 = sysPath.join(dir, sysPath.relative(dir, path8));
+        this._addToNodeFs(path8, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -2007,7 +2862,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve3(void 0);
+        resolve4(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -2064,13 +2919,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path6, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path8, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path6) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path8) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path6);
+    const wh = this.fsw._getWatchHelpers(path8);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -2086,8 +2941,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path6);
-        const targetPath = follow ? await fsrealpath(path6) : path6;
+        const absPath = sysPath.resolve(path8);
+        const targetPath = follow ? await fsrealpath(path8) : path8;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -2097,29 +2952,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path6) : path6;
+        const targetPath = follow ? await fsrealpath(path8) : path8;
         if (this.fsw.closed)
           return;
         const parent = sysPath.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path6, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path8, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path6), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path8), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path6, closer);
+        this.fsw._addPathCloser(path8, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path6;
+        return path8;
       }
     }
   }
@@ -2162,26 +3017,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path6) {
-  if (typeof path6 !== "string")
+function normalizePath(path8) {
+  if (typeof path8 !== "string")
     throw new Error("string expected");
-  path6 = sysPath2.normalize(path6);
-  path6 = path6.replace(/\\/g, "/");
+  path8 = sysPath2.normalize(path8);
+  path8 = path8.replace(/\\/g, "/");
   let prepend = false;
-  if (path6.startsWith("//"))
+  if (path8.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path6.match(DOUBLE_SLASH_RE2))
-    path6 = path6.replace(DOUBLE_SLASH_RE2, "/");
+  while (path8.match(DOUBLE_SLASH_RE2))
+    path8 = path8.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path6 = "/" + path6;
-  return path6;
+    path8 = "/" + path8;
+  return path8;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path6 = normalizePath(testString);
+  const path8 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path6, stats)) {
+    if (pattern(path8, stats)) {
       return true;
     }
   }
@@ -2221,19 +3076,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path6) => toUnix(sysPath2.normalize(toUnix(path6)));
-var normalizeIgnored = (cwd = "") => (path6) => {
-  if (typeof path6 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path6) ? path6 : sysPath2.join(cwd, path6));
+var normalizePathToUnix = (path8) => toUnix(sysPath2.normalize(toUnix(path8)));
+var normalizeIgnored = (cwd = "") => (path8) => {
+  if (typeof path8 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path8) ? path8 : sysPath2.join(cwd, path8));
   } else {
-    return path6;
+    return path8;
   }
 };
-var getAbsolutePath = (path6, cwd) => {
-  if (sysPath2.isAbsolute(path6)) {
-    return path6;
+var getAbsolutePath = (path8, cwd) => {
+  if (sysPath2.isAbsolute(path8)) {
+    return path8;
   }
-  return sysPath2.join(cwd, path6);
+  return sysPath2.join(cwd, path8);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -2288,10 +3143,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path6, follow, fsw) {
+  constructor(path8, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path6;
-    this.path = path6 = path6.replace(REPLACER_RE, "");
+    const watchPath = path8;
+    this.path = path8 = path8.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -2413,20 +3268,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path6) => {
-        const absPath = getAbsolutePath(path6, cwd);
+      paths = paths.map((path8) => {
+        const absPath = getAbsolutePath(path8, cwd);
         return absPath;
       });
     }
-    paths.forEach((path6) => {
-      this._removeIgnoredPath(path6);
+    paths.forEach((path8) => {
+      this._removeIgnoredPath(path8);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path6) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path6, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path8) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path8, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -2448,17 +3303,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path6) => {
-      if (!sysPath2.isAbsolute(path6) && !this._closers.has(path6)) {
+    paths.forEach((path8) => {
+      if (!sysPath2.isAbsolute(path8) && !this._closers.has(path8)) {
         if (cwd)
-          path6 = sysPath2.join(cwd, path6);
-        path6 = sysPath2.resolve(path6);
+          path8 = sysPath2.join(cwd, path8);
+        path8 = sysPath2.resolve(path8);
       }
-      this._closePath(path6);
-      this._addIgnoredPath(path6);
-      if (this._watched.has(path6)) {
+      this._closePath(path8);
+      this._addIgnoredPath(path8);
+      if (this._watched.has(path8)) {
         this._addIgnoredPath({
-          path: path6,
+          path: path8,
           recursive: true
         });
       }
@@ -2522,38 +3377,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path6, stats) {
+  async _emit(event, path8, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path6 = sysPath2.normalize(path6);
+      path8 = sysPath2.normalize(path8);
     if (opts.cwd)
-      path6 = sysPath2.relative(opts.cwd, path6);
-    const args = [path6];
+      path8 = sysPath2.relative(opts.cwd, path8);
+    const args = [path8];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path6))) {
+    if (awf && (pw = this._pendingWrites.get(path8))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path6, [event, ...args]);
+        this._pendingUnlinks.set(path8, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path7) => {
+          this._pendingUnlinks.forEach((entry, path9) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path7);
+            this._pendingUnlinks.delete(path9);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path6)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path8)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path6);
+        this._pendingUnlinks.delete(path8);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -2571,16 +3426,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path6, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path8, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path6, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path8, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path6) : path6;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path8) : path8;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -2611,23 +3466,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path6, timeout) {
+  _throttle(actionType, path8, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path6);
+    const actionPath = action.get(path8);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path6);
+      const item = action.get(path8);
       const count = item ? item.count : 0;
-      action.delete(path6);
+      action.delete(path8);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -2635,7 +3490,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path6, thr);
+    action.set(path8, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -2649,44 +3504,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path6, threshold, event, awfEmit) {
+  _awaitWriteFinish(path8, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path6;
-    if (this.options.cwd && !sysPath2.isAbsolute(path6)) {
-      fullPath = sysPath2.join(this.options.cwd, path6);
+    let fullPath = path8;
+    if (this.options.cwd && !sysPath2.isAbsolute(path8)) {
+      fullPath = sysPath2.join(this.options.cwd, path8);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path6)) {
+        if (err || !writes.has(path8)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path6).lastChange = now2;
+          writes.get(path8).lastChange = now2;
         }
-        const pw = writes.get(path6);
+        const pw = writes.get(path8);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path6);
+          writes.delete(path8);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path6)) {
-      writes.set(path6, {
+    if (!writes.has(path8)) {
+      writes.set(path8, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path6);
+          writes.delete(path8);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -2697,8 +3552,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path6, stats) {
-    if (this.options.atomic && DOT_RE.test(path6))
+  _isIgnored(path8, stats) {
+    if (this.options.atomic && DOT_RE.test(path8))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -2708,17 +3563,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path6, stats);
+    return this._userIgnored(path8, stats);
   }
-  _isntIgnored(path6, stat4) {
-    return !this._isIgnored(path6, stat4);
+  _isntIgnored(path8, stat4) {
+    return !this._isIgnored(path8, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path6) {
-    return new WatchHelper(path6, this.options.followSymlinks, this);
+  _getWatchHelpers(path8) {
+    return new WatchHelper(path8, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -2750,63 +3605,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path6 = sysPath2.join(directory, item);
-    const fullPath = sysPath2.resolve(path6);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path6) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path6, 100))
+    const path8 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path8);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path8) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path8, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path6);
+    const wp = this._getWatchedDir(path8);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path6, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path8, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path6;
+    let relPath = path8;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path6);
+      relPath = sysPath2.relative(this.options.cwd, path8);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path6);
+    this._watched.delete(path8);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path6))
-      this._emit(eventName, path6);
-    this._closePath(path6);
+    if (wasTracked && !this._isIgnored(path8))
+      this._emit(eventName, path8);
+    this._closePath(path8);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path6) {
-    this._closeFile(path6);
-    const dir = sysPath2.dirname(path6);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path6));
+  _closePath(path8) {
+    this._closeFile(path8);
+    const dir = sysPath2.dirname(path8);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path8));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path6) {
-    const closers = this._closers.get(path6);
+  _closeFile(path8) {
+    const closers = this._closers.get(path8);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path6);
+    this._closers.delete(path8);
   }
-  _addPathCloser(path6, closer) {
+  _addPathCloser(path8, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path6);
+    let list = this._closers.get(path8);
     if (!list) {
       list = [];
-      this._closers.set(path6, list);
+      this._closers.set(path8, list);
     }
     list.push(closer);
   }
@@ -2837,56 +3692,184 @@ var esm_default = { watch, FSWatcher };
 
 // src/watch.ts
 var DEBOUNCE_MS = 1200;
+var LIMIT_REFRESH_MS = 6e4;
+var FALLBACK_SCAN_MS = 5e3;
+var DEVICE_HEARTBEAT_MS = 60 * 6e4;
+var CLOUD_SYNC_INTERVAL_MS = 30 * 6e4;
+var MAX_CLOUD_WRITES_PER_DAY = 16;
+var QUOTA_RETRY_MS = 15 * 6e4;
+var QUOTA_RETRY_JITTER_MS = 5 * 6e4;
 async function watch2(runner) {
-  await safeSync(runner, "startup");
+  const startupRetryAfter = await safeSync(runner, {
+    reason: "startup",
+    refreshLimits: true,
+    forceDeviceHeartbeat: true,
+    deviceHeartbeatMs: DEVICE_HEARTBEAT_MS,
+    cloudSyncIntervalMs: CLOUD_SYNC_INTERVAL_MS,
+    maxCloudWritesPerDay: MAX_CLOUD_WRITES_PER_DAY
+  });
   const paths = runner.watchPaths();
   const watcher = esm_default.watch(paths, {
     ignoreInitial: true,
     awaitWriteFinish: { stabilityThreshold: 400, pollInterval: 100 },
-    ignored: (p) => !(p.endsWith(".jsonl") || !p.includes("."))
+    // Never infer "file" from dots in the absolute path: the provider roots
+    // themselves are named .claude and .codex on every supported platform.
+    ignored: (p, stats) => Boolean(stats?.isFile() && !isUsageFile(p))
   });
   let timer;
-  let pending = false;
+  let pending;
   let running = false;
-  const schedule = () => {
+  let scheduledAt = 0;
+  let blockedUntil = startupRetryAfter ? Date.now() + startupRetryAfter : 0;
+  const schedule = (request, delay = DEBOUNCE_MS) => {
+    pending = mergeRequests(pending, request);
+    if (running) return;
+    const target = Math.max(Date.now() + delay, blockedUntil);
+    if (timer && scheduledAt <= target) return;
     if (timer) clearTimeout(timer);
+    scheduledAt = target;
     timer = setTimeout(async () => {
-      if (running) {
-        pending = true;
-        return;
-      }
+      timer = void 0;
+      scheduledAt = 0;
+      const next = pending;
+      pending = void 0;
+      if (!next) return;
       running = true;
-      await safeSync(runner, "change");
+      const retryAfterMs = await safeSync(runner, next);
       running = false;
+      if (retryAfterMs) {
+        blockedUntil = Date.now() + retryAfterMs;
+        pending = mergeRequests(pending, next);
+      } else {
+        blockedUntil = 0;
+      }
       if (pending) {
-        pending = false;
-        schedule();
+        const queued = pending;
+        pending = void 0;
+        schedule(queued, 0);
       }
-    }, DEBOUNCE_MS);
+    }, Math.max(0, target - Date.now()));
   };
-  watcher.on("add", schedule).on("change", schedule);
+  const turnRequest = (reason) => ({
+    reason,
+    refreshLimits: false,
+    deviceHeartbeatMs: DEVICE_HEARTBEAT_MS,
+    cloudSyncIntervalMs: CLOUD_SYNC_INTERVAL_MS,
+    maxCloudWritesPerDay: MAX_CLOUD_WRITES_PER_DAY
+  });
+  watcher.on("add", () => schedule(turnRequest("change"))).on("change", () => schedule(turnRequest("change")));
+  const fallbackTimer = setInterval(() => schedule(turnRequest("fallback"), 0), FALLBACK_SCAN_MS);
+  const refreshTimer = setInterval(
+    () => schedule(
+      {
+        reason: "limits",
+        refreshLimits: true,
+        deviceHeartbeatMs: DEVICE_HEARTBEAT_MS,
+        cloudSyncIntervalMs: CLOUD_SYNC_INTERVAL_MS,
+        maxCloudWritesPerDay: MAX_CLOUD_WRITES_PER_DAY
+      },
+      0
+    ),
+    LIMIT_REFRESH_MS
+  );
   console.log(`Watching for usage in:
   ${paths.join("\n  ")}
 Press Ctrl+C to stop.`);
-  await new Promise((resolve3) => {
+  await new Promise((resolve4) => {
     process.on("SIGINT", () => {
-      void watcher.close().then(resolve3);
+      clearInterval(refreshTimer);
+      clearInterval(fallbackTimer);
+      if (timer) clearTimeout(timer);
+      void watcher.close().then(resolve4);
     });
   });
 }
-async function safeSync(runner, reason) {
+async function safeSync(runner, request) {
   try {
-    const { newTurns, byProvider } = await runner.syncOnce();
-    if (newTurns > 0) {
+    const { reason, ...options } = request;
+    const { processedTurns, byProvider, published, cloudWritesToday } = await runner.syncOnce(options);
+    if (processedTurns > 0) {
       const detail = Object.entries(byProvider).map(([p, n]) => `${p}:${n}`).join(" ");
-      console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] synced ${newTurns} new turn(s) (${detail})`);
+      console.log(
+        `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] processed ${processedTurns} turn(s) locally (${detail}); ` + (published ? `cloud snapshot published (${cloudWritesToday}/16 today)` : "cloud snapshot queued")
+      );
     } else if (reason === "startup") {
-      console.log(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] up to date`);
+      console.log(
+        `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] local snapshot ready; ` + (published ? `cloud snapshot published (${cloudWritesToday}/16 today)` : "cloud snapshot queued")
+      );
     }
   } catch (err) {
+    if (err instanceof FirestoreRestError && err.status === 429) {
+      const retryAfter = Math.max(
+        err.retryAfterMs ?? 0,
+        QUOTA_RETRY_MS + Math.floor(Math.random() * QUOTA_RETRY_JITTER_MS)
+      );
+      console.error(
+        `Cloud sync paused: Firestore quota is exhausted; the local snapshot is safe. Retrying in ${Math.ceil(retryAfter / 6e4)}m.`
+      );
+      return retryAfter;
+    }
     console.error(`Sync error: ${err.message}`);
+    return 15e3;
   }
 }
+function mergeRequests(current, incoming) {
+  if (!current) return incoming;
+  return {
+    reason: incoming.reason === "change" || current.reason === "change" ? "change" : incoming.reason,
+    refreshLimits: Boolean(current.refreshLimits || incoming.refreshLimits),
+    forceDeviceHeartbeat: Boolean(current.forceDeviceHeartbeat || incoming.forceDeviceHeartbeat),
+    deviceHeartbeatMs: Math.min(
+      current.deviceHeartbeatMs ?? DEVICE_HEARTBEAT_MS,
+      incoming.deviceHeartbeatMs ?? DEVICE_HEARTBEAT_MS
+    ),
+    cloudSyncIntervalMs: Math.min(
+      current.cloudSyncIntervalMs ?? CLOUD_SYNC_INTERVAL_MS,
+      incoming.cloudSyncIntervalMs ?? CLOUD_SYNC_INTERVAL_MS
+    ),
+    maxCloudWritesPerDay: Math.min(
+      current.maxCloudWritesPerDay ?? MAX_CLOUD_WRITES_PER_DAY,
+      incoming.maxCloudWritesPerDay ?? MAX_CLOUD_WRITES_PER_DAY
+    )
+  };
+}
+function isUsageFile(filePath) {
+  return filePath.endsWith(".jsonl") || filePath.endsWith(".sqlite") || filePath.endsWith(".sqlite-wal");
+}
+
+// src/update-check.ts
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var REGISTRY_URL = "https://registry.npmjs.org/tokelytics/latest";
+async function agentUpdateMessage(force = false) {
+  try {
+    const state = await loadUpdateState();
+    const checkedAt = Date.parse(state.checkedAt ?? "");
+    let latest = state.latestVersion;
+    if (force || !Number.isFinite(checkedAt) || Date.now() - checkedAt >= CHECK_INTERVAL_MS) {
+      const response = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(5e3) });
+      if (!response.ok) return void 0;
+      const body = await response.json();
+      latest = body.version;
+      await saveUpdateState({
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        latestVersion: latest
+      });
+    }
+    if (latest && compareVersions(latest, AGENT_VERSION) > 0) {
+      return `Tokelytics ${latest} is available. Update with: npm install -g tokelytics@latest`;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function compareVersions(left, right) {
+  const a = left.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const b = right.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    if ((a[i] ?? 0) !== (b[i] ?? 0)) return (a[i] ?? 0) > (b[i] ?? 0) ? 1 : -1;
+  }
+  return 0;
+}
 
 // src/cli.ts
 var USAGE = `Tokelytics agent
@@ -2894,7 +3877,7 @@ var USAGE = `Tokelytics agent
 Usage:
   tokelytics login              Sign in by approving in your browser
   tokelytics sync               Run one incremental sync to your dashboard
-  tokelytics watch              Stream usage in realtime (filesystem watcher)
+  tokelytics watch              Watch usage and refresh the cloud snapshot
   tokelytics status             Show current sign-in and device
   tokelytics logout             Forget stored credentials
 `;
@@ -2910,24 +3893,39 @@ async function main(argv) {
       } catch (err) {
         console.warn(`(Couldn't register device yet \u2014 will retry on first sync: ${err.message})`);
       }
-      console.log('Done. Now run "tokelytics watch" to stream your usage.');
+      console.log('Done. Now run "npx tokelytics@latest watch" to keep your dashboard updated.');
       return 0;
     }
     case "sync": {
-      const runner = await createRunner();
-      const { newTurns, byProvider } = await runner.syncOnce();
-      const detail = Object.entries(byProvider).map(([p, n]) => `${p}:${n}`).join(" ") || "none";
-      console.log(`Synced ${newTurns} new turn(s) (${detail}).`);
+      const update = await agentUpdateMessage();
+      if (update) console.warn(update);
+      const lock = await acquireWatchLock();
+      try {
+        const runner = await createRunner();
+        const { processedTurns, processedLimits, byProvider } = await runner.syncOnce();
+        const detail = Object.entries(byProvider).map(([p, n]) => `${p}:${n}`).join(" ") || "none";
+        console.log(`Processed ${processedTurns} turn(s) (${detail}); refreshed ${processedLimits} usage provider(s).`);
+      } finally {
+        await lock.release();
+      }
       return 0;
     }
     case "watch": {
-      const runner = await createRunner();
-      await watch2(runner);
+      const lock = await acquireWatchLock();
+      try {
+        const update = await agentUpdateMessage();
+        if (update) console.warn(update);
+        const runner = await createRunner();
+        await watch2(runner);
+      } finally {
+        await lock.release();
+      }
       return 0;
     }
     case "status": {
       const creds = await loadCredentials();
       const state = await loadState();
+      console.log(`Agent version: ${AGENT_VERSION}`);
       if (!creds) {
         console.log('Not signed in. Run "tokelytics login".');
       } else {
@@ -2943,6 +3941,8 @@ async function main(argv) {
       } catch (err) {
         console.log(`Session needs refresh: ${err.message}`);
       }
+      const update = await agentUpdateMessage(true);
+      if (update) console.log(update);
       return 0;
     }
     case "logout": {