token-rats 0.0.4 → 0.1.0

package/dist/index.js

@@ -385,8 +385,8 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -508,11 +508,11 @@ var errorUtil;
 var _ZodEnum_cache;
 var _ZodNativeEnum_cache;
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -3948,12 +3948,20 @@ var z = /* @__PURE__ */ Object.freeze({
 
 // ../contracts/src/session.ts
 var Source = z.enum(["claude-code", "cursor", "codex"]);
+var Provider = z.enum(["anthropic", "openai", "cursor", "unknown"]);
 var SessionRecord = z.object({
   id: z.string().min(1),
   source: Source,
+  provider: Provider.optional(),
   model: z.string().min(1),
   inTokens: z.number().int().nonnegative(),
   outTokens: z.number().int().nonnegative(),
+  /** Anthropic cache reads / OpenAI `cached_input_tokens`. Billed cheap-or-free. */
+  cacheReadTokens: z.number().int().nonnegative().optional(),
+  /** Anthropic cache creation tokens. Billed at a premium for first-write only. */
+  cacheWriteTokens: z.number().int().nonnegative().optional(),
+  /** OpenAI reasoning output tokens (o-series / Codex). Billed at output rate. */
+  reasoningTokens: z.number().int().nonnegative().optional(),
   costUsdCents: z.number().int().nonnegative(),
   startedAt: z.number().int().positive(),
   endedAt: z.number().int().positive(),
@@ -3968,19 +3976,38 @@ var User = z.object({
   /** Present only when the caller is the user themselves or the user is public. */
   bio: z.string().max(200).nullable().optional(),
   twitterHandle: z.string().max(50).nullable().optional(),
-  publicProfile: z.boolean().optional()
+  /**
+   * True iff `twitter_handle` came from the OAuth flow (i.e. `twitter_user_id`
+   * is set). Self-only — used by settings UI to distinguish manual legacy
+   * handles from verified ones.
+   */
+  twitterVerified: z.boolean().optional(),
+  publicProfile: z.boolean().optional(),
+  /**
+   * Primary verified GitHub email, captured at OAuth callback time. Self-only
+   * (other readers never see this field). `null` when GitHub didn't return a
+   * verified email — the user sees a banner asking them to add one.
+   */
+  email: z.string().email().nullable().optional()
 });
 var PublicProfileSettings = z.object({
   publicProfile: z.boolean().optional(),
-  bio: z.string().max(200).nullable().optional(),
-  twitterHandle: z.string().max(50).nullable().optional()
+  bio: z.string().max(200).nullable().optional()
 });
 var Profile = User.extend({
   totals: z.object({
     today: z.object({ tokens: z.number().int(), costUsdCents: z.number().int() }),
     week: z.object({ tokens: z.number().int(), costUsdCents: z.number().int() }),
     allTime: z.object({ tokens: z.number().int(), costUsdCents: z.number().int() })
-  })
+  }),
+  /** Number of users this user has brought in via their referral link. */
+  referredCount: z.number().int().nonnegative().optional(),
+  /**
+   * The profile owner's referral code. Self-only — present only when the
+   * caller is viewing their own profile, so the page can render a
+   * copy-able invite link without a separate fetch to /v1/me/referral.
+   */
+  referralCode: z.string().optional()
 });
 var AutobiographyStats = z.object({
   handle: z.string(),
@@ -4016,13 +4043,24 @@ var Room = z.object({
   name: z.string().min(1).max(64),
   ownerId: z.string(),
   orgId: z.string().nullable(),
-  createdAt: z.number().int().positive()
+  createdAt: z.number().int().positive(),
+  /** v1.2: public country-locked groups. `country` is set iff `isPublic` is true. */
+  isPublic: z.boolean(),
+  /** ISO-3166-1 alpha-2 (`cf-ipcountry` of the creator). Null on private rooms. */
+  country: z.string().min(2).max(2).nullable(),
+  /**
+   * True iff this room is the caller's pinned room. Populated only on
+   * caller-scoped responses (e.g. GET /v1/me/rooms); absent elsewhere.
+   */
+  isPinned: z.boolean().optional()
 });
 var RoomMember = z.object({
   userId: z.string(),
   handle: z.string(),
   avatarUrl: z.string().url().nullable(),
-  joinedAt: z.number().int().positive()
+  joinedAt: z.number().int().positive(),
+  /** OAuth-verified X handle, when present. Manual handles are not surfaced. */
+  twitterHandle: z.string().max(50).nullable().optional()
 });
 
 // ../contracts/src/leaderboard.ts
@@ -4088,8 +4126,25 @@ var ChallengeWithLeaderboard = Challenge.extend({
   winnerHandle: z.string().nullable()
 });
 
+// ../contracts/src/referral.ts
+var ReferredUser = z.object({
+  handle: z.string(),
+  avatarUrl: z.string().url().nullable(),
+  /** Unix ms — when the referred user signed up. */
+  createdAt: z.number().int()
+});
+var ReferralStats = z.object({
+  /** The user's unique referral code (URL-safe, ~8 chars). */
+  code: z.string(),
+  /** Total users referred. */
+  count: z.number().int().nonnegative(),
+  /** Most recent referred users (newest first), capped server-side. */
+  recent: z.array(ReferredUser)
+});
+
 // ../contracts/src/org.ts
-var OrgPlan = z.enum(["free", "pro"]);
+var OrgPlan = z.enum(["free", "student", "pro"]);
+var OrgStatus = z.enum(["pending", "approved"]);
 var OrgMemberRole = z.enum(["owner", "admin", "member"]);
 var OrgSlug = z.string().min(3).max(48).regex(/^[a-z0-9-]+$/, "Slug must be lowercase letters, numbers, and hyphens only");
 var Org = z.object({
@@ -4099,7 +4154,12 @@ var Org = z.object({
   plan: OrgPlan,
   seatCount: z.number().int().nonnegative(),
   githubOrgLogin: z.string().nullable(),
-  createdAt: z.number().int().positive()
+  createdAt: z.number().int().positive(),
+  /** v1.2: soft-create status. Approved orgs are fully usable; pending orgs are gated. */
+  status: OrgStatus,
+  requestedPlan: OrgPlan.nullable(),
+  founderEmail: z.string().email().nullable(),
+  founderName: z.string().nullable()
 });
 var OrgMember = z.object({
   userId: z.string(),
@@ -4144,8 +4204,17 @@ var OrgDashboard = z.object({
 var CreateOrgRequest = z.object({
   name: z.string().min(1).max(64),
   slug: OrgSlug,
-  githubOrgLogin: z.string().optional()
+  githubOrgLogin: z.string().optional(),
+  // v1.2 soft-create — required fields, trust-on-submit.
+  founderEmail: z.string().email(),
+  founderName: z.string().min(1).max(80).optional(),
+  requestedPlan: OrgPlan
+});
+var PatchOrgRequest = z.object({
+  founderEmail: z.string().email().optional(),
+  founderName: z.string().min(1).max(80).optional()
 });
+var PatchOrgResponse = z.object({ org: Org });
 var CreateOrgResponse = z.object({ org: Org });
 var GetOrgResponse = z.object({
   org: Org,
@@ -4160,6 +4229,20 @@ var CreateOrgInviteRequest = z.object({
 var CreateOrgInviteResponse = z.object({ invite: OrgInvite });
 var AcceptOrgInviteResponse = z.object({ ok: z.boolean() });
 var GetOrgDashboardResponse = z.object({ dashboard: OrgDashboard });
+var AdminPendingOrg = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: OrgSlug.nullable(),
+  requestedPlan: OrgPlan.nullable(),
+  founderEmail: z.string().email().nullable(),
+  founderName: z.string().nullable(),
+  founderHandle: z.string(),
+  createdAt: z.number().int().positive()
+});
+var GetPendingOrgsResponse = z.object({
+  orgs: z.array(AdminPendingOrg)
+});
+var ApproveOrgResponse = z.object({ org: Org });
 
 // ../contracts/src/api.ts
 var GetMeResponse = z.object({ user: User });
@@ -4171,7 +4254,9 @@ var UploadSessionsResponse = z.object({
   duplicates: z.number().int().nonnegative()
 });
 var CreateRoomRequest = z.object({
-  name: z.string().min(1).max(64)
+  name: z.string().min(1).max(64),
+  /** v1.2: when true the room is publicly listed in /groups for its country. */
+  isPublic: z.boolean().default(false)
 });
 var CreateRoomResponse = z.object({ room: Room });
 var JoinRoomResponse = z.object({ room: Room });
@@ -4191,14 +4276,60 @@ var HeatmapDay = z.object({
   tokens: z.number().int().nonnegative(),
   sessions: z.number().int().nonnegative()
 });
+var HeatmapRange = z.enum(["30d", "52w"]);
 var Heatmap = z.object({
+  range: HeatmapRange,
   from: z.string(),
   // YYYY-MM-DD UTC, inclusive
   to: z.string(),
   // YYYY-MM-DD UTC, inclusive
   days: z.array(HeatmapDay)
 });
+var GetHeatmapQuery = z.object({
+  range: HeatmapRange.default("30d")
+});
 var GetHeatmapResponse = z.object({ heatmap: Heatmap });
+var RoomSummary = z.object({
+  code: z.string(),
+  name: z.string(),
+  /** Future: true once feature #6 lands. Always false for now. */
+  isPublic: z.boolean(),
+  /** ISO country code (e.g. "DE") when isPublic is true; null otherwise. */
+  country: z.string().nullable(),
+  memberCount: z.number().int().nonnegative(),
+  total30dTokens: z.number().int().nonnegative(),
+  total30dCostUsdCents: z.number().int().nonnegative()
+});
+var GetRoomSummaryResponse = z.object({ summary: RoomSummary });
+var PublicGroupRow = z.object({
+  code: z.string(),
+  name: z.string(),
+  country: z.string().min(2).max(2),
+  memberCount: z.number().int().nonnegative(),
+  total30dTokens: z.number().int().nonnegative(),
+  total30dCostUsdCents: z.number().int().nonnegative()
+});
+var CountryBoardRow = z.object({
+  rank: z.number().int().positive(),
+  userId: z.string(),
+  handle: z.string(),
+  avatarUrl: z.string().url().nullable(),
+  tokens: z.number().int().nonnegative(),
+  costUsdCents: z.number().int().nonnegative(),
+  sessions: z.number().int().nonnegative()
+});
+var GetGroupsResponse = z.object({
+  country: z.string().min(2).max(2).nullable(),
+  groups: z.array(PublicGroupRow),
+  /** Public users in the viewer's country, ranked by trailing-30d tokens. */
+  userBoard: z.array(CountryBoardRow)
+});
+var GroupStreak = z.object({
+  currentStreak: z.number().int().nonnegative(),
+  /** Yesterday in YYYY-MM-DD UTC. */
+  asOf: z.string()
+});
+var GetGroupStreakResponse = z.object({ groupStreak: GroupStreak });
 var GetMyRoomsResponse = z.object({
   rooms: z.array(Room)
 });
@@ -4234,6 +4365,7 @@ var GetTrendingResponse = z.object({
   range: LeaderboardRange,
   generatedAt: z.number().int().positive()
 });
+var GetReferralResponse = z.object({ referral: ReferralStats });
 var ReportAbuseRequest = z.object({
   targetHandle: z.string().min(1).max(100),
   reason: z.string().min(1).max(500)
@@ -4249,14 +4381,22 @@ var ENDPOINTS = {
   profile: (handle) => `/v1/u/${handle}`,
   autobiography: (handle) => `/v1/u/${handle}/autobiography`,
   profileHeatmap: (handle) => `/v1/u/${handle}/heatmap`,
+  // v1.2 room aggregates — auth optional, accessible to non-members.
+  roomSummary: (code) => `/v1/r/${code}/summary`,
+  roomHeatmap: (code) => `/v1/r/${code}/heatmap`,
+  roomGroupStreak: (code) => `/v1/r/${code}/group-streak`,
+  // v1.2 public country-locked groups list
+  groups: "/v1/groups",
   authGithubStart: "/v1/auth/github/start",
   authGithubCallback: "/v1/auth/github/callback",
+  authLogout: "/v1/auth/logout",
   authCliExchange: "/v1/auth/cli/exchange",
   authCliPoll: "/v1/auth/cli/poll",
   // Phase 2 Track G+H
   meRooms: "/v1/me/rooms",
   leaveRoom: (code) => `/v1/rooms/${code}/leave`,
   renameRoom: (code) => `/v1/rooms/${code}`,
+  pinRoom: (code) => `/v1/rooms/${code}/pin`,
   roomActivity: (code) => `/v1/rooms/${code}/activity`,
   roomStreaks: (code) => `/v1/rooms/${code}/streaks`,
   roomChallenges: (code) => `/v1/rooms/${code}/challenges`,
@@ -4270,6 +4410,10 @@ var ENDPOINTS = {
   patchMe: "/v1/me",
   trending: "/v1/trending",
   reportAbuse: "/v1/abuse/report",
+  // Affiliate / referral tracking
+  meReferral: "/v1/me/referral",
+  // v1.2 Track AD — friends derived from shared private rooms
+  meFriends: "/v1/me/friends",
   // Phase 3 Track O — Org plan
   orgs: "/v1/orgs",
   org: (slug) => `/v1/orgs/${slug}`,
@@ -4283,7 +4427,10 @@ var ENDPOINTS = {
   // Admin analytics (project-owner only)
   adminSignups: "/v1/admin/signups",
   adminActivity: "/v1/admin/activity",
-  adminReferrers: "/v1/admin/referrers"
+  adminReferrers: "/v1/admin/referrers",
+  // Admin org approval (v1.2)
+  adminOrgsPending: "/v1/admin/orgs/pending",
+  adminOrgApprove: (slug) => `/v1/admin/orgs/${slug}/approve`
 };
 
 // ../contracts/src/errors.ts
@@ -4369,20 +4516,37 @@ var AdminActivityResponse = z.object({
   generatedAt: z.number().int().positive()
 });
 var AdminReferrerRow = z.object({
-  /** A label describing the source of the signal. */
-  label: z.string(),
-  /** Number of users (or events) attributed to this label. */
+  handle: z.string(),
+  avatarUrl: z.string().url().nullable(),
+  /** Number of users this referrer has brought in. */
   count: z.number().int().nonnegative()
 });
 var AdminReferrersResponse = z.object({
-  /** True iff a real referral attribution column / table exists. */
-  tracked: z.boolean(),
-  /** Description of what `rows` represents (e.g. "First CLI source"). */
-  signal: z.string(),
   rows: z.array(AdminReferrerRow),
   generatedAt: z.number().int().positive()
 });
 
+// ../contracts/src/friends.ts
+var FriendSharedRoom = z.object({
+  code: z.string(),
+  name: z.string()
+});
+var FriendRow = z.object({
+  userId: z.string(),
+  handle: z.string(),
+  avatarUrl: z.string().url().nullable(),
+  twitterHandle: z.string().nullable().optional(),
+  publicProfile: z.boolean(),
+  sharedRooms: z.array(FriendSharedRoom),
+  tokens: z.number().int().nonnegative(),
+  costUsdCents: z.number().int().nonnegative(),
+  sessions: z.number().int().nonnegative()
+});
+var FriendsResponse = z.object({
+  range: LeaderboardRange,
+  friends: z.array(FriendRow)
+});
+
 // src/lib/api.ts
 var DEFAULT_API_URL = "https://api.tokenrats.com";
 function isTransient(status) {
@@ -4437,8 +4601,8 @@ var ApiClient = class {
     }
     throw lastErr;
   }
-  async post(path3, body) {
-    const url = `${this.apiUrl}${path3}`;
+  async post(path7, body) {
+    const url = `${this.apiUrl}${path7}`;
     const res = await this.fetchWithRetry(url, {
       method: "POST",
       headers: this.headers(),
@@ -4449,8 +4613,8 @@ var ApiClient = class {
     }
     return res.json();
   }
-  async get(path3) {
-    const url = `${this.apiUrl}${path3}`;
+  async get(path7) {
+    const url = `${this.apiUrl}${path7}`;
     const res = await this.fetchWithRetry(url, {
       method: "GET",
       headers: this.headers()
@@ -4687,68 +4851,8 @@ function logoutCommand() {
 }
 
 // src/commands/sync.ts
-import * as fs3 from "node:fs";
-
-// ../pricing/src/prices.ts
-var prices = {
-  models: {
-    // ── Anthropic / Claude ────────────────────────────────────────────────
-    "claude-opus-4-7": { inputPerMTok: 15, outputPerMTok: 75 },
-    "claude-opus-4-6": { inputPerMTok: 15, outputPerMTok: 75 },
-    "claude-sonnet-4-6": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-sonnet-4-5": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-haiku-4-5": { inputPerMTok: 0.8, outputPerMTok: 4 },
-    "claude-3-5-sonnet-20241022": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-3-5-sonnet-20240620": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-3-5-haiku-20241022": { inputPerMTok: 0.8, outputPerMTok: 4 },
-    "claude-3-opus-20240229": { inputPerMTok: 15, outputPerMTok: 75 },
-    "claude-3-sonnet-20240229": { inputPerMTok: 3, outputPerMTok: 15 },
-    "claude-3-haiku-20240307": { inputPerMTok: 0.25, outputPerMTok: 1.25 },
-    // ── OpenAI / Codex ────────────────────────────────────────────────────
-    // GPT-5 family. gpt-5-codex is the Codex CLI's public model; OpenAI's
-    // pricing page lists only input ($1.25/MTok). Output uses the same $10
-    // rate the broader GPT-5 base is publicly quoted at — flagged here for
-    // re-verification when OpenAI publishes an explicit output figure.
-    "gpt-5-codex": { inputPerMTok: 1.25, outputPerMTok: 10 },
-    "gpt-5-mini": { inputPerMTok: 0.25, outputPerMTok: 2 },
-    "gpt-5-nano": { inputPerMTok: 0.05, outputPerMTok: 0.4 },
-    "gpt-5-pro": { inputPerMTok: 15, outputPerMTok: 120 },
-    "gpt-5.5": { inputPerMTok: 5, outputPerMTok: 30 },
-    "codex-mini-latest": { inputPerMTok: 1.5, outputPerMTok: 6 },
-    // GPT-4 family.
-    "gpt-4o": { inputPerMTok: 2.5, outputPerMTok: 10 },
-    "gpt-4o-mini": { inputPerMTok: 0.15, outputPerMTok: 0.6 },
-    "gpt-4-turbo": { inputPerMTok: 10, outputPerMTok: 30 },
-    "gpt-4.1": { inputPerMTok: 2, outputPerMTok: 8 },
-    "gpt-4.1-mini": { inputPerMTok: 0.4, outputPerMTok: 1.6 },
-    "gpt-4.1-nano": { inputPerMTok: 0.1, outputPerMTok: 0.4 },
-    // Reasoning models (o-series).
-    o1: { inputPerMTok: 15, outputPerMTok: 60 },
-    "o1-mini": { inputPerMTok: 3, outputPerMTok: 12 },
-    // o3 was repriced in 2026; previously $10/$40, now $2/$8.
-    o3: { inputPerMTok: 2, outputPerMTok: 8 },
-    "o3-mini": { inputPerMTok: 1.1, outputPerMTok: 4.4 },
-    "o4-mini": { inputPerMTok: 1.1, outputPerMTok: 4.4 }
-  }
-};
-
-// ../pricing/src/index.ts
-var TABLE = prices.models;
-function priceOf(model, inTokens, outTokens) {
-  const p = TABLE[model] ?? matchPrefix(model);
-  if (!p) return { costUsdCents: 0, known: false };
-  const dollars = (inTokens * p.inputPerMTok + outTokens * p.outputPerMTok) / 1e6;
-  return { costUsdCents: Math.round(dollars * 100), known: true };
-}
-function matchPrefix(model) {
-  let best;
-  for (const [key, price] of Object.entries(TABLE)) {
-    if (model.startsWith(key) && (!best || key.length > best.key.length)) {
-      best = { key, price };
-    }
-  }
-  return best?.price;
-}
+import * as fs7 from "node:fs";
+import * as readline from "node:readline/promises";
 
 // ../parsers/src/hash.ts
 var FNV_PRIME = 16777619;
@@ -4811,6 +4915,8 @@ function parseClaudeCode(input) {
         endedAt: timestamp,
         inTokens: 0,
         outTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
         model: ""
       };
       sessions.set(sessionId, acc);
@@ -4829,10 +4935,10 @@ function parseClaudeCode(input) {
     const usage = msg.usage;
     if (typeof usage === "object" && usage !== null) {
       const u = usage;
-      const inputTokens = toNonNegInt(u.input_tokens);
-      const outputTokens = toNonNegInt(u.output_tokens);
-      acc.inTokens += inputTokens;
-      acc.outTokens += outputTokens;
+      acc.inTokens += toNonNegInt(u.input_tokens);
+      acc.outTokens += toNonNegInt(u.output_tokens);
+      acc.cacheReadTokens += toNonNegInt(u.cache_read_input_tokens);
+      acc.cacheWriteTokens += toNonNegInt(u.cache_creation_input_tokens);
     }
   }
   const results = [];
@@ -4841,7 +4947,7 @@ function parseClaudeCode(input) {
     const endedAt = acc.endedAt > 0 ? acc.endedAt : acc.startedAt;
     if (startedAt <= 0 || endedAt <= 0) continue;
     const model = acc.model.length > 0 ? acc.model : "unknown";
-    const { costUsdCents } = priceOf(model, acc.inTokens, acc.outTokens);
+    const costUsdCents = 0;
     const dedupeKey = computeDedupeKey(
       "claude-code",
       model,
@@ -4852,9 +4958,12 @@ function parseClaudeCode(input) {
     results.push({
       id: `claude-code:${acc.sessionId}`,
       source: "claude-code",
+      provider: "anthropic",
       model,
       inTokens: acc.inTokens,
       outTokens: acc.outTokens,
+      cacheReadTokens: acc.cacheReadTokens,
+      cacheWriteTokens: acc.cacheWriteTokens,
       costUsdCents,
       startedAt,
       endedAt,
@@ -4926,6 +5035,8 @@ function parseCodex(input) {
       const reasoning = toNonNegInt2(t.reasoning_output_tokens);
       acc.inTokens = Math.max(0, inputTotal - cachedInput);
       acc.outTokens = output + reasoning;
+      acc.cacheReadTokens = cachedInput;
+      acc.reasoningTokens = reasoning;
     }
   }
   const results = [];
@@ -4934,14 +5045,17 @@ function parseCodex(input) {
     const endedAt = acc.endedAt > 0 ? acc.endedAt : acc.startedAt;
     if (startedAt <= 0 || endedAt <= 0) continue;
     const model = acc.model.length > 0 ? acc.model : "unknown";
-    const { costUsdCents } = priceOf(model, acc.inTokens, acc.outTokens);
+    const costUsdCents = 0;
     const dedupeKey = computeDedupeKey("codex", model, startedAt, acc.inTokens, acc.outTokens);
     results.push({
       id: `codex:${acc.sessionId}`,
       source: "codex",
+      provider: "openai",
       model,
       inTokens: acc.inTokens,
       outTokens: acc.outTokens,
+      cacheReadTokens: acc.cacheReadTokens,
+      reasoningTokens: acc.reasoningTokens,
       costUsdCents,
       startedAt,
       endedAt,
@@ -4959,6 +5073,8 @@ function upsert(map, sessionId) {
       endedAt: 0,
       inTokens: 0,
       outTokens: 0,
+      cacheReadTokens: 0,
+      reasoningTokens: 0,
       model: ""
     };
     map.set(sessionId, acc);
@@ -4983,12 +5099,6 @@ var ESTIMATES = {
   composer: { inTokens: 1e4, outTokens: 2e3, model: "cursor-composer" }
   // "tab" deliberately omitted — see file header.
 };
-var INPUT_USD_PER_MTOK = 3;
-var OUTPUT_USD_PER_MTOK = 15;
-function estimatedCostCents(inTokens, outTokens) {
-  const dollars = inTokens / 1e6 * INPUT_USD_PER_MTOK + outTokens / 1e6 * OUTPUT_USD_PER_MTOK;
-  return Math.round(dollars * 100);
-}
 function parseCursor(input) {
   let text;
   if (typeof input === "string") {
@@ -5007,20 +5117,21 @@ function parseCursor(input) {
   for (const raw of rows) {
     if (typeof raw !== "object" || raw === null) continue;
     const row = raw;
-    const id = typeof row["id"] === "string" ? row["id"] : null;
+    const id = typeof row.id === "string" ? row.id : null;
     if (!id) continue;
-    const type = typeof row["type"] === "string" ? row["type"] : null;
+    const type = typeof row.type === "string" ? row.type : null;
     if (!type) continue;
-    const unixMs = typeof row["unixMs"] === "number" && isFinite(row["unixMs"]) && row["unixMs"] > 0 ? row["unixMs"] : null;
+    const unixMs = typeof row.unixMs === "number" && Number.isFinite(row.unixMs) && row.unixMs > 0 ? row.unixMs : null;
     if (unixMs === null) continue;
     const estimate = ESTIMATES[type];
     if (!estimate) continue;
     const { inTokens, outTokens, model } = estimate;
-    const costUsdCents = estimatedCostCents(inTokens, outTokens);
+    const costUsdCents = 0;
     const dedupeKey = computeDedupeKey("cursor", model, unixMs, inTokens, outTokens);
     results.push({
       id: `cursor:${id}`,
       source: "cursor",
+      provider: "cursor",
       model,
       inTokens,
       outTokens,
@@ -5034,7 +5145,7 @@ function parseCursor(input) {
 }
 
 // src/lib/cursor-extract.ts
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
@@ -5045,10 +5156,10 @@ function cursorWorkspaceStorageDir() {
     return join2(home, "Library", "Application Support", rel);
   }
   if (process.platform === "win32") {
-    const appData = process.env["APPDATA"] ?? join2(home, "AppData", "Roaming");
+    const appData = process.env.APPDATA ?? join2(home, "AppData", "Roaming");
     return join2(appData, rel);
   }
-  const xdgConfig = process.env["XDG_CONFIG_HOME"] ?? join2(home, ".config");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join2(home, ".config");
   return join2(xdgConfig, rel);
 }
 function discoverWorkspaceDbs() {
@@ -5136,9 +5247,9 @@ async function readGenerationsFromDb(dbPath) {
     for (const item of parsed) {
       if (typeof item !== "object" || item === null) continue;
       const r = item;
-      const id = typeof r["generationUUID"] === "string" ? r["generationUUID"] : null;
-      const type = typeof r["type"] === "string" ? r["type"] : null;
-      const unixMs = typeof r["unixMs"] === "number" && isFinite(r["unixMs"]) && r["unixMs"] > 0 ? r["unixMs"] : null;
+      const id = typeof r.generationUUID === "string" ? r.generationUUID : null;
+      const type = typeof r.type === "string" ? r.type : null;
+      const unixMs = typeof r.unixMs === "number" && Number.isFinite(r.unixMs) && r.unixMs > 0 ? r.unixMs : null;
       if (!id || !type || unixMs === null) continue;
       out.push({ id, type, unixMs });
     }
@@ -5187,17 +5298,373 @@ async function extractCursorGenerations() {
   }
   return { rows, dbCount: dbPaths.length, skipped: null };
 }
+async function extractCursorGenerationsDelta(lastMtimes, cap = 10) {
+  const dbPaths = discoverWorkspaceDbs();
+  if (dbPaths.length === 0) {
+    return { rows: [], newMtimes: /* @__PURE__ */ new Map(), scanned: 0, opened: 0 };
+  }
+  const stamped = [];
+  for (const p of dbPaths) {
+    try {
+      stamped.push({ path: p, mtimeMs: statSync(p).mtimeMs });
+    } catch {
+    }
+  }
+  stamped.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const head = stamped.slice(0, cap);
+  const newMtimes = new Map(lastMtimes);
+  const rows = [];
+  let opened = 0;
+  for (const { path: path7, mtimeMs } of head) {
+    const prev = lastMtimes.get(path7) ?? 0;
+    if (mtimeMs <= prev) continue;
+    opened++;
+    try {
+      const perDb = await readGenerationsFromDb(path7);
+      rows.push(...perDb);
+      newMtimes.set(path7, mtimeMs);
+    } catch {
+    }
+  }
+  return { rows, newMtimes, scanned: stamped.length, opened };
+}
 
-// src/lib/discover.ts
+// src/lib/daemon/linux.ts
+import { spawnSync } from "node:child_process";
+import * as fs3 from "node:fs";
+import * as os3 from "node:os";
+import * as path3 from "node:path";
+
+// src/lib/daemon/paths.ts
 import * as fs2 from "node:fs";
 import * as os2 from "node:os";
 import * as path2 from "node:path";
+function configBase() {
+  if (process.platform === "darwin") {
+    return path2.join(os2.homedir(), "Library", "Application Support");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME;
+  return xdg ?? path2.join(os2.homedir(), ".config");
+}
+function daemonStateDir() {
+  return path2.join(configBase(), "token-rats");
+}
+function daemonLogDir() {
+  return path2.join(daemonStateDir(), "logs");
+}
+function daemonStateFile() {
+  return path2.join(daemonStateDir(), "daemon-state.json");
+}
+function cliEntrypoint() {
+  const node = process.execPath;
+  const script = fs2.realpathSync(process.argv[1] ?? "");
+  return { node, script };
+}
+function entrypointIsEphemeral() {
+  const { script } = cliEntrypoint();
+  return script.includes("_npx") || script.includes(".npm/_cacache");
+}
+function ensureDaemonDirs() {
+  fs2.mkdirSync(daemonStateDir(), { recursive: true });
+  fs2.mkdirSync(daemonLogDir(), { recursive: true });
+}
+
+// src/lib/daemon/linux.ts
+var UNIT = "token-rats-watch.service";
+function unitPath() {
+  const xdg = process.env.XDG_CONFIG_HOME ?? path3.join(os3.homedir(), ".config");
+  return path3.join(xdg, "systemd", "user", UNIT);
+}
+function renderUnit(node, script, logDir) {
+  return `[Unit]
+Description=Token Rats background watcher
+After=default.target
+
+[Service]
+Type=simple
+ExecStart=${node} ${script} watch --daemon
+Restart=on-failure
+RestartSec=30
+StandardOutput=append:${path3.join(logDir, "watch.log")}
+StandardError=append:${path3.join(logDir, "watch.err.log")}
+Nice=10
+
+[Install]
+WantedBy=default.target
+`;
+}
+function systemctl(args) {
+  const r = spawnSync("systemctl", ["--user", ...args], { encoding: "utf8" });
+  return {
+    ok: r.status === 0,
+    stdout: r.stdout ?? "",
+    stderr: r.stderr ?? ""
+  };
+}
+var SystemdUnavailableError = class extends Error {
+  constructor() {
+    super("systemctl --user is unavailable on this system");
+    this.name = "SystemdUnavailableError";
+  }
+};
+function assertSystemd() {
+  const r = spawnSync("systemctl", ["--user", "--version"], { encoding: "utf8" });
+  if (r.status !== 0) throw new SystemdUnavailableError();
+}
+function lingerEnabled() {
+  const user = os3.userInfo().username;
+  const r = spawnSync("loginctl", ["show-user", user], { encoding: "utf8" });
+  if (r.status !== 0) return false;
+  return /Linger=yes/.test(r.stdout);
+}
+function installLinux(node, script) {
+  assertSystemd();
+  ensureDaemonDirs();
+  const file = unitPath();
+  fs3.mkdirSync(path3.dirname(file), { recursive: true });
+  const logDir = daemonLogDir();
+  fs3.writeFileSync(file, renderUnit(node, script, logDir), { encoding: "utf8", mode: 420 });
+  const reload = systemctl(["daemon-reload"]);
+  if (!reload.ok) {
+    throw new Error(`systemctl daemon-reload failed: ${reload.stderr.trim()}`);
+  }
+  const enable = systemctl(["enable", "--now", UNIT]);
+  if (!enable.ok) {
+    throw new Error(`systemctl enable --now failed: ${enable.stderr.trim()}`);
+  }
+  return { unit: file, logDir };
+}
+function uninstallLinux() {
+  systemctl(["disable", "--now", UNIT]);
+  try {
+    fs3.rmSync(unitPath());
+  } catch {
+  }
+  systemctl(["daemon-reload"]);
+}
+function statusLinux() {
+  const installed = fs3.existsSync(unitPath());
+  if (!installed) return { installed: false, running: false };
+  const r = systemctl(["show", UNIT, "--property=ActiveState,MainPID"]);
+  const active = /ActiveState=active/.test(r.stdout);
+  const pidMatch = r.stdout.match(/MainPID=(\d+)/);
+  const pid = pidMatch?.[1] ? Number(pidMatch[1]) : void 0;
+  return {
+    installed: true,
+    running: active && pid !== void 0 && pid > 0,
+    ...pid && pid > 0 ? { pid } : {}
+  };
+}
+
+// src/lib/daemon/macos.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import * as fs4 from "node:fs";
+import * as os4 from "node:os";
+import * as path4 from "node:path";
+var LABEL = "com.tokenrats.watch";
+function plistPath() {
+  return path4.join(os4.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function xmlEscape(s) {
+  return s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function renderPlist(node, script, logDir) {
+  const stdout = xmlEscape(path4.join(logDir, "watch.log"));
+  const stderr = xmlEscape(path4.join(logDir, "watch.err.log"));
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(node)}</string>
+    <string>${xmlEscape(script)}</string>
+    <string>watch</string>
+    <string>--daemon</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key><false/>
+    <key>Crashed</key><true/>
+  </dict>
+  <key>ThrottleInterval</key><integer>30</integer>
+  <key>StandardOutPath</key><string>${stdout}</string>
+  <key>StandardErrorPath</key><string>${stderr}</string>
+  <key>ProcessType</key><string>Background</string>
+</dict>
+</plist>
+`;
+}
+function uid() {
+  const fn = process.getuid;
+  if (typeof fn !== "function") throw new Error("process.getuid unavailable");
+  return fn();
+}
+function launchctl(args) {
+  const r = spawnSync2("launchctl", args, { encoding: "utf8" });
+  return {
+    ok: r.status === 0,
+    stdout: r.stdout ?? "",
+    stderr: r.stderr ?? ""
+  };
+}
+function installMacos(node, script) {
+  ensureDaemonDirs();
+  const dir = path4.dirname(plistPath());
+  fs4.mkdirSync(dir, { recursive: true });
+  const logDir = daemonLogDir();
+  const file = plistPath();
+  fs4.writeFileSync(file, renderPlist(node, script, logDir), { encoding: "utf8", mode: 420 });
+  const target = `gui/${uid()}`;
+  launchctl(["bootout", target, file]);
+  const r = launchctl(["bootstrap", target, file]);
+  if (!r.ok) {
+    throw new Error(`launchctl bootstrap failed: ${r.stderr.trim() || r.stdout.trim()}`);
+  }
+  launchctl(["kickstart", "-k", `${target}/${LABEL}`]);
+  return { plist: file, logDir };
+}
+function uninstallMacos() {
+  const file = plistPath();
+  const target = `gui/${uid()}`;
+  launchctl(["bootout", target, file]);
+  try {
+    fs4.rmSync(file);
+  } catch {
+  }
+}
+function statusMacos() {
+  const file = plistPath();
+  const installed = fs4.existsSync(file);
+  if (!installed) return { installed: false, running: false };
+  const r = launchctl(["print", `gui/${uid()}/${LABEL}`]);
+  const match = r.stdout.match(/\bpid\s*=\s*(\d+)/);
+  if (match?.[1]) return { installed: true, running: true, pid: Number(match[1]) };
+  return { installed: true, running: false };
+}
+
+// src/lib/daemon/state.ts
+import * as fs5 from "node:fs";
+function readDaemonState() {
+  try {
+    const raw = fs5.readFileSync(daemonStateFile(), "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeDaemonState(state) {
+  ensureDaemonDirs();
+  fs5.writeFileSync(daemonStateFile(), `${JSON.stringify(state, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+function markDeclined() {
+  const s = readDaemonState();
+  s.declinedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeDaemonState(s);
+}
+function markInstalled(method, script, version) {
+  const s = readDaemonState();
+  s.installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  s.installedScript = script;
+  s.method = method;
+  s.cliVersion = version;
+  s.declinedAt = void 0;
+  writeDaemonState(s);
+}
+function markUninstalled() {
+  const s = readDaemonState();
+  s.method = "none";
+  s.installedAt = void 0;
+  s.installedScript = void 0;
+  writeDaemonState(s);
+}
+
+// src/lib/daemon/install.ts
+function platformMethod() {
+  if (process.platform === "darwin") return "launchd";
+  if (process.platform === "linux") return "systemd";
+  return "unsupported";
+}
+function isDaemonSupported() {
+  return platformMethod() !== "unsupported";
+}
+var DaemonUnsupportedError = class extends Error {
+  constructor(platform) {
+    super(`Background daemon is not yet supported on ${platform}`);
+    this.name = "DaemonUnsupportedError";
+  }
+};
+async function installDaemon(version) {
+  const method = platformMethod();
+  const { node, script } = cliEntrypoint();
+  const ephemeralWarning = entrypointIsEphemeral();
+  if (method === "launchd") {
+    const r = installMacos(node, script);
+    markInstalled("launchd", script, version);
+    return { method: "launchd", logDir: r.logDir, ephemeralWarning };
+  }
+  if (method === "systemd") {
+    try {
+      const r = installLinux(node, script);
+      markInstalled("systemd", script, version);
+      return {
+        method: "systemd",
+        logDir: r.logDir,
+        ephemeralWarning,
+        lingerSet: lingerEnabled()
+      };
+    } catch (err) {
+      if (err instanceof SystemdUnavailableError) {
+        throw new DaemonUnsupportedError(process.platform);
+      }
+      throw err;
+    }
+  }
+  throw new DaemonUnsupportedError(process.platform);
+}
+async function uninstallDaemon() {
+  const method = platformMethod();
+  if (method === "launchd") uninstallMacos();
+  else if (method === "systemd") uninstallLinux();
+  markUninstalled();
+}
+async function daemonStatus() {
+  const method = platformMethod();
+  const state = readDaemonState();
+  const base = {
+    method,
+    installedScript: state.installedScript,
+    installedAt: state.installedAt,
+    declinedAt: state.declinedAt
+  };
+  if (method === "launchd") {
+    const s = statusMacos();
+    return { ...base, installed: s.installed, running: s.running, ...s.pid && { pid: s.pid } };
+  }
+  if (method === "systemd") {
+    const s = statusLinux();
+    return { ...base, installed: s.installed, running: s.running, ...s.pid && { pid: s.pid } };
+  }
+  return { ...base, installed: false, running: false };
+}
+
+// src/lib/discover.ts
+import * as fs6 from "node:fs";
+import * as os5 from "node:os";
+import * as path5 from "node:path";
 function findJsonlFiles(dir) {
   const results = [];
-  if (!fs2.existsSync(dir)) return results;
-  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  if (!fs6.existsSync(dir)) return results;
+  const entries = fs6.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const full = path2.join(dir, entry.name);
+    const full = path5.join(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...findJsonlFiles(full));
     } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -5207,32 +5674,32 @@ function findJsonlFiles(dir) {
   return results;
 }
 function claudeCodeProjectsDir() {
-  const home = os2.homedir();
+  const home = os5.homedir();
   if (process.platform === "win32") {
     const profile = process.env.USERPROFILE ?? home;
-    return path2.join(profile, ".claude", "projects");
+    return path5.join(profile, ".claude", "projects");
   }
-  return path2.join(home, ".claude", "projects");
+  return path5.join(home, ".claude", "projects");
 }
 function discoverClaudeCodeFiles() {
   const dir = claudeCodeProjectsDir();
   return findJsonlFiles(dir);
 }
 function codexSessionsDirs() {
-  const home = os2.homedir();
+  const home = os5.homedir();
   const candidates = [];
   if (process.platform === "win32") {
     const profile = process.env.USERPROFILE ?? home;
-    candidates.push(path2.join(profile, ".codex", "sessions"));
-    const appData = process.env.APPDATA ?? path2.join(profile, "AppData", "Roaming");
-    candidates.push(path2.join(appData, "Codex", "sessions"));
+    candidates.push(path5.join(profile, ".codex", "sessions"));
+    const appData = process.env.APPDATA ?? path5.join(profile, "AppData", "Roaming");
+    candidates.push(path5.join(appData, "Codex", "sessions"));
   } else {
-    candidates.push(path2.join(home, ".codex", "sessions"));
-    const snapRoot = path2.join(home, "snap", "codex");
-    if (fs2.existsSync(snapRoot)) {
-      for (const entry of fs2.readdirSync(snapRoot, { withFileTypes: true })) {
+    candidates.push(path5.join(home, ".codex", "sessions"));
+    const snapRoot = path5.join(home, "snap", "codex");
+    if (fs6.existsSync(snapRoot)) {
+      for (const entry of fs6.readdirSync(snapRoot, { withFileTypes: true })) {
         if (entry.isDirectory()) {
-          candidates.push(path2.join(snapRoot, entry.name, "sessions"));
+          candidates.push(path5.join(snapRoot, entry.name, "sessions"));
         }
       }
     }
@@ -5241,7 +5708,7 @@ function codexSessionsDirs() {
   const dirs = [];
   for (const c2 of candidates) {
     try {
-      const real = fs2.existsSync(c2) ? fs2.realpathSync(c2) : null;
+      const real = fs6.existsSync(c2) ? fs6.realpathSync(c2) : null;
       if (real && !seen2.has(real)) {
         seen2.add(real);
         dirs.push(c2);
@@ -5259,6 +5726,9 @@ function discoverCodexFiles() {
   return out;
 }
 
+// src/lib/version.ts
+var CLI_VERSION = "0.1.0";
+
 // src/commands/sync.ts
 var BATCH_SIZE = 500;
 function chunk(arr, size) {
@@ -5285,8 +5755,7 @@ function mergeBySessionId(records) {
     }
   }
   for (const rec of byId.values()) {
-    const { costUsdCents } = priceOf(rec.model, rec.inTokens, rec.outTokens);
-    rec.costUsdCents = costUsdCents;
+    rec.costUsdCents = 0;
     rec.dedupeKey = computeDedupeKey(
       rec.source,
       rec.model,
@@ -5313,7 +5782,7 @@ async function syncCommand(opts) {
   for (const file of claudeFiles) {
     let text;
     try {
-      text = fs3.readFileSync(file, "utf8");
+      text = fs7.readFileSync(file, "utf8");
     } catch {
       if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
       continue;
@@ -5335,7 +5804,7 @@ async function syncCommand(opts) {
   for (const file of codexFiles) {
     let text;
     try {
-      text = fs3.readFileSync(file, "utf8");
+      text = fs7.readFileSync(file, "utf8");
     } catch {
       if (opts.verbose) warn(`Could not read ${file} \u2014 skipping`);
       continue;
@@ -5396,7 +5865,9 @@ async function syncCommand(opts) {
   }
   info(`Discovered ${allSessions.length} session(s) from ${sourceStr}.`);
   if (opts.dryRun) {
-    info(`[dry-run] Would upload ${allSessions.length} session(s) in ${Math.ceil(allSessions.length / BATCH_SIZE)} batch(es).`);
+    info(
+      `[dry-run] Would upload ${allSessions.length} session(s) in ${Math.ceil(allSessions.length / BATCH_SIZE)} batch(es).`
+    );
     if (opts.verbose) {
       for (const s of allSessions.slice(0, 10)) {
         dim(
@@ -5433,191 +5904,459 @@ async function syncCommand(opts) {
   success(
     `Synced ${allSessions.length} sessions (${totalAccepted} new, ${totalDuplicates} already on server) from ${sourceStr}`
   );
+  await maybeWireDaemon(opts);
+}
+async function maybeWireDaemon(opts) {
+  if (opts.noDaemon) return;
+  if (process.env.TOKEN_RATS_NO_DAEMON === "1") return;
+  if (!isDaemonSupported()) return;
+  const status = await daemonStatus();
+  const state = readDaemonState();
+  if (status.installed) {
+    try {
+      await installDaemon(CLI_VERSION);
+      if (opts.verbose) dim("Refreshed daemon registration (self-heal).");
+    } catch (err) {
+      warn(`Could not refresh daemon: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return;
+  }
+  if (state.declinedAt) {
+    if (opts.verbose) dim(`Daemon prompt skipped \u2014 declined on ${state.declinedAt}`);
+    return;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return;
+  info("");
+  info("Background sync watches Claude Code + Cursor + Codex and uploads new");
+  info("sessions automatically \u2014 no more re-running `token-rats sync`.");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let answer;
+  try {
+    answer = (await rl.question("Install background sync? [Y/n] ")).trim().toLowerCase();
+  } finally {
+    rl.close();
+  }
+  if (answer === "n" || answer === "no") {
+    markDeclined();
+    info("Skipped. Enable later with `token-rats watch --install`.");
+    return;
+  }
+  try {
+    const r = await installDaemon(CLI_VERSION);
+    success(`Background sync enabled (${r.method}). Logs: ${r.logDir}/watch.log`);
+    info("Disable any time with `token-rats watch --uninstall`.");
+    if (r.ephemeralWarning) {
+      warn(
+        "You ran sync via npx \u2014 the daemon may break when the npx cache clears.\nRun `npm i -g token-rats` for a durable install."
+      );
+    }
+    if (r.method === "systemd" && r.lingerSet === false) {
+      warn(
+        "For the watcher to survive logout, run once:\n  sudo loginctl enable-linger $USER"
+      );
+    }
+  } catch (err) {
+    error(`Install failed: ${err instanceof Error ? err.message : String(err)}`);
+    info("You can retry later with `token-rats watch --install`.");
+  }
 }
 
 // src/commands/watch.ts
-import * as fs4 from "node:fs";
+import * as fs8 from "node:fs";
+import * as path6 from "node:path";
+var CURSOR_POLL_MS = 9e4;
+var CURSOR_DB_CAP = 10;
+var REAUTH_BACKOFF_MS = 10 * 60 * 1e3;
+function makeLogger(daemon, verbose) {
+  if (daemon) {
+    const emit = (level, msg, extra) => {
+      const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), level, msg, ...extra });
+      process.stderr.write(`${line}
+`);
+    };
+    return {
+      info: (m, e) => emit("info", m, e),
+      warn: (m, e) => emit("warn", m, e),
+      error: (m, e) => emit("error", m, e),
+      debug: (m, e) => {
+        if (verbose) emit("debug", m, e);
+      }
+    };
+  }
+  return {
+    info: (m) => info(m),
+    warn: (m) => warn(m),
+    error: (m) => error(m),
+    debug: (m) => {
+      if (verbose) dim(m);
+    }
+  };
+}
 var seen = /* @__PURE__ */ new Set();
-function parseAndFilter(filePath, verbose) {
+var reauthBackoffUntil = 0;
+var health = {
+  startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  uploaded: 0,
+  duplicates: 0,
+  errors: 0,
+  lastSourceAt: {}
+};
+async function upload(client, records, log, daemon) {
+  if (records.length === 0) return;
+  if (Date.now() < reauthBackoffUntil) {
+    log.debug("Skipping upload \u2014 in reauth backoff", { records: records.length });
+    return;
+  }
+  try {
+    const res = await client.uploadSessions(records);
+    health.uploaded += res.accepted;
+    health.duplicates += res.duplicates;
+    log.info("upload", { accepted: res.accepted, duplicates: res.duplicates });
+  } catch (err) {
+    health.errors++;
+    if (err instanceof ApiError2 && err.status === 401) {
+      if (daemon) {
+        reauthBackoffUntil = Date.now() + REAUTH_BACKOFF_MS;
+        log.error("Auth expired. Run `token-rats login` to recover.", {
+          backoffUntil: new Date(reauthBackoffUntil).toISOString()
+        });
+        return;
+      }
+      error("Session expired. Run `token-rats login` to re-authenticate.");
+      process.exit(1);
+    }
+    log.warn(`Upload failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function freshClaudeRecords(filePath, log) {
   let text;
   try {
-    text = fs4.readFileSync(filePath, "utf8");
+    text = fs8.readFileSync(filePath, "utf8");
   } catch {
-    if (verbose) warn(`Could not read ${filePath} \u2014 skipping`);
+    log.debug(`Could not read ${filePath} \u2014 skipping`);
     return [];
   }
   let records;
   try {
     records = parseClaudeCode(text);
   } catch {
-    if (verbose) warn(`Failed to parse ${filePath} \u2014 skipping`);
+    log.debug(`Failed to parse ${filePath} \u2014 skipping`);
     return [];
   }
   const fresh = [];
   for (const r of records) {
-    if (!seen.has(r.dedupeKey)) {
-      seen.add(r.dedupeKey);
-      fresh.push(r);
-    }
+    if (seen.has(r.dedupeKey)) continue;
+    seen.add(r.dedupeKey);
+    fresh.push(r);
   }
-  if (verbose && fresh.length > 0) {
-    dim(`  ${filePath}: ${fresh.length} new session(s)`);
+  if (fresh.length > 0) {
+    health.lastSourceAt["claude-code"] = (/* @__PURE__ */ new Date()).toISOString();
+    log.debug(`${filePath}: ${fresh.length} new Claude Code session(s)`);
   }
   return fresh;
 }
-async function upload(client, records, verbose) {
-  if (records.length === 0) return;
+function freshCodexRecords(filePath, log) {
+  let text;
   try {
-    const res = await client.uploadSessions(records);
-    if (verbose) {
-      dim(`  Uploaded ${res.accepted} new, ${res.duplicates} duplicate(s)`);
-    } else {
-      success(`Uploaded ${res.accepted} session(s)`);
-    }
-  } catch (err) {
-    if (err instanceof ApiError2 && err.status === 401) {
-      error("Session expired. Run `token-rats login` to re-authenticate.");
-      process.exit(1);
-    }
-    warn(`Upload failed: ${err instanceof Error ? err.message : String(err)}`);
+    text = fs8.readFileSync(filePath, "utf8");
+  } catch {
+    return [];
+  }
+  let records;
+  try {
+    records = parseCodex(text);
+  } catch {
+    return [];
   }
+  const fresh = [];
+  for (const r of records) {
+    if (seen.has(r.dedupeKey)) continue;
+    seen.add(r.dedupeKey);
+    fresh.push(r);
+  }
+  if (fresh.length > 0) {
+    health.lastSourceAt.codex = (/* @__PURE__ */ new Date()).toISOString();
+    log.debug(`${filePath}: ${fresh.length} new Codex session(s)`);
+  }
+  return fresh;
 }
 function makeDebounced(fn, ms) {
   const timers = /* @__PURE__ */ new Map();
-  return (path3) => {
-    const existing = timers.get(path3);
+  return (p) => {
+    const existing = timers.get(p);
     if (existing) clearTimeout(existing);
     timers.set(
-      path3,
+      p,
       setTimeout(() => {
-        timers.delete(path3);
-        fn(path3);
+        timers.delete(p);
+        fn(p);
       }, ms)
     );
   };
 }
 function findJsonlFiles2(dir) {
-  const results = [];
-  if (!fs4.existsSync(dir)) return results;
-  const entries = fs4.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const full = `${dir}/${entry.name}`;
-    if (entry.isDirectory()) {
-      results.push(...findJsonlFiles2(full));
-    } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-      results.push(full);
-    }
+  const out = [];
+  if (!fs8.existsSync(dir)) return out;
+  for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
+    const full = path6.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...findJsonlFiles2(full));
+    else if (entry.isFile() && entry.name.endsWith(".jsonl")) out.push(full);
   }
-  return results;
+  return out;
 }
-async function watchCommand(opts) {
-  const token = loadToken();
-  if (!token) {
-    error("Not logged in. Run `token-rats login` first.");
-    process.exit(1);
-  }
-  const client = new ApiClient({ apiUrl: opts.apiUrl, token });
-  const debounceMs = opts.interval ?? 2e3;
-  const dir = claudeCodeProjectsDir();
-  if (!fs4.existsSync(dir)) {
-    warn(`Claude Code projects directory not found: ${dir}`);
-    warn("No files to watch. Exiting.");
-    process.exit(0);
-  }
-  info(`Watching ${dir} (debounce: ${debounceMs}ms)`);
-  info("Press Ctrl-C to stop.\n");
-  const initialFiles = findJsonlFiles2(dir);
-  for (const f of initialFiles) {
-    parseAndFilter(f, false);
-  }
-  if (opts.verbose) {
-    dim(`Initial snapshot: ${seen.size} session(s) in ${initialFiles.length} file(s)`);
+async function watchJsonlDir(dir, debounceMs, onChange, log) {
+  if (!fs8.existsSync(dir)) {
+    log.debug(`Directory missing \u2014 not watching: ${dir}`);
+    return () => {
+    };
   }
-  const onChanged = makeDebounced(async (filePath) => {
-    if (!filePath.endsWith(".jsonl")) return;
-    const fresh = parseAndFilter(filePath, opts.verbose ?? false);
-    if (fresh.length > 0) {
-      await upload(client, fresh, opts.verbose ?? false);
-    }
+  const debouncedChange = makeDebounced((p) => {
+    if (p.endsWith(".jsonl")) onChange(p);
   }, debounceMs);
-  let cleanup = null;
   try {
-    const chokidar = await new Function("m", "return import(m)")(
-      "chokidar"
-    );
-    const watcher = chokidar.watch(`${dir}/**/*.jsonl`, {
+    const dynImport = new Function("m", "return import(m)");
+    const chokidarMod = await dynImport("chokidar");
+    const watcher = chokidarMod.watch(`${dir}/**/*.jsonl`, {
       ignoreInitial: true,
       persistent: true,
       awaitWriteFinish: { stabilityThreshold: 500, pollInterval: 100 }
     });
-    watcher.on("add", (p) => onChanged(p));
-    watcher.on("change", (p) => onChanged(p));
-    cleanup = () => {
+    watcher.on("add", (p) => {
+      if (typeof p === "string") debouncedChange(p);
+    });
+    watcher.on("change", (p) => {
+      if (typeof p === "string") debouncedChange(p);
+    });
+    return () => {
       watcher.close();
     };
-    if (opts.verbose) dim("Using chokidar for file watching");
   } catch {
-    if (opts.verbose) dim("chokidar not available; using Node built-in fs.watch");
-    if (process.platform === "linux") {
-      let lastMtimes = /* @__PURE__ */ new Map();
-      for (const f of initialFiles) {
+  }
+  if (process.platform === "linux") {
+    let lastMtimes = /* @__PURE__ */ new Map();
+    for (const f of findJsonlFiles2(dir)) {
+      try {
+        lastMtimes.set(f, fs8.statSync(f).mtimeMs);
+      } catch {
+      }
+    }
+    const handle = setInterval(() => {
+      const current = findJsonlFiles2(dir);
+      for (const f of current) {
         try {
-          lastMtimes.set(f, fs4.statSync(f).mtimeMs);
+          const mtime = fs8.statSync(f).mtimeMs;
+          const prev = lastMtimes.get(f) ?? 0;
+          if (mtime > prev) {
+            lastMtimes.set(f, mtime);
+            debouncedChange(f);
+          }
         } catch {
         }
       }
-      const pollInterval = setInterval(() => {
-        const current = findJsonlFiles2(dir);
-        for (const f of current) {
-          try {
-            const mtime = fs4.statSync(f).mtimeMs;
-            const prev = lastMtimes.get(f) ?? 0;
-            if (mtime > prev) {
-              lastMtimes.set(f, mtime);
-              onChanged(f);
-            }
-          } catch {
-          }
+      for (const f of current) {
+        if (!lastMtimes.has(f)) {
+          lastMtimes.set(f, Date.now());
+          debouncedChange(f);
         }
-        for (const f of current) {
-          if (!lastMtimes.has(f)) {
-            lastMtimes.set(f, Date.now());
-            onChanged(f);
-          }
-        }
-        lastMtimes = new Map(current.map((f) => [f, lastMtimes.get(f) ?? 0]));
-      }, debounceMs);
-      cleanup = () => clearInterval(pollInterval);
-    } else {
-      const controller = new AbortController();
-      (async () => {
-        try {
-          const { watch } = await import("node:fs/promises");
-          const watcher = watch(dir, { recursive: true, signal: controller.signal });
-          for await (const event of watcher) {
-            const filename = event.filename;
-            if (filename?.endsWith(".jsonl")) {
-              const fullPath = `${dir}/${filename}`;
-              onChanged(fullPath);
-            }
-          }
-        } catch (err) {
-          if (err instanceof Error && err.name !== "AbortError") {
-            warn(`Watcher error: ${err.message}`);
-          }
+      }
+      lastMtimes = new Map(current.map((f) => [f, lastMtimes.get(f) ?? 0]));
+    }, debounceMs);
+    return () => clearInterval(handle);
+  }
+  const controller = new AbortController();
+  (async () => {
+    try {
+      const { watch } = await import("node:fs/promises");
+      const watcher = watch(dir, { recursive: true, signal: controller.signal });
+      for await (const event of watcher) {
+        if (event.filename?.endsWith(".jsonl")) {
+          debouncedChange(path6.join(dir, event.filename));
         }
-      })();
-      cleanup = () => controller.abort();
+      }
+    } catch (err) {
+      if (err instanceof Error && err.name !== "AbortError") {
+        log.warn(`Watcher error on ${dir}: ${err.message}`);
+      }
+    }
+  })();
+  return () => controller.abort();
+}
+function startCursorLoop(client, log, daemon) {
+  let lastMtimes = /* @__PURE__ */ new Map();
+  let running = false;
+  let stopped = false;
+  const tick = async () => {
+    if (running || stopped) return;
+    running = true;
+    try {
+      const { rows, newMtimes, scanned, opened } = await extractCursorGenerationsDelta(
+        lastMtimes,
+        CURSOR_DB_CAP
+      );
+      lastMtimes = newMtimes;
+      if (rows.length === 0) {
+        if (opened > 0) log.debug(`Cursor poll: ${scanned} DB(s), opened ${opened}, no new rows`);
+        return;
+      }
+      let records;
+      try {
+        records = parseCursor(JSON.stringify(rows));
+      } catch {
+        log.warn("Failed to parse Cursor rows");
+        return;
+      }
+      const fresh = [];
+      for (const r of records) {
+        if (seen.has(r.dedupeKey)) continue;
+        seen.add(r.dedupeKey);
+        fresh.push(r);
+      }
+      if (fresh.length === 0) {
+        log.debug(`Cursor poll: ${rows.length} row(s), all duplicates`);
+        return;
+      }
+      health.lastSourceAt.cursor = (/* @__PURE__ */ new Date()).toISOString();
+      log.debug(
+        `Cursor poll: ${fresh.length} fresh session(s) (scanned ${scanned}, opened ${opened})`
+      );
+      await upload(client, fresh, log, daemon);
+    } finally {
+      running = false;
     }
+  };
+  const initial = setTimeout(tick, 5e3);
+  const handle = setInterval(tick, CURSOR_POLL_MS);
+  return () => {
+    stopped = true;
+    clearTimeout(initial);
+    clearInterval(handle);
+  };
+}
+async function runWatcher(opts) {
+  const daemon = opts.daemon === true;
+  const verbose = opts.verbose === true;
+  const log = makeLogger(daemon, verbose);
+  const token = loadToken();
+  if (!token) {
+    log.error("Not logged in. Run `token-rats login` first.");
+    if (!daemon) process.exit(1);
+    reauthBackoffUntil = Date.now() + REAUTH_BACKOFF_MS;
   }
-  function shutdown() {
-    info("Shutting down\u2026");
-    if (cleanup) cleanup();
-    process.exit(0);
+  const client = new ApiClient({ apiUrl: opts.apiUrl, token: token ?? void 0 });
+  const debounceMs = opts.interval ?? 2e3;
+  if (!daemon) {
+    info("Watching Claude Code + Cursor + Codex");
+    info("Press Ctrl-C to stop.\n");
+  } else {
+    log.info("watch starting", { debounceMs, cursorPollMs: CURSOR_POLL_MS });
+  }
+  const ccDir = claudeCodeProjectsDir();
+  for (const f of findJsonlFiles2(ccDir)) freshClaudeRecords(f, log);
+  for (const d of codexSessionsDirs()) {
+    for (const f of findJsonlFiles2(d)) freshCodexRecords(f, log);
+  }
+  log.debug(`Seeded ${seen.size} dedupe key(s) from initial snapshot`);
+  const cleanups = [];
+  cleanups.push(
+    await watchJsonlDir(
+      ccDir,
+      debounceMs,
+      async (filePath) => {
+        const fresh = freshClaudeRecords(filePath, log);
+        await upload(client, fresh, log, daemon);
+      },
+      log
+    )
+  );
+  for (const codexDir of codexSessionsDirs()) {
+    cleanups.push(
+      await watchJsonlDir(
+        codexDir,
+        debounceMs,
+        async (filePath) => {
+          const fresh = freshCodexRecords(filePath, log);
+          await upload(client, fresh, log, daemon);
+        },
+        log
+      )
+    );
   }
+  cleanups.push(startCursorLoop(client, log, daemon));
+  process.on("SIGUSR1", () => {
+    log.info("health", {
+      uptimeSec: Math.round(process.uptime()),
+      uploaded: health.uploaded,
+      duplicates: health.duplicates,
+      errors: health.errors,
+      lastSourceAt: health.lastSourceAt,
+      seenKeys: seen.size,
+      reauthBackoffUntil: reauthBackoffUntil > Date.now() ? new Date(reauthBackoffUntil).toISOString() : null
+    });
+  });
+  const shutdown = () => {
+    log.info("watch stopping");
+    for (const c2 of cleanups) c2();
+    process.exit(0);
+  };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
+async function handleInstall(opts) {
+  if (!isDaemonSupported()) {
+    error(`Background daemon not supported on ${process.platform} yet.`);
+    process.exit(1);
+  }
+  try {
+    const r = await installDaemon(opts.version ?? "0.0.0");
+    success(`Background watcher installed (${r.method}).`);
+    info(`Logs: ${r.logDir}/watch.log`);
+    if (r.ephemeralWarning) {
+      warn(
+        "You ran this via npx \u2014 the daemon may break when the npx cache is cleared.\nRun `npm i -g token-rats` (or `pnpm add -g token-rats`) for a durable install."
+      );
+    }
+    if (r.method === "systemd" && r.lingerSet === false) {
+      warn(
+        "For the watcher to survive logout, run once:\n  sudo loginctl enable-linger $USER\nWithout it, the watcher resumes at your next login."
+      );
+    }
+  } catch (err) {
+    error(`Install failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+async function handleUninstall() {
+  try {
+    await uninstallDaemon();
+    success("Background watcher uninstalled.");
+  } catch (err) {
+    error(`Uninstall failed: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+async function handleStatus() {
+  const s = await daemonStatus();
+  if (s.method === "unsupported") {
+    info(`Daemon not supported on ${process.platform}.`);
+    return;
+  }
+  info(`Method:      ${s.method}`);
+  info(`Installed:   ${s.installed ? "yes" : "no"}`);
+  info(`Running:     ${s.running ? `yes (pid ${s.pid ?? "?"})` : "no"}`);
+  if (s.installedAt) info(`Installed at: ${s.installedAt}`);
+  if (s.installedScript) info(`Script:      ${s.installedScript}`);
+  if (s.declinedAt) info(`Declined at: ${s.declinedAt}`);
+  info(`Log dir:     ${daemonLogDir()}`);
+  if (process.platform === "linux") {
+    info(`Linger:      ${lingerEnabled() ? "yes (survives logout)" : "no (dies on logout)"}`);
+  }
+}
+async function watchCommand(opts) {
+  if (opts.install) return handleInstall(opts);
+  if (opts.uninstall) return handleUninstall();
+  if (opts.status) return handleStatus();
+  return runWatcher(opts);
+}
 
 // src/commands/whoami.ts
 async function whoamiCommand(opts) {
@@ -5642,7 +6381,7 @@ async function whoamiCommand(opts) {
 
 // src/index.ts
 function getVersion() {
-  return "0.0.4";
+  return CLI_VERSION;
 }
 function printHelp() {
   console.log(`
@@ -5653,8 +6392,13 @@ function printHelp() {
 
 \x1B[1mCommands:\x1B[0m
   login           Authenticate with Token Rats (opens browser)
-  sync            Read local Claude Code + Cursor logs and upload counts
-  watch           Watch logs in real-time; upload new sessions as they appear
+  sync            Upload local Claude Code + Cursor + Codex usage. On first
+                  successful sync, asks to install a background watcher
+                  (launchd on macOS, systemd --user on Linux) that keeps
+                  your leaderboard live \u2014 no more re-running sync.
+  watch           Run the foreground watcher (Ctrl-C to stop), OR manage
+                  the background watcher with --install / --uninstall /
+                  --status.
   whoami          Show the currently signed-in account
   logout          Clear your stored credentials
   install-cursor  Install better-sqlite3 globally for faster Cursor reads
@@ -5667,8 +6411,15 @@ function printHelp() {
 \x1B[1mFlags (sync only):\x1B[0m
   --dry-run         Parse but do not upload; print what would be sent
   --verbose         Print discovered files and per-file record counts
+  --no-daemon       Skip the post-sync prompt to install background watcher
+                    (TOKEN_RATS_NO_DAEMON=1 does the same globally)
 
 \x1B[1mFlags (watch only):\x1B[0m
+  --install         Install the background watcher (launchd / systemd --user)
+  --uninstall       Remove the background watcher
+  --status          Show whether the watcher is installed and running
+  --daemon          Internal: structured logs for launchd/systemd. Not for
+                    interactive use.
   --interval <ms>   Debounce window in ms before uploading (default: 2000)
   --verbose         Print file change events and upload detail
 
@@ -5697,6 +6448,11 @@ function parseArgs(argv) {
   let dryRun = false;
   let verbose = false;
   let interval;
+  let noDaemon = false;
+  let daemon = false;
+  let install = false;
+  let uninstall = false;
+  let status = false;
   let i = 0;
   while (i < argv.length) {
     const arg = argv[i];
@@ -5712,6 +6468,16 @@ function parseArgs(argv) {
       interval = Number(argv[++i]);
     } else if (arg.startsWith("--interval=")) {
       interval = Number(arg.slice("--interval=".length));
+    } else if (arg === "--no-daemon") {
+      noDaemon = true;
+    } else if (arg === "--daemon") {
+      daemon = true;
+    } else if (arg === "--install") {
+      install = true;
+    } else if (arg === "--uninstall") {
+      uninstall = true;
+    } else if (arg === "--status") {
+      status = true;
     } else if (arg === "--version" || arg === "-V") {
       console.log(getVersion());
       process.exit(0);
@@ -5724,11 +6490,34 @@ function parseArgs(argv) {
     i++;
   }
   const [command = null, ...rest] = positional;
-  return { command, apiUrl, dryRun, verbose, interval, rest };
+  return {
+    command,
+    apiUrl,
+    dryRun,
+    verbose,
+    interval,
+    noDaemon,
+    daemon,
+    install,
+    uninstall,
+    status,
+    rest
+  };
 }
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  const { command, apiUrl, dryRun, verbose, interval } = args;
+  const {
+    command,
+    apiUrl,
+    dryRun,
+    verbose,
+    interval,
+    noDaemon,
+    daemon,
+    install,
+    uninstall,
+    status
+  } = args;
   if (!command || command === "help") {
     printHelp();
     process.exit(0);
@@ -5738,10 +6527,19 @@ async function main() {
       await loginCommand({ apiUrl });
       break;
     case "sync":
-      await syncCommand({ apiUrl, dryRun, verbose });
+      await syncCommand({ apiUrl, dryRun, verbose, noDaemon });
       break;
     case "watch":
-      await watchCommand({ apiUrl, verbose, interval });
+      await watchCommand({
+        apiUrl,
+        verbose,
+        interval,
+        daemon,
+        install,
+        uninstall,
+        status,
+        version: getVersion()
+      });
       break;
     case "whoami":
       await whoamiCommand({ apiUrl });