codex-token-tracker 0.1.1 → 0.2.1

package/dist/main.js

@@ -24,10 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/main.ts
 var import_electron = require("electron");
-var import_node_fs8 = __toESM(require("node:fs"));
+var import_node_fs9 = __toESM(require("node:fs"));
 var import_node_os7 = __toESM(require("node:os"));
-var import_node_path10 = __toESM(require("node:path"));
-var import_node_child_process3 = require("node:child_process");
+var import_node_path11 = __toESM(require("node:path"));
+var import_node_child_process4 = require("node:child_process");
 var import_menubar = require("menubar");
 
 // ../shared/src/usage.ts
@@ -50,20 +50,53 @@ function cacheHitRate(u) {
 }
 
 // ../shared/src/pricing.ts
+var LONG_CONTEXT_THRESHOLD = 272e3;
+var long = (threshold, input, cachedInput, output) => ({
+  threshold,
+  input,
+  cachedInput,
+  output
+});
 var DEFAULT_PRICING = {
-  // GPT-5.x family
+  // GPT-5.6 family
+  "gpt-5.6-sol": { input: 4, cachedInput: 0.4, output: 20, long: long(LONG_CONTEXT_THRESHOLD, 8, 0.8, 30) },
+  "gpt-5.6-sol-codex": { input: 4, cachedInput: 0.4, output: 20, long: long(LONG_CONTEXT_THRESHOLD, 8, 0.8, 30) },
+  "gpt-5.6-terra": { input: 2, cachedInput: 0.2, output: 12, long: long(LONG_CONTEXT_THRESHOLD, 4, 0.4, 18) },
+  "gpt-5.6-terra-codex": { input: 2, cachedInput: 0.2, output: 12, long: long(LONG_CONTEXT_THRESHOLD, 4, 0.4, 18) },
+  "gpt-5.6-luna": { input: 0.2, cachedInput: 0.02, output: 1.2, long: long(LONG_CONTEXT_THRESHOLD, 0.4, 0.04, 1.8) },
+  "gpt-5.6-cyber": { input: 12.5, cachedInput: 1.25, output: 75 },
+  // GPT-5.5 family
+  "gpt-5.5": { input: 5, cachedInput: 0.5, output: 30, long: long(LONG_CONTEXT_THRESHOLD, 10, 1, 45) },
+  "gpt-5.5-codex": { input: 5, cachedInput: 0.5, output: 30, long: long(LONG_CONTEXT_THRESHOLD, 10, 1, 45) },
+  "gpt-5.5-pro": { input: 30, cachedInput: 30, output: 180, long: long(LONG_CONTEXT_THRESHOLD, 60, 60, 270) },
+  "gpt-5.5-cyber": { input: 12.5, cachedInput: 1.25, output: 75 },
+  // GPT-5.4 family
+  "gpt-5.4": { input: 2.5, cachedInput: 0.25, output: 15, long: long(LONG_CONTEXT_THRESHOLD, 5, 0.5, 22.5) },
+  "gpt-5.4-codex": { input: 2.5, cachedInput: 0.25, output: 15, long: long(LONG_CONTEXT_THRESHOLD, 5, 0.5, 22.5) },
+  "gpt-5.4-mini": { input: 0.75, cachedInput: 0.075, output: 4.5 },
+  "gpt-5.4-nano": { input: 0.2, cachedInput: 0.02, output: 1.25 },
+  "gpt-5.4-pro": { input: 30, cachedInput: 30, output: 180, long: long(LONG_CONTEXT_THRESHOLD, 60, 60, 270) },
+  // GPT-5.3 family (Codex-only release)
+  "gpt-5.3": { input: 1.75, cachedInput: 0.175, output: 14 },
+  "gpt-5.3-codex": { input: 1.75, cachedInput: 0.175, output: 14 },
+  // GPT-5.2 family
+  "gpt-5.2": { input: 1.75, cachedInput: 0.175, output: 14 },
+  "gpt-5.2-codex": { input: 1.75, cachedInput: 0.175, output: 14 },
+  "gpt-5.2-pro": { input: 21, cachedInput: 21, output: 168 },
+  // GPT-5.1 family
+  "gpt-5.1": { input: 1.25, cachedInput: 0.125, output: 10 },
+  "gpt-5.1-codex": { input: 1.25, cachedInput: 0.125, output: 10 },
+  "gpt-5.1-codex-max": { input: 1.25, cachedInput: 0.125, output: 10 },
+  "gpt-5.1-codex-mini": { input: 0.25, cachedInput: 0.025, output: 2 },
+  // GPT-5 family
   "gpt-5": { input: 1.25, cachedInput: 0.125, output: 10 },
   "gpt-5-codex": { input: 1.25, cachedInput: 0.125, output: 10 },
   "gpt-5-mini": { input: 0.25, cachedInput: 0.025, output: 2 },
   "gpt-5-nano": { input: 0.05, cachedInput: 5e-3, output: 0.4 },
   "gpt-5-pro": { input: 15, cachedInput: 15, output: 120 },
-  "gpt-5.1": { input: 1.25, cachedInput: 0.125, output: 10 },
-  "gpt-5.1-codex": { input: 1.25, cachedInput: 0.125, output: 10 },
-  "gpt-5.1-codex-max": { input: 1.25, cachedInput: 0.125, output: 10 },
-  "gpt-5.1-codex-mini": { input: 0.25, cachedInput: 0.025, output: 2 },
-  "gpt-5.2": { input: 1.75, cachedInput: 0.175, output: 14 },
-  "gpt-5.2-codex": { input: 1.75, cachedInput: 0.175, output: 14 },
-  "gpt-5.2-pro": { input: 21, cachedInput: 21, output: 168 },
+  "gpt-5-search-api": { input: 1.25, cachedInput: 0.125, output: 10 },
+  // ChatGPT-tuned endpoint
+  "chat-latest": { input: 5, cachedInput: 0.5, output: 30 },
   // GPT-4.1 / 4o family
   "gpt-4.1": { input: 2, cachedInput: 0.5, output: 8 },
   "gpt-4.1-mini": { input: 0.4, cachedInput: 0.1, output: 1.6 },
@@ -79,7 +112,7 @@ var DEFAULT_PRICING = {
   "o4-mini": { input: 1.1, cachedInput: 0.275, output: 4.4 },
   "codex-mini-latest": { input: 1.5, cachedInput: 0.375, output: 6 }
 };
-var FALLBACK_PRICE_KEY = "gpt-5.2";
+var FALLBACK_PRICE_KEY = "gpt-5.3-codex";
 var TIERS = ["mini", "nano", "pro"];
 function normalizeModelName(model) {
   let m = (model || "").trim().toLowerCase();
@@ -89,6 +122,11 @@ function normalizeModelName(model) {
   m = m.replace(/-preview$/, "");
   return m;
 }
+function isOpenAIModel(model) {
+  const m = normalizeModelName(model);
+  if (m === "unknown") return true;
+  return /^(gpt[-.]|chatgpt|chat-latest|o[1-9](?:[-.]|$)|codex|text-|davinci|babbage|ada|curie)/.test(m);
+}
 function tierOf(name) {
   for (const t2 of TIERS) if (name.split("-").includes(t2)) return t2;
   return null;
@@ -128,11 +166,12 @@ function resolvePrice(model, overrides) {
 }
 function computeCost(u, p) {
   const input = u.input ?? 0;
+  const rate = p.long && input > p.long.threshold ? p.long : p;
   const cached = Math.min(u.cached ?? 0, input);
   const cacheWrite = Math.min(u.cacheWrite ?? 0, Math.max(0, input - cached));
   const fresh = Math.max(0, input - cached - cacheWrite);
   const output = u.output ?? 0;
-  const cost = fresh * p.input + cached * p.cachedInput + cacheWrite * (p.cacheWrite ?? p.input) + output * p.output;
+  const cost = fresh * rate.input + cached * rate.cachedInput + cacheWrite * (p.cacheWrite ?? rate.input) + output * rate.output;
   return cost / 1e6;
 }
 
@@ -312,14 +351,14 @@ function createSessionParser(fallbackSessionId) {
     if (ts2 > lastActivityAt) lastActivityAt = ts2;
   }
   function onTokenCount(ts2, payload) {
-    const info = payload.info;
+    const info2 = payload.info;
     let cumulative = null;
     let last = null;
-    if (info && typeof info === "object") {
-      cumulative = toUsage(info.total_token_usage);
-      last = toUsage(info.last_token_usage);
-      if (typeof info.model_context_window === "number") contextWindow = info.model_context_window;
-    } else if (info === void 0) {
+    if (info2 && typeof info2 === "object") {
+      cumulative = toUsage(info2.total_token_usage);
+      last = toUsage(info2.last_token_usage);
+      if (typeof info2.model_context_window === "number") contextWindow = info2.model_context_window;
+    } else if (info2 === void 0) {
       cumulative = toUsage(payload);
     }
     const rl = payload.rate_limits;
@@ -1003,7 +1042,17 @@ var import_node_events = require("node:events");
 var import_node_fs = __toESM(require("node:fs"));
 var import_node_os = __toESM(require("node:os"));
 var import_node_path = __toESM(require("node:path"));
-var DEFAULT_DASHBOARD_URL = "https://codex.chenli.dev";
+
+// src/version.ts
+var APP_VERSION = true ? "0.2.1" : "0.0.0-dev";
+var APP_CHANNEL = true ? "prod" : "dev";
+var IS_DEV_BUILD = APP_CHANNEL === "dev";
+var APP_NAME = IS_DEV_BUILD ? "Codex Tracker (dev)" : "Codex Tracker";
+
+// src/core/config.ts
+var PROD_DASHBOARD_URL = "https://codex.chenli.dev";
+var DEV_DASHBOARD_URL = "http://localhost:3000";
+var DEFAULT_DASHBOARD_URL = IS_DEV_BUILD ? DEV_DASHBOARD_URL : PROD_DASHBOARD_URL;
 var SOURCE_FORMATS = ["codex", "pi", "generic", "opencode", "cline"];
 var DEFAULT_SOURCES = { codex: true, pi: true, hermes: true, opencode: true, cline: true, roo: true, kilo: true };
 var SOURCE_IDS = Object.keys(DEFAULT_SOURCES);
@@ -1022,10 +1071,12 @@ var DEFAULT_CONFIG = {
   sources: { ...DEFAULT_SOURCES },
   trackAllProviders: false,
   liveRateLimits: true,
-  usageRefreshSec: 60
+  usageRefreshSec: 60,
+  // a dev build must never offer to replace itself with the published package
+  checkUpdates: !IS_DEV_BUILD
 };
 function configDir() {
-  return process.env.CODEX_TRACKER_HOME || import_node_path.default.join(import_node_os.default.homedir(), ".codex-tracker");
+  return process.env.CODEX_TRACKER_HOME || import_node_path.default.join(import_node_os.default.homedir(), IS_DEV_BUILD ? ".codex-tracker-dev" : ".codex-tracker");
 }
 function readJson(file, fallback) {
   try {
@@ -1076,6 +1127,7 @@ function loadConfig() {
   cfg.sources = normalizeSources(stored.sources);
   cfg.trackAllProviders = stored.trackAllProviders === true;
   cfg.liveRateLimits = stored.liveRateLimits !== false;
+  cfg.checkUpdates = typeof stored.checkUpdates === "boolean" ? stored.checkUpdates : DEFAULT_CONFIG.checkUpdates;
   if (!(cfg.usageRefreshSec >= 15)) cfg.usageRefreshSec = DEFAULT_CONFIG.usageRefreshSec;
   if (!["auto", "en", "zh"].includes(cfg.language)) cfg.language = "auto";
   if (!(cfg.uploadIntervalSec >= 10)) cfg.uploadIntervalSec = DEFAULT_CONFIG.uploadIntervalSec;
@@ -1189,6 +1241,7 @@ var en = {
   estimatedPricingHint: "Pricing estimated: model not in the price table",
   other: "Other",
   lastUpload: "Last upload {time}",
+  lastSync: "Last full sync {time}",
   neverUploaded: "Not uploaded yet",
   uploadError: "Upload error: {message}",
   allDevicesToday: "All devices today",
@@ -1207,16 +1260,44 @@ var en = {
   launchAtLogin: "Launch at login",
   refresh: "Refresh",
   quit: "Quit",
+  // full sync
+  syncNow: "Sync now",
+  syncing: "Syncing\u2026",
+  syncTitle: "Rescan every agent on this device and re-upload its full usage history",
+  syncScanning: "Rescanning every agent's transcripts\u2026",
+  syncComputing: "Recomputing token usage\u2026",
+  syncUploading: "Re-uploading this device's history\u2026",
+  syncDownloading: "Fetching other devices\u2026",
+  syncLimits: "Refreshing rate limits\u2026",
+  syncDone: "Synced {agents} \xB7 {files} files \xB7 {sessions} sessions \xB7 {buckets} hours re-uploaded",
+  syncDoneLocal: "Rescanned {agents} \xB7 {files} files \xB7 {sessions} sessions \u2014 sign in to upload",
+  syncFailed: "Sync failed: {message}",
   sessions: "{n} sessions",
   files: "{n} files",
   noData: "No usage found yet. Run Codex and this will fill in.",
   version: "v{version}",
+  // dev builds
+  devBuild: "DEV",
+  devBuildTitle: "Local build \u2014 uploading to {url} (dev environment). Config: {dir}",
+  devBuildMenu: "Dev build \u2192 {url}",
   justNow: "just now",
   never: "never",
   local: "Local",
   remote: "Other devices",
+  // updates
+  update: "Update",
+  updateAvailable: "Update to v{version}",
+  updateNewVersion: "Version {version} is available (you have v{current})",
+  updateUpToDate: "Up to date",
+  updateChecking: "Checking\u2026",
+  updateInstalling: "Installing\u2026",
+  updateInstalled: "Updated to v{version} \u2014 restart to apply",
+  updateFailed: "Update failed \u2014 run this yourself:",
+  updateCheckFailed: "Update check failed: {message}",
+  checkForUpdates: "Check for updates",
+  releaseNotes: "Release notes",
   // CLI
-  cliUsage: `Usage: codex-tracker [command] [options]
+  cliUsage: `Usage: codex-token-tracker [command] [options]      (alias: codex-tracker)
 
 Commands:
   (none)            Start the menu bar app (falls back to agent mode without a display)
@@ -1226,11 +1307,14 @@ Commands:
   login             Connect this device to your dashboard (--dashboard <url>)
   logout            Disconnect this device
   status            Print today's usage, live session and rate limits
+  sync              Rescan every agent and re-upload this device's full history (calibrate)
   paths             Show detected session directories (Codex, pi, OpenCode, Cline/Roo/Kilo, Hermes, custom)
+  update            Install the newest published version (--check only reports)
   config get|set    Read or change settings (config set uploadIntervalSec 30, config set sources.pi false)
   lang <en|zh|auto> Set the display language
 
 Options:
+  --check           update: report the newest version without installing it
   --dashboard <url> Dashboard URL (self-hosted)
   --background      Start the menu bar app detached and return
   --version, -v     Print version
@@ -1272,7 +1356,21 @@ Options:
   cliConfigSet: "Set {key} = {value}",
   cliConfigUnknownKey: "Unknown config key: {key}. Keys: {keys}",
   cliLangSet: "Language set to {lang}",
-  cliConfigDir: "Config: {dir}"
+  cliConfigDir: "Config: {dir}",
+  cliUpdateLatest: "codex-token-tracker {version} is the latest version.",
+  cliUpdateAvailable: "Update available: {current} \u2192 {latest}",
+  cliUpdateRunning: "Running: {command}",
+  cliUpdateDone: "Updated to {version}. Restart the menu bar app (or rerun the CLI) to use it.",
+  cliUpdateFailed: "Update failed (exit {code}). Run it yourself: {command}",
+  cliUpdateCheckFailed: "Could not reach the npm registry: {message}",
+  cliSyncStart: "Full sync: rescanning every agent on this device\u2026",
+  cliSyncScanned: "  scanned {files} files in {roots} directories ({agents})",
+  cliSyncUploaded: "  re-uploaded {buckets} hour buckets and {sessions} sessions",
+  cliSyncLocal: "  not signed in \u2014 nothing uploaded (run `codex-tracker login` first)",
+  cliSyncDone: "Sync complete in {seconds}s \u2014 {sessions} sessions, today {tokens} tok \xB7 {cost}",
+  cliSyncFailed: "Sync failed: {message}",
+  cliChannelDev: "Dev build \u2014 dashboard {url} \xB7 config {dir}",
+  cliUpdateDevBuild: "This is a local dev build; `update` would install the published package over it. Run `pnpm build` in the repo instead."
 };
 
 // src/i18n/zh.ts
@@ -1320,6 +1418,7 @@ var zh = {
   estimatedPricingHint: "\u4EF7\u683C\u4E3A\u4F30\u7B97\u503C\uFF1A\u8BE5\u6A21\u578B\u4E0D\u5728\u4EF7\u76EE\u8868\u4E2D",
   other: "\u5176\u4ED6",
   lastUpload: "\u4E0A\u6B21\u4E0A\u4F20 {time}",
+  lastSync: "\u4E0A\u6B21\u5B8C\u6574\u540C\u6B65 {time}",
   neverUploaded: "\u5C1A\u672A\u4E0A\u4F20",
   uploadError: "\u4E0A\u4F20\u5931\u8D25\uFF1A{message}",
   allDevicesToday: "\u6240\u6709\u8BBE\u5907\u4ECA\u65E5",
@@ -1338,15 +1437,42 @@ var zh = {
   launchAtLogin: "\u5F00\u673A\u81EA\u542F\u52A8",
   refresh: "\u5237\u65B0",
   quit: "\u9000\u51FA",
+  // 完整同步
+  syncNow: "\u7ACB\u5373\u540C\u6B65",
+  syncing: "\u540C\u6B65\u4E2D\u2026",
+  syncTitle: "\u91CD\u65B0\u626B\u63CF\u672C\u8BBE\u5907\u4E0A\u7684\u6240\u6709\u667A\u80FD\u4F53\uFF0C\u5E76\u91CD\u65B0\u4E0A\u4F20\u5B8C\u6574\u7528\u91CF\u5386\u53F2",
+  syncScanning: "\u6B63\u5728\u91CD\u65B0\u626B\u63CF\u6240\u6709\u667A\u80FD\u4F53\u7684\u4F1A\u8BDD\u8BB0\u5F55\u2026",
+  syncComputing: "\u6B63\u5728\u91CD\u65B0\u8BA1\u7B97 token \u7528\u91CF\u2026",
+  syncUploading: "\u6B63\u5728\u91CD\u65B0\u4E0A\u4F20\u672C\u8BBE\u5907\u7684\u5386\u53F2\u6570\u636E\u2026",
+  syncDownloading: "\u6B63\u5728\u62C9\u53D6\u5176\u4ED6\u8BBE\u5907\u7684\u6570\u636E\u2026",
+  syncLimits: "\u6B63\u5728\u5237\u65B0\u9650\u989D\u2026",
+  syncDone: "\u5DF2\u540C\u6B65 {agents} \xB7 {files} \u4E2A\u6587\u4EF6 \xB7 {sessions} \u4E2A\u4F1A\u8BDD \xB7 \u91CD\u65B0\u4E0A\u4F20 {buckets} \u4E2A\u5C0F\u65F6\u6BB5",
+  syncDoneLocal: "\u5DF2\u91CD\u65B0\u626B\u63CF {agents} \xB7 {files} \u4E2A\u6587\u4EF6 \xB7 {sessions} \u4E2A\u4F1A\u8BDD \u2014 \u767B\u5F55\u540E\u53EF\u4E0A\u4F20",
+  syncFailed: "\u540C\u6B65\u5931\u8D25\uFF1A{message}",
   sessions: "{n} \u4E2A\u4F1A\u8BDD",
   files: "{n} \u4E2A\u6587\u4EF6",
   noData: "\u8FD8\u6CA1\u6709\u7528\u91CF\u6570\u636E\u3002\u8FD0\u884C Codex \u540E\u8FD9\u91CC\u4F1A\u81EA\u52A8\u66F4\u65B0\u3002",
   version: "v{version}",
+  // 开发版
+  devBuild: "\u5F00\u53D1\u7248",
+  devBuildTitle: "\u672C\u5730\u6784\u5EFA \u2014\u2014 \u6570\u636E\u4E0A\u4F20\u81F3 {url}\uFF08\u5F00\u53D1\u73AF\u5883\uFF09\u3002\u914D\u7F6E\u76EE\u5F55\uFF1A{dir}",
+  devBuildMenu: "\u5F00\u53D1\u7248 \u2192 {url}",
   justNow: "\u521A\u521A",
   never: "\u4ECE\u672A",
   local: "\u672C\u673A",
   remote: "\u5176\u4ED6\u8BBE\u5907",
-  cliUsage: `\u7528\u6CD5\uFF1Acodex-tracker [\u547D\u4EE4] [\u9009\u9879]
+  update: "\u66F4\u65B0",
+  updateAvailable: "\u66F4\u65B0\u5230 v{version}",
+  updateNewVersion: "\u6709\u65B0\u7248\u672C {version}\uFF08\u5F53\u524D v{current}\uFF09",
+  updateUpToDate: "\u5DF2\u662F\u6700\u65B0\u7248\u672C",
+  updateChecking: "\u68C0\u67E5\u4E2D\u2026",
+  updateInstalling: "\u5B89\u88C5\u4E2D\u2026",
+  updateInstalled: "\u5DF2\u66F4\u65B0\u5230 v{version} \u2014 \u91CD\u542F\u540E\u751F\u6548",
+  updateFailed: "\u66F4\u65B0\u5931\u8D25 \u2014 \u8BF7\u624B\u52A8\u6267\u884C\uFF1A",
+  updateCheckFailed: "\u68C0\u67E5\u66F4\u65B0\u5931\u8D25\uFF1A{message}",
+  checkForUpdates: "\u68C0\u67E5\u66F4\u65B0",
+  releaseNotes: "\u66F4\u65B0\u65E5\u5FD7",
+  cliUsage: `\u7528\u6CD5\uFF1Acodex-token-tracker [\u547D\u4EE4] [\u9009\u9879]      \uFF08\u522B\u540D\uFF1Acodex-tracker\uFF09
 
 \u547D\u4EE4\uFF1A
   (\u65E0)              \u542F\u52A8\u83DC\u5355\u680F\u5E94\u7528\uFF08\u65E0\u663E\u793A\u73AF\u5883\u65F6\u81EA\u52A8\u5207\u6362\u4E3A agent \u6A21\u5F0F\uFF09
@@ -1356,11 +1482,14 @@ var zh = {
   login             \u5C06\u672C\u8BBE\u5907\u8FDE\u63A5\u5230\u4EEA\u8868\u76D8\uFF08--dashboard <url>\uFF09
   logout            \u65AD\u5F00\u672C\u8BBE\u5907
   status            \u6253\u5370\u4ECA\u65E5\u7528\u91CF\u3001\u5B9E\u65F6\u4F1A\u8BDD\u4E0E\u9650\u989D
+  sync              \u91CD\u65B0\u626B\u63CF\u6240\u6709\u667A\u80FD\u4F53\u5E76\u91CD\u65B0\u4E0A\u4F20\u672C\u8BBE\u5907\u5B8C\u6574\u5386\u53F2\uFF08\u6821\u51C6\uFF09
   paths             \u663E\u793A\u68C0\u6D4B\u5230\u7684\u4F1A\u8BDD\u76EE\u5F55\uFF08Codex\u3001pi\u3001OpenCode\u3001Cline/Roo/Kilo\u3001Hermes\u3001\u81EA\u5B9A\u4E49\uFF09
+  update            \u5B89\u88C5\u6700\u65B0\u53D1\u5E03\u7248\u672C\uFF08--check \u53EA\u68C0\u67E5\u4E0D\u5B89\u88C5\uFF09
   config get|set    \u8BFB\u53D6\u6216\u4FEE\u6539\u8BBE\u7F6E\uFF08config set uploadIntervalSec 30\uFF0Cconfig set sources.pi false\uFF09
   lang <en|zh|auto> \u8BBE\u7F6E\u663E\u793A\u8BED\u8A00
 
 \u9009\u9879\uFF1A
+  --check           update\uFF1A\u53EA\u62A5\u544A\u6700\u65B0\u7248\u672C\uFF0C\u4E0D\u6267\u884C\u5B89\u88C5
   --dashboard <url> \u4EEA\u8868\u76D8\u5730\u5740\uFF08\u81EA\u6258\u7BA1\uFF09
   --background      \u4EE5\u540E\u53F0\u65B9\u5F0F\u542F\u52A8\u83DC\u5355\u680F\u5E94\u7528\u5E76\u7ACB\u5373\u8FD4\u56DE
   --version, -v     \u663E\u793A\u7248\u672C
@@ -1402,7 +1531,21 @@ var zh = {
   cliConfigSet: "\u5DF2\u8BBE\u7F6E {key} = {value}",
   cliConfigUnknownKey: "\u672A\u77E5\u914D\u7F6E\u9879\uFF1A{key}\u3002\u53EF\u7528\uFF1A{keys}",
   cliLangSet: "\u8BED\u8A00\u5DF2\u8BBE\u7F6E\u4E3A {lang}",
-  cliConfigDir: "\u914D\u7F6E\u76EE\u5F55\uFF1A{dir}"
+  cliConfigDir: "\u914D\u7F6E\u76EE\u5F55\uFF1A{dir}",
+  cliUpdateLatest: "codex-token-tracker {version} \u5DF2\u662F\u6700\u65B0\u7248\u672C\u3002",
+  cliUpdateAvailable: "\u53D1\u73B0\u65B0\u7248\u672C\uFF1A{current} \u2192 {latest}",
+  cliUpdateRunning: "\u6B63\u5728\u6267\u884C\uFF1A{command}",
+  cliUpdateDone: "\u5DF2\u66F4\u65B0\u5230 {version}\u3002\u8BF7\u91CD\u542F\u83DC\u5355\u680F\u5E94\u7528\uFF08\u6216\u91CD\u65B0\u8FD0\u884C CLI\uFF09\u4EE5\u751F\u6548\u3002",
+  cliUpdateFailed: "\u66F4\u65B0\u5931\u8D25\uFF08\u9000\u51FA\u7801 {code}\uFF09\u3002\u8BF7\u624B\u52A8\u6267\u884C\uFF1A{command}",
+  cliUpdateCheckFailed: "\u65E0\u6CD5\u8BBF\u95EE npm registry\uFF1A{message}",
+  cliSyncStart: "\u5B8C\u6574\u540C\u6B65\uFF1A\u6B63\u5728\u91CD\u65B0\u626B\u63CF\u672C\u8BBE\u5907\u4E0A\u7684\u6240\u6709\u667A\u80FD\u4F53\u2026",
+  cliSyncScanned: "  \u5DF2\u626B\u63CF {roots} \u4E2A\u76EE\u5F55\u4E2D\u7684 {files} \u4E2A\u6587\u4EF6\uFF08{agents}\uFF09",
+  cliSyncUploaded: "  \u5DF2\u91CD\u65B0\u4E0A\u4F20 {buckets} \u4E2A\u5C0F\u65F6\u6BB5\u4E0E {sessions} \u4E2A\u4F1A\u8BDD",
+  cliSyncLocal: "  \u672A\u767B\u5F55 \u2014 \u6CA1\u6709\u4E0A\u4F20\u4EFB\u4F55\u6570\u636E\uFF08\u8BF7\u5148\u8FD0\u884C `codex-tracker login`\uFF09",
+  cliSyncDone: "\u540C\u6B65\u5B8C\u6210\uFF0C\u7528\u65F6 {seconds} \u79D2 \u2014 {sessions} \u4E2A\u4F1A\u8BDD\uFF0C\u4ECA\u65E5 {tokens} tok \xB7 {cost}",
+  cliSyncFailed: "\u540C\u6B65\u5931\u8D25\uFF1A{message}",
+  cliChannelDev: "\u5F00\u53D1\u7248 \u2014\u2014 \u4EEA\u8868\u76D8 {url} \xB7 \u914D\u7F6E\u76EE\u5F55 {dir}",
+  cliUpdateDevBuild: "\u8FD9\u662F\u672C\u5730\u5F00\u53D1\u7248\uFF1B`update` \u4F1A\u7528\u5DF2\u53D1\u5E03\u7684\u5305\u8986\u76D6\u5B83\u3002\u8BF7\u6539\u4E3A\u5728\u4ED3\u5E93\u4E2D\u8FD0\u884C `pnpm build`\u3002"
 };
 
 // src/i18n/index.ts
@@ -1849,21 +1992,21 @@ function findSessionInfo(storage, sessionID) {
   const key = `${storage}|${sessionID}`;
   const cached = sessionCache.get(key);
   if (cached && (cached.info || Date.now() - cached.at < 6e4)) return cached.info;
-  let info = null;
+  let info2 = null;
   const sessionDir = import_node_path6.default.join(storage, "session");
   const direct = import_node_path6.default.join(sessionDir, "info", `${sessionID}.json`);
-  if (import_node_fs4.default.existsSync(direct)) info = readJsonFile(direct);
-  if (!info) {
+  if (import_node_fs4.default.existsSync(direct)) info2 = readJsonFile(direct);
+  if (!info2) {
     for (const project of listDirs(sessionDir)) {
       const p = import_node_path6.default.join(sessionDir, project, `${sessionID}.json`);
       if (import_node_fs4.default.existsSync(p)) {
-        info = readJsonFile(p);
+        info2 = readJsonFile(p);
         break;
       }
     }
   }
-  sessionCache.set(key, { at: Date.now(), info });
-  return info;
+  sessionCache.set(key, { at: Date.now(), info: info2 });
+  return info2;
 }
 function openaiIsOAuth(dataDir) {
   const file = import_node_path6.default.join(dataDir, "auth.json");
@@ -1933,16 +2076,16 @@ var opencodeSource = {
       provider,
       usage: { input, cached, cacheWrite, output, reasoning: t2.reasoning ?? 0, total: input + output, requests: 1 }
     };
-    const info = storage ? findSessionInfo(storage, m.sessionID) : null;
-    const cwd = info?.directory ?? null;
+    const info2 = storage ? findSessionInfo(storage, m.sessionID) : null;
+    const cwd = info2?.directory ?? null;
     return {
       sessionId: m.sessionID,
       agent: file.root.agent,
       provider,
-      startedAt: info?.time?.created ?? ts2,
+      startedAt: info2?.time?.created ?? ts2,
       lastActivityAt: ts2,
       cwd,
-      projectName: projectNameOf(cwd) ?? info?.title ?? null,
+      projectName: projectNameOf(cwd) ?? info2?.title ?? null,
       originator: "opencode",
       source: "opencode",
       cliVersion: null,
@@ -2209,6 +2352,15 @@ var SessionStore = class {
   onChange = null;
   debounceTimer = null;
   sessionCache = null;
+  /**
+   * Forget the parsed-file index so the next deep refresh re-reads and re-parses every transcript.
+   * Used by the full sync: files are otherwise skipped while their size and mtime are unchanged, which
+   * would keep stale numbers around after a parser or pricing change.
+   */
+  reset() {
+    this.files.clear();
+    this.sessionCache = null;
+  }
   async refreshDeep() {
     const o = this.getOptions();
     this.roots = discoverSessionRoots({ extraSessionDirs: o.extraSessionDirs, sources: o.sources });
@@ -2366,7 +2518,20 @@ var SessionStore = class {
 
 // src/core/stats.ts
 var LIVE_WINDOW_MS = 5 * 60 * 1e3;
+var RATE_WINDOW_MS = 6e4;
+var BURST_WINDOW_MS = 1e4;
 var DAY3 = 864e5;
+function outputRate(events, now, windowMs, sessionStart) {
+  const from = now - windowMs;
+  let output = 0;
+  for (const e of events) {
+    if (e.ts <= from) continue;
+    output += e.usage.output;
+  }
+  if (output <= 0) return 0;
+  const elapsedSec = Math.max(1, (now - Math.max(from, sessionStart)) / 1e3);
+  return output / elapsedSec;
+}
 var PriceCache = class {
   constructor(overrides) {
     this.overrides = overrides;
@@ -2443,7 +2608,9 @@ function agentStats(sessions, since, prices) {
 function computeStats(input) {
   const now = input.now ?? Date.now();
   const prices = new PriceCache(input.pricing);
-  const sessions = input.sessions;
+  const sessions = input.sessions.map(
+    (s) => s.events.every((e) => isOpenAIModel(e.model)) ? s : { ...s, events: s.events.filter((e) => isOpenAIModel(e.model)) }
+  );
   const allEvents = [];
   const sessionCosts = /* @__PURE__ */ new Map();
   let lastActivityAt = null;
@@ -2469,14 +2636,8 @@ function computeStats(input) {
   let live = null;
   const liveSession = sessions.filter((s) => s.events.length && now - s.lastActivityAt <= LIVE_WINDOW_MS).sort((a, b) => b.lastActivityAt - a.lastActivityAt)[0];
   if (liveSession) {
-    let t60 = 0;
-    let t10 = 0;
-    for (const e of liveSession.events) {
-      const age = now - e.ts;
-      if (age <= 6e4) t60 += e.usage.total;
-      if (age <= 1e4) t10 += e.usage.total;
-    }
     const last = liveSession.events[liveSession.events.length - 1];
+    const start = liveSession.startedAt || liveSession.events[0].ts;
     live = {
       sessionId: liveSession.sessionId,
       agent: liveSession.agent,
@@ -2484,8 +2645,8 @@ function computeStats(input) {
       model: liveSession.model,
       startedAt: liveSession.startedAt,
       lastEventAt: last.ts,
-      tokensPerSecond: t60 / 60,
-      tokensPerSecond10s: t10 / 10,
+      tokensPerSecond: outputRate(liveSession.events, now, RATE_WINDOW_MS, start),
+      tokensPerSecond10s: outputRate(liveSession.events, now, BURST_WINDOW_MS, start),
       contextUsed: last.usage.input + last.usage.output,
       contextWindow: liveSession.contextWindow,
       sessionUsage: { ...liveSession.cumulative },
@@ -2512,6 +2673,7 @@ function computeStats(input) {
   }
   return {
     buckets,
+    sessions: sessions.filter((s) => s.events.length),
     today,
     week,
     month,
@@ -3869,12 +4031,12 @@ function createApi(pathParts = []) {
             `API path is expected to be of the form \`api.moduleName.functionName\`. Found: \`${found}\``
           );
         }
-        const path11 = pathParts.slice(0, -1).join("/");
+        const path12 = pathParts.slice(0, -1).join("/");
         const exportName = pathParts[pathParts.length - 1];
         if (exportName === "default") {
-          return path11;
+          return path12;
         } else {
-          return path11 + ":" + exportName;
+          return path12 + ":" + exportName;
         }
       } else if (prop === Symbol.toStringTag) {
         return "FunctionReference";
@@ -4038,8 +4200,8 @@ var require_constants = __commonJS({
 });
 var require_node_gyp_build = __commonJS({
   "../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js"(exports2, module2) {
-    var fs9 = __require("fs");
-    var path11 = __require("path");
+    var fs10 = __require("fs");
+    var path12 = __require("path");
     var os8 = __require("os");
     var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
     var vars2 = process.config && process.config.variables || {};
@@ -4056,21 +4218,21 @@ var require_node_gyp_build = __commonJS({
       return runtimeRequire(load.resolve(dir));
     }
     load.resolve = load.path = function(dir) {
-      dir = path11.resolve(dir || ".");
+      dir = path12.resolve(dir || ".");
       try {
-        var name = runtimeRequire(path11.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+        var name = runtimeRequire(path12.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
         if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
       } catch (err) {
       }
       if (!prebuildsOnly) {
-        var release = getFirst(path11.join(dir, "build/Release"), matchBuild);
+        var release = getFirst(path12.join(dir, "build/Release"), matchBuild);
         if (release) return release;
-        var debug = getFirst(path11.join(dir, "build/Debug"), matchBuild);
+        var debug = getFirst(path12.join(dir, "build/Debug"), matchBuild);
         if (debug) return debug;
       }
       var prebuild = resolve(dir);
       if (prebuild) return prebuild;
-      var nearby = resolve(path11.dirname(process.execPath));
+      var nearby = resolve(path12.dirname(process.execPath));
       if (nearby) return nearby;
       var target = [
         "platform=" + platform,
@@ -4087,26 +4249,26 @@ var require_node_gyp_build = __commonJS({
       ].filter(Boolean).join(" ");
       throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
       function resolve(dir2) {
-        var tuples = readdirSync(path11.join(dir2, "prebuilds")).map(parseTuple);
+        var tuples = readdirSync(path12.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
         if (!tuple) return;
-        var prebuilds = path11.join(dir2, "prebuilds", tuple.name);
+        var prebuilds = path12.join(dir2, "prebuilds", tuple.name);
         var parsed = readdirSync(prebuilds).map(parseTags);
         var candidates = parsed.filter(matchTags(runtime, abi));
         var winner = candidates.sort(compareTags(runtime))[0];
-        if (winner) return path11.join(prebuilds, winner.file);
+        if (winner) return path12.join(prebuilds, winner.file);
       }
     };
     function readdirSync(dir) {
       try {
-        return fs9.readdirSync(dir);
+        return fs10.readdirSync(dir);
       } catch (err) {
         return [];
       }
     }
     function getFirst(dir, filter) {
       var files = readdirSync(dir).filter(filter);
-      return files[0] && path11.join(dir, files[0]);
+      return files[0] && path12.join(dir, files[0]);
     }
     function matchBuild(name) {
       return /\.node$/.test(name);
@@ -4193,7 +4355,7 @@ var require_node_gyp_build = __commonJS({
       return typeof window !== "undefined" && window.process && window.process.type === "renderer";
     }
     function isAlpine(platform2) {
-      return platform2 === "linux" && fs9.existsSync("/etc/alpine-release");
+      return platform2 === "linux" && fs10.existsSync("/etc/alpine-release");
     }
     load.parseTags = parseTags;
     load.matchTags = matchTags;
@@ -7739,13 +7901,13 @@ var require_websocket_server = __commonJS({
           }
         }
         if (this.options.verifyClient) {
-          const info = {
+          const info2 = {
             origin: req.headers[`${version2 === 8 ? "sec-websocket-origin" : "origin"}`],
             secure: !!(req.socket.authorized || req.socket.encrypted),
             req
           };
           if (this.options.verifyClient.length === 2) {
-            this.options.verifyClient(info, (verified, code2, message, headers) => {
+            this.options.verifyClient(info2, (verified, code2, message, headers) => {
               if (!verified) {
                 return abortHandshake(socket, code2 || 401, message, headers);
               }
@@ -7761,7 +7923,7 @@ var require_websocket_server = __commonJS({
             });
             return;
           }
-          if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
+          if (!this.options.verifyClient(info2)) return abortHandshake(socket, 401);
         }
         this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
       }
@@ -8757,11 +8919,25 @@ var Uploader = class {
       throw err;
     }
   }
-  /** Upload changed hour buckets and session summaries. Returns counts of pushed items. */
-  async pushAll(buckets, sessions, sessionCosts) {
+  /** Wait for an in-flight incremental push to finish so a full sync isn't skipped by the guard. */
+  async awaitIdle(timeoutMs = 15e3) {
+    const deadline = Date.now() + timeoutMs;
+    while (this.inFlight && Date.now() < deadline) await new Promise((r) => setTimeout(r, 100));
+  }
+  /**
+   * Upload changed hour buckets and session summaries. Returns counts of pushed items.
+   * With `full`, the record of what was already pushed is dropped first so *everything* is re-sent —
+   * that is what recalibrates this device's totals on the dashboard after a parser or pricing change.
+   */
+  async pushAll(buckets, sessions, sessionCosts, opts = {}) {
+    if (opts.full) await this.awaitIdle();
     if (this.inFlight) return { buckets: 0, sessions: 0 };
     this.inFlight = true;
     try {
+      if (opts.full) {
+        this.state.pushedBuckets = {};
+        this.state.pushedSessions = {};
+      }
       const changed = [];
       const hashes = /* @__PURE__ */ new Map();
       for (const b of buckets.sort((a, b2) => a.hourStart - b2.hourStart)) {
@@ -8967,9 +9143,167 @@ async function fetchLiveRateLimits(appVersion, timeoutMs = 1e4) {
   }
 }
 
-// src/version.ts
-var APP_VERSION = true ? "0.1.1" : "0.0.0-dev";
-var APP_NAME = "Codex Tracker";
+// src/core/update.ts
+var import_node_fs8 = __toESM(require("node:fs"));
+var import_node_path10 = __toESM(require("node:path"));
+var import_node_child_process3 = require("node:child_process");
+var NPM_PACKAGE = "codex-token-tracker";
+var CHECK_TTL_MS = 6 * 60 * 60 * 1e3;
+var REQUEST_TIMEOUT_MS = 8e3;
+var INSTALL_TIMEOUT_MS = 10 * 60 * 1e3;
+var LOG_TAIL_CHARS = 4e3;
+function parseVersion(v2) {
+  const s = String(v2 ?? "").trim().replace(/^v/, "");
+  const i2 = s.indexOf("-");
+  const core = i2 === -1 ? s : s.slice(0, i2);
+  const pre = i2 === -1 ? "" : s.slice(i2 + 1);
+  const n = core.split(".").map((x) => Number.parseInt(x, 10) || 0);
+  return { nums: [n[0] ?? 0, n[1] ?? 0, n[2] ?? 0], pre };
+}
+function compareVersions(a, b) {
+  const A = parseVersion(a);
+  const B = parseVersion(b);
+  for (let i2 = 0; i2 < 3; i2++) if (A.nums[i2] !== B.nums[i2]) return A.nums[i2] < B.nums[i2] ? -1 : 1;
+  if (A.pre === B.pre) return 0;
+  if (!A.pre) return 1;
+  if (!B.pre) return -1;
+  return A.pre < B.pre ? -1 : 1;
+}
+function isDevBuild(version2) {
+  return IS_DEV_BUILD || version2.startsWith("0.0.0");
+}
+function registryBase() {
+  const r = process.env.CODEX_TRACKER_REGISTRY || process.env.npm_config_registry || process.env.NPM_CONFIG_REGISTRY || "https://registry.npmjs.org";
+  return r.replace(/\/+$/, "");
+}
+async function fetchLatestVersion(signal) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), REQUEST_TIMEOUT_MS);
+  signal?.addEventListener("abort", () => ctrl.abort(), { once: true });
+  try {
+    const res = await fetch(`${registryBase()}/-/package/${NPM_PACKAGE}/dist-tags`, {
+      signal: ctrl.signal,
+      headers: { accept: "application/json" }
+    });
+    if (!res.ok) throw new Error(`registry responded ${res.status}`);
+    const json = await res.json();
+    const latest = json?.latest;
+    if (typeof latest !== "string" || !latest) throw new Error("registry returned no `latest` tag");
+    return latest;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function detectPackageManager(installDir = import_node_path10.default.resolve(__dirname, "..")) {
+  const p = installDir.replace(/\\/g, "/").toLowerCase();
+  if (/\/\.?bun\//.test(p)) return "bun";
+  if (/\/\.?pnpm[/-]/.test(p)) return "pnpm";
+  if (/\/\.?yarn\//.test(p)) return "yarn";
+  const ua = (process.env.npm_config_user_agent ?? "").toLowerCase();
+  if (ua.startsWith("pnpm")) return "pnpm";
+  if (ua.startsWith("yarn")) return "yarn";
+  if (ua.startsWith("bun")) return "bun";
+  return "npm";
+}
+function updateArgs(pm, spec = `${NPM_PACKAGE}@latest`) {
+  switch (pm) {
+    case "pnpm":
+      return ["add", "-g", spec];
+    case "yarn":
+      return ["global", "add", spec];
+    case "bun":
+      return ["add", "-g", spec];
+    default:
+      return ["install", "-g", spec];
+  }
+}
+function updateCommand(pm, spec) {
+  return `${pm} ${updateArgs(pm, spec).join(" ")}`;
+}
+function cachePath() {
+  return import_node_path10.default.join(configDir(), "update.json");
+}
+function readCache() {
+  try {
+    const raw = JSON.parse(import_node_fs8.default.readFileSync(cachePath(), "utf8"));
+    if (typeof raw?.latest === "string" && typeof raw.checkedAt === "number") {
+      return { latest: raw.latest, checkedAt: raw.checkedAt };
+    }
+  } catch {
+  }
+  return null;
+}
+function writeCache(c) {
+  try {
+    import_node_fs8.default.mkdirSync(import_node_path10.default.dirname(cachePath()), { recursive: true });
+    import_node_fs8.default.writeFileSync(cachePath(), JSON.stringify(c, null, 2));
+  } catch {
+  }
+}
+function info(current, latest, checkedAt, error) {
+  const pm = detectPackageManager();
+  return {
+    current,
+    latest,
+    available: Boolean(latest) && !isDevBuild(current) && compareVersions(latest, current) > 0,
+    checkedAt,
+    error,
+    packageManager: pm,
+    command: updateCommand(pm)
+  };
+}
+async function checkForUpdate(opts = {}) {
+  const current = opts.current ?? APP_VERSION;
+  const cached = readCache();
+  if (!opts.force && cached && Date.now() - cached.checkedAt < CHECK_TTL_MS) {
+    return info(current, cached.latest, cached.checkedAt, null);
+  }
+  try {
+    const latest = await fetchLatestVersion(opts.signal);
+    const checkedAt = Date.now();
+    writeCache({ latest, checkedAt });
+    return info(current, latest, checkedAt, null);
+  } catch (err) {
+    return info(current, cached?.latest ?? null, cached?.checkedAt ?? null, err.message);
+  }
+}
+function runUpdate(opts = {}) {
+  const pm = detectPackageManager();
+  const spec = opts.version ? `${NPM_PACKAGE}@${opts.version}` : `${NPM_PACKAGE}@latest`;
+  const args = updateArgs(pm, spec);
+  const command = `${pm} ${args.join(" ")}`;
+  return new Promise((resolve) => {
+    let output = "";
+    const collect = (chunk) => {
+      const text = chunk.toString();
+      opts.onOutput?.(text);
+      output = (output + text).slice(-LOG_TAIL_CHARS);
+    };
+    let child;
+    try {
+      child = (0, import_node_child_process3.spawn)(pm, args, {
+        // Electron's bundled Node has no shell PATH resolution for `npm.cmd` on Windows.
+        shell: process.platform === "win32",
+        env: { ...process.env, ELECTRON_RUN_AS_NODE: void 0 },
+        windowsHide: true
+      });
+    } catch (err) {
+      resolve({ ok: false, code: null, command, output: err.message });
+      return;
+    }
+    const timer = setTimeout(() => child.kill(), INSTALL_TIMEOUT_MS);
+    child.stdout?.on("data", collect);
+    child.stderr?.on("data", collect);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({ ok: false, code: null, command, output: output + err.message });
+    });
+    child.on("close", (code2) => {
+      clearTimeout(timer);
+      resolve({ ok: code2 === 0, code: code2, command, output });
+    });
+  });
+}
 
 // src/core/engine.ts
 var SHALLOW_MS = 3e3;
@@ -8978,6 +9312,8 @@ var TICK_MS = 2e3;
 var REMOTE_MS = 6e4;
 var LIVE_LIMITS_DEBOUNCE_MS = 1e4;
 var LIVE_LIMITS_MIN_GAP_MS = 2e4;
+var UPDATE_CHECK_MS = 6 * 60 * 60 * 1e3;
+var SYNC_BANNER_MS = 25e3;
 var Engine = class extends import_node_events.EventEmitter {
   constructor(opts) {
     super();
@@ -9014,6 +9350,16 @@ var Engine = class extends import_node_events.EventEmitter {
   liveLimitsInFlight = false;
   liveLimitsTimer = null;
   lastLiveLimitsAttempt = 0;
+  update = null;
+  updateStatus = "idle";
+  updateLog = null;
+  syncStatus = "idle";
+  syncPhase = null;
+  syncStartedAt = null;
+  syncFinishedAt = null;
+  syncError = null;
+  syncResult = null;
+  syncBannerTimer = null;
   get heatmapWeeks() {
     return this.opts.heatmapWeeks ?? 16;
   }
@@ -9035,6 +9381,8 @@ var Engine = class extends import_node_events.EventEmitter {
       return;
     }
     void this.refreshLiveLimits(true);
+    void this.checkUpdate(false);
+    this.timers.push(setInterval(() => void this.checkUpdate(false), UPDATE_CHECK_MS));
     this.store.startWatching(() => void this.refresh(false));
     this.timers.push(setInterval(() => void this.refresh(false), SHALLOW_MS));
     this.timers.push(setInterval(() => void this.refresh(true), DEEP_MS));
@@ -9062,6 +9410,8 @@ var Engine = class extends import_node_events.EventEmitter {
     this.timers = [];
     if (this.liveLimitsTimer) clearTimeout(this.liveLimitsTimer);
     this.liveLimitsTimer = null;
+    if (this.syncBannerTimer) clearTimeout(this.syncBannerTimer);
+    this.syncBannerTimer = null;
     this.store.stopWatching();
     this.pending?.abort.abort();
   }
@@ -9141,7 +9491,7 @@ var Engine = class extends import_node_events.EventEmitter {
     if (!this.signedIn) return { buckets: 0, sessions: 0 };
     if (!this.stats) this.recompute();
     try {
-      const r = await this.uploader.pushAll(this.stats.buckets, this.store.sessions(), this.stats.sessionCosts);
+      const r = await this.uploader.pushAll(this.stats.buckets, this.stats.sessions, this.stats.sessionCosts);
       this.emitSnapshot();
       return r;
     } catch (err) {
@@ -9165,6 +9515,154 @@ var Engine = class extends import_node_events.EventEmitter {
     await this.uploader.fetchRemote(this.heatmapWeeks);
     this.recompute();
   }
+  /**
+   * Full sync ("calibrate this device"). Unlike the periodic incremental upload this deliberately
+   * throws away every cache on the way:
+   *  1. re-read the config so sources enabled since start-up are picked up,
+   *  2. drop the parsed-file index and re-discover + re-parse every transcript of every agent
+   *     (Codex plus the agents running on the Codex subscription: pi, OpenCode, Cline/Roo/Kilo,
+   *     Hermes and any custom `extraSessionDirs`),
+   *  3. recompute the aggregates with the current pricing table,
+   *  4. re-upload *everything* — not just what changed — so the dashboard's totals for this device
+   *     are replaced by the freshly computed ones,
+   *  5. pull the other devices' rows and the live rate limits back down.
+   *
+   * Returns null when a sync is already running. Never throws: failures land in the returned state.
+   */
+  async syncNow() {
+    if (this.syncStatus === "running") return null;
+    if (this.syncBannerTimer) {
+      clearTimeout(this.syncBannerTimer);
+      this.syncBannerTimer = null;
+    }
+    const startedAt = Date.now();
+    this.syncStatus = "running";
+    this.syncPhase = null;
+    this.syncStartedAt = startedAt;
+    this.syncFinishedAt = null;
+    this.syncError = null;
+    const phase = (p) => {
+      this.syncPhase = p;
+      this.emitSnapshot();
+    };
+    try {
+      phase("scanning");
+      this.reloadConfig();
+      this.store.reset();
+      await this.store.refreshDeep();
+      phase("computing");
+      this.recompute();
+      let uploadedBuckets = 0;
+      let uploadedSessions = 0;
+      const uploaded = this.opts.upload && this.signedIn;
+      if (uploaded) {
+        phase("uploading");
+        const r = await this.uploader.pushAll(this.stats.buckets, this.stats.sessions, this.stats.sessionCosts, { full: true });
+        uploadedBuckets = r.buckets;
+        uploadedSessions = r.sessions;
+        await this.heartbeatNow().catch(() => {
+        });
+        phase("downloading");
+        await this.fetchRemoteNow();
+      }
+      phase("limits");
+      await this.refreshLiveLimits(true);
+      const finishedAt = Date.now();
+      this.syncResult = {
+        startedAt,
+        finishedAt,
+        durationMs: finishedAt - startedAt,
+        files: this.store.fileCount,
+        sessions: this.store.sessions().length,
+        roots: this.store.roots.length,
+        agents: [...new Set(this.store.roots.map((r) => r.agent))].sort(),
+        uploadedBuckets,
+        uploadedSessions,
+        uploaded
+      };
+      this.syncStatus = "done";
+      this.syncFinishedAt = finishedAt;
+      this.opts.log?.(
+        `sync: ${this.syncResult.files} files, ${this.syncResult.sessions} sessions, ${uploadedBuckets} buckets / ${uploadedSessions} sessions uploaded in ${this.syncResult.durationMs} ms`
+      );
+      return this.syncResult;
+    } catch (err) {
+      this.syncStatus = "error";
+      this.syncFinishedAt = Date.now();
+      this.syncError = err instanceof SignedOutError ? "not signed in" : errorMessage(err);
+      this.opts.log?.(`sync failed: ${this.syncError}`);
+      return null;
+    } finally {
+      this.syncPhase = null;
+      this.emitSnapshot();
+      this.scheduleSyncBannerClear();
+    }
+  }
+  /** Return the sync banner to "idle" a little after it finished, keeping `last` for the footer. */
+  scheduleSyncBannerClear() {
+    if (this.opts.watch === false) return;
+    if (this.syncBannerTimer) clearTimeout(this.syncBannerTimer);
+    this.syncBannerTimer = setTimeout(() => {
+      this.syncBannerTimer = null;
+      if (this.syncStatus === "done" || this.syncStatus === "error") {
+        this.syncStatus = "idle";
+        this.emitSnapshot();
+      }
+    }, SYNC_BANNER_MS);
+    this.syncBannerTimer.unref?.();
+  }
+  syncState() {
+    return {
+      status: this.syncStatus,
+      phase: this.syncPhase,
+      startedAt: this.syncStartedAt,
+      finishedAt: this.syncFinishedAt,
+      error: this.syncError,
+      last: this.syncResult
+    };
+  }
+  /**
+   * Ask the npm registry for the newest published version (cached for 6 h unless `force`).
+   * Best-effort: a failure is recorded on the snapshot, never thrown.
+   */
+  async checkUpdate(force) {
+    if (!this.config.checkUpdates) {
+      this.update = null;
+      return null;
+    }
+    if (this.updateStatus === "checking" || this.updateStatus === "installing") return this.update;
+    this.updateStatus = "checking";
+    this.emitSnapshot();
+    this.update = await checkForUpdate({ force });
+    this.updateStatus = "idle";
+    if (this.update.error) this.opts.log?.(`update check failed: ${this.update.error}`);
+    this.emitSnapshot();
+    return this.update;
+  }
+  /**
+   * Install the newest version globally with the package manager this copy came from.
+   * The new code only takes effect once the app is restarted, so the UI says so rather than
+   * pretending to hot-swap itself.
+   */
+  async installUpdate() {
+    if (this.updateStatus === "installing") return false;
+    if (!this.update?.available) await this.checkUpdate(true);
+    if (!this.update?.available) return false;
+    this.updateStatus = "installing";
+    this.updateLog = null;
+    this.emitSnapshot();
+    const r = await runUpdate({ version: this.update.latest ?? void 0 });
+    this.updateStatus = r.ok ? "installed" : "failed";
+    this.updateLog = r.ok ? null : `${r.command}
+${r.output}`.trim();
+    if (!r.ok) this.opts.log?.(`update install failed (${r.code}): ${r.output}`);
+    this.emitSnapshot();
+    return r.ok;
+  }
+  updateState() {
+    if (!this.config.checkUpdates || !this.update) return null;
+    return { ...this.update, status: this.updateStatus, log: this.updateLog };
+  }
   /** Start the device-code login flow (resolves when approved / denied / expired / cancelled). */
   async login(openBrowser, onCode) {
     if (this.pending) return { status: "cancelled" };
@@ -9240,6 +9738,7 @@ var Engine = class extends import_node_events.EventEmitter {
     const sessions = this.store.sessions();
     return {
       version: APP_VERSION,
+      channel: APP_CHANNEL,
       generatedAt: Date.now(),
       language: this.language(),
       languageSetting: this.config.language,
@@ -9257,6 +9756,8 @@ var Engine = class extends import_node_events.EventEmitter {
       rateLimits: this.liveLimits ?? fromLogRateLimits(s.logRateLimits),
       rateLimitsError: this.config.liveRateLimits ? this.liveLimitsError : null,
       rateLimitsUpdatedAt: this.liveLimits ? this.liveLimitsAt : s.logRateLimits?.observedAt ?? null,
+      update: this.updateState(),
+      sync: this.syncState(),
       modelsToday: s.modelsToday,
       modelsMonth: s.modelsMonth,
       byAgentToday: s.byAgentToday,
@@ -9273,6 +9774,7 @@ var Engine = class extends import_node_events.EventEmitter {
       },
       sessionDirs: SessionStore.rootDirs(this.store.roots),
       sessionRoots: this.store.roots.map((r) => ({ dir: r.dir, agent: r.agent, format: r.format, origin: r.origin })),
+      configDir: configDir(),
       launchAtLogin: this.config.launchAtLogin,
       trayTitle: this.config.trayTitle
     };
@@ -9281,9 +9783,9 @@ var Engine = class extends import_node_events.EventEmitter {
 
 // src/main.ts
 var DEBUG = Boolean(process.env.CODEX_TRACKER_DEBUG);
-var assetsDir = import_node_path10.default.join(__dirname, "..", "assets");
-var rendererIndex = import_node_path10.default.join(__dirname, "renderer", "index.html");
-var preloadPath = import_node_path10.default.join(__dirname, "preload.js");
+var assetsDir = import_node_path11.default.join(__dirname, "..", "assets");
+var rendererIndex = import_node_path11.default.join(__dirname, "renderer", "index.html");
+var preloadPath = import_node_path11.default.join(__dirname, "preload.js");
 var isMac = process.platform === "darwin";
 var isWin = process.platform === "win32";
 var mb = null;
@@ -9294,12 +9796,12 @@ function log2(...args) {
 }
 function trayIcon() {
   if (isMac) {
-    const img2 = import_electron.nativeImage.createFromPath(import_node_path10.default.join(assetsDir, "trayTemplate.png"));
+    const img2 = import_electron.nativeImage.createFromPath(import_node_path11.default.join(assetsDir, "trayTemplate.png"));
     img2.setTemplateImage(true);
     return img2;
   }
   const file = import_electron.nativeTheme.shouldUseDarkColors || !isWin ? "tray-win.png" : "tray-win-light.png";
-  const img = import_electron.nativeImage.createFromPath(import_node_path10.default.join(assetsDir, file));
+  const img = import_electron.nativeImage.createFromPath(import_node_path11.default.join(assetsDir, file));
   return isWin ? img.resize({ width: 16, height: 16 }) : img;
 }
 function trayText(s) {
@@ -9319,28 +9821,29 @@ function updateTray(s) {
   mb.tray.setToolTip(`${APP_NAME} \u2014 ${t(L, "today")}: ${formatTokens(s.today.usage.total)} \xB7 ${formatUSD(s.today.cost)}${live}`);
   if (isMac) mb.tray.setTitle(trayText(s), { fontType: "monospacedDigit" });
 }
-var launchAgentPath = import_node_path10.default.join(import_node_os7.default.homedir(), "Library", "LaunchAgents", "dev.codex-tracker.menubar.plist");
+var launchAgentLabel = IS_DEV_BUILD ? "dev.codex-tracker.menubar.dev" : "dev.codex-tracker.menubar";
+var launchAgentPath = import_node_path11.default.join(import_node_os7.default.homedir(), "Library", "LaunchAgents", `${launchAgentLabel}.plist`);
 function setLaunchAtLogin(enabled) {
   if (isMac) {
     if (enabled) {
       const plist = `<?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>dev.codex-tracker.menubar</string>
-  <key>ProgramArguments</key><array><string>${process.execPath}</string><string>${import_node_path10.default.join(__dirname, "main.js")}</string></array>
+  <key>Label</key><string>${launchAgentLabel}</string>
+  <key>ProgramArguments</key><array><string>${process.execPath}</string><string>${import_node_path11.default.join(__dirname, "main.js")}</string></array>
   <key>RunAtLoad</key><true/>
   <key>KeepAlive</key><false/>
   <key>ProcessType</key><string>Interactive</string>
 </dict></plist>
 `;
-      import_node_fs8.default.mkdirSync(import_node_path10.default.dirname(launchAgentPath), { recursive: true });
-      import_node_fs8.default.writeFileSync(launchAgentPath, plist);
-      (0, import_node_child_process3.execFile)("launchctl", ["load", "-w", launchAgentPath], () => {
+      import_node_fs9.default.mkdirSync(import_node_path11.default.dirname(launchAgentPath), { recursive: true });
+      import_node_fs9.default.writeFileSync(launchAgentPath, plist);
+      (0, import_node_child_process4.execFile)("launchctl", ["load", "-w", launchAgentPath], () => {
       });
-    } else if (import_node_fs8.default.existsSync(launchAgentPath)) {
-      (0, import_node_child_process3.execFile)("launchctl", ["unload", "-w", launchAgentPath], () => {
+    } else if (import_node_fs9.default.existsSync(launchAgentPath)) {
+      (0, import_node_child_process4.execFile)("launchctl", ["unload", "-w", launchAgentPath], () => {
         try {
-          import_node_fs8.default.unlinkSync(launchAgentPath);
+          import_node_fs9.default.unlinkSync(launchAgentPath);
         } catch {
         }
       });
@@ -9348,7 +9851,7 @@ function setLaunchAtLogin(enabled) {
     return;
   }
   if (isWin) {
-    import_electron.app.setLoginItemSettings({ openAtLogin: enabled, path: process.execPath, args: [import_node_path10.default.join(__dirname, "main.js")] });
+    import_electron.app.setLoginItemSettings({ openAtLogin: enabled, path: process.execPath, args: [import_node_path11.default.join(__dirname, "main.js")] });
   }
 }
 function buildMenu(s) {
@@ -9361,6 +9864,7 @@ function buildMenu(s) {
   });
   const template = [
     { label: `${APP_NAME} ${t(L, "version", { version: APP_VERSION })}`, enabled: false },
+    ...IS_DEV_BUILD ? [{ label: t(L, "devBuildMenu", { url: s.auth.dashboardUrl }), enabled: false }] : [],
     {
       label: s.auth.status === "signedIn" ? t(L, "signedInAs", { name: s.auth.user?.name || s.auth.user?.email || "?" }) : t(L, "signedOut"),
       enabled: false
@@ -9385,6 +9889,14 @@ function buildMenu(s) {
       }
     ] : [],
     { label: t(L, "refresh"), click: () => void engine?.refresh(true) },
+    {
+      label: s.sync.status === "running" ? t(L, "syncing") : t(L, "syncNow"),
+      enabled: s.sync.status !== "running",
+      click: () => void engine?.syncNow()
+    },
+    ...s.update ? [
+      s.update.available ? { label: t(L, "updateAvailable", { version: s.update.latest ?? "?" }), click: () => void engine?.installUpdate() } : { label: t(L, "checkForUpdates"), click: () => void engine?.checkUpdate(true) }
+    ] : [],
     { type: "separator" },
     { label: t(L, "quit"), click: () => import_electron.app.quit() }
   ];
@@ -9398,10 +9910,10 @@ async function startLogin() {
     log2("login failed", errorMessage(err));
   }
 }
+import_electron.app.setName(APP_NAME);
 if (!import_electron.app.requestSingleInstanceLock()) {
   import_electron.app.quit();
 } else {
-  import_electron.app.setName(APP_NAME);
   import_electron.app.on("second-instance", () => mb?.showWindow());
   import_electron.app.on("window-all-closed", () => {
   });
@@ -9441,6 +9953,9 @@ if (!import_electron.app.requestSingleInstanceLock()) {
   import_electron.ipcMain.handle("auth:cancel", () => engine?.cancelLogin());
   import_electron.ipcMain.handle("auth:logout", () => engine?.logout());
   import_electron.ipcMain.handle("refresh", () => engine?.refresh(true).then(() => void 0));
+  import_electron.ipcMain.handle("sync:now", () => engine?.syncNow().then(() => void 0));
+  import_electron.ipcMain.handle("update:check", () => engine?.checkUpdate(true).then(() => void 0));
+  import_electron.ipcMain.handle("update:install", () => engine?.installUpdate().then(() => void 0));
   import_electron.ipcMain.handle("quit", () => import_electron.app.quit());
   mb.on("ready", async () => {
     if (isMac) import_electron.app.dock?.hide();
@@ -9466,7 +9981,7 @@ if (!import_electron.app.requestSingleInstanceLock()) {
       setTimeout(async () => {
         try {
           const img = await mb.window.webContents.capturePage();
-          import_node_fs8.default.writeFileSync(shot, img.toPNG());
+          import_node_fs9.default.writeFileSync(shot, img.toPNG());
           log2("screenshot written", shot);
         } catch (err) {
           log2("screenshot failed", errorMessage(err));
@@ -9482,7 +9997,7 @@ if (!import_electron.app.requestSingleInstanceLock()) {
       return { action: "deny" };
     });
     win.webContents.on("console-message", (_e, level, message, line, sourceId) => {
-      if (DEBUG || level >= 2) console.error(`[renderer:${level}] ${message} (${import_node_path10.default.basename(sourceId)}:${line})`);
+      if (DEBUG || level >= 2) console.error(`[renderer:${level}] ${message} (${import_node_path11.default.basename(sourceId)}:${line})`);
     });
     win.webContents.on("render-process-gone", (_e, details) => log2("renderer gone", details));
     if (process.env.CODEX_TRACKER_DEVTOOLS) win.webContents.openDevTools({ mode: "detach" });