@vibe-cafe/vibe-usage 0.14.3 → 0.14.5

package/README.md

@@ -84,7 +84,7 @@ Quota results are never uploaded or added to incremental sync state. Credential-
 | Grok | `$GROK_HOME/sessions/<encoded-cwd>/<session-id>/` (default `~/.grok`) plus explicitly added Grok Homes; token usage from `updates.jsonl` `turn_completed.usage` (per-model `modelUsage`, cache reads, reasoning); project from `summary.json` cwd; copied sessions keep the more complete local record |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
 | CraftAgent | `~/.craft-agent/workspaces/*/sessions/*/.pi-sessions/*.jsonl`; honors `$CRAFT_AGENT_DIR` / `$CRAFTAGENT_DIR`; cache writes are included in input usage |
-| Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`); cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count |
+| Cursor | `state.vscdb` (SQLite; reads only the token Cursor itself already stored locally, never logs in or refreshes it) plus `cursor.com`'s usage CSV, with the dashboard's paginated usage-events API as fallback when the CSV is empty or changes shape; cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count; `status` shows the signed-in account and newest event |
 | DimAgent | `$DIMCODE_HOME/dimcode.sqlite` (default `~/.dimcode/v2/dimcode.sqlite`); exact usage from `usage_ledger`, with forked ledger/history copies deduplicated |
 | Gemini CLI | `~/.gemini/tmp/<project_hash>/chats/session-*.jsonl` (current line-delimited format) and legacy `session-*.json`; recurses into nested subagent sessions |
 | OpenCode | `~/.local/share/opencode/opencode.db` (SQLite) — both the legacy `message` table and the 2.x `session_message` projection are read, merged by message id — with `storage/message/` as the legacy alternative; cache writes are counted as 5m cache creation; supports explicitly added data roots |
@@ -144,19 +144,23 @@ To relabel old history, the maintainer needs the old bucket keys, raw per-tool t
 - Uploads buckets + sessions to your vibecafe.ai dashboard (always gzip-compressed, ~94% smaller)
 - Incremental upload: every parser emits a complete local snapshot, then only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Upload state remains in `~/.vibe-usage/state.json`; failed or still-indexing parsers retain their prior state, while deleted local logs are pruned. Deleting the state file triggers a one-time full re-upload, and `reset` clears it automatically after deleting cloud data
 - Incremental Codex parsing: a versioned, disposable cache under `~/.vibe-usage/cache/codex/` stores per-rollout aggregate results and parser continuation state. Unchanged rollouts require no raw-log reads; an ordinary append reads only the new tail; forks, sub-agents, replacements, truncations, and failed safety checks fall back to the full correctness path. Multi-file sessions have a combined cache that rebuilds when any segment changes. A bounded rolling audit occasionally re-reads one historical file or continuation group. Very large first-time indexes checkpoint before the Mac app timeout and resume on the next sync instead of restarting
+- Interactive `sync` shows a live status line (`正在读取上传设置` → `正在扫描本地日志 12/35 · 已用时 2m10s`) while it reads backend settings and scans/indexes local logs. A first sync, a cold Codex index rebuild, or a Cursor account with a long event history can take minutes, so that line is what separates a slow sync from a hung one. It is printed only on a TTY — the Mac and Windows apps read the piped stdout as the result text and must keep receiving plain output. Interrupting a sync is safe: finished batches are already committed, and the Codex index checkpoints and resumes on the next run
 - The Codex parser cache contains derived aggregates and replay metadata, not raw prompt or response text. It is independent of upload state and can be deleted safely (the next sync rebuilds it). `reset` intentionally keeps it so the required full re-upload does not also require a full disk rescan. Set `VIBE_USAGE_CODEX_CACHE=0` to disable the optimization for diagnosis
 - SQLite-backed tools are read via Node's built-in `node:sqlite` on Node ≥ 22.5 — no `sqlite3` binary needed (works on Windows out of the box); on older Node the CLI falls back to the system `sqlite3` executable
 - Continuous syncing is on by default: the first run installs a background service (see [Background sync](#background-sync)); the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app) is the menu-bar alternative
 
 ## Cursor 网络排查
 
-Cursor 用量需要从 `cursor.com` 下载 CSV。`Cursor usage export skipped (network: …)` 表示这次下载失败；CLI 会保留 Cursor 的历史同步状态，下次同步重新尝试。
+Cursor 用量优先读取 `cursor.com` 的 CSV 导出（模型名最准确）。如果 CSV 为空、表头变化或没有 token 计数，会自动改用仪表盘自己的分页用量事件接口（`/api/dashboard/get-filtered-usage-events`）；该接口较早事件的模型名可能显示为 `default`，但 token 总量正确。CSV 仍可用但最新事件已超过 24 小时（且不超过 7 天）时，会只向事件接口补“CSV 最新事件之后”的增量，不覆盖或重传历史。`Cursor usage export skipped (network: …)` / `Cursor usage request skipped (network: …)` 表示这次请求失败；CLI 会保留 Cursor 的历史同步状态，下次同步重新尝试。
 
 - `ENOTFOUND` / `EAI_AGAIN`：检查 DNS 和终端网络。
 - `UND_ERR_CONNECT_TIMEOUT` / `ETIMEDOUT` / `ECONNRESET`：检查到 Cursor 的连接及终端代理。浏览器或 Cursor 应用能联网，不代表 Node.js 使用了相同代理。
 - `CERT_*` / `UNABLE_TO_VERIFY_LEAF_SIGNATURE` 等：检查系统时间和代理或公司网络的 CA 证书配置；自定义 CA 可通过 `NODE_EXTRA_CA_CERTS` 指定。
-- `timeout after …ms`：导出超时。`cursor.com` 的导出是按整个账号现算的，**账号用量越大越慢**，所以重度用户会每次都超时、而不是偶尔。默认等待 120 秒；仍不够就调大，例如 `VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS=300000`，然后重跑一次 `sync` 补传历史。
+- `timeout after …ms`：请求超时（每页默认 120 秒）。可用 `VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS=300000` 调大，然后重跑一次 `sync` 补传历史。
 - `Cursor session rejected`：在 Cursor 的 Account 设置中重新登录，再同步。
+- 数据停在某一天、或刚换过 Cursor 账号：运行 `npx @vibe-cafe/vibe-usage status`。它会显示 Cursor 当前登录账号（本地脱敏标签）和最新事件时间；如果最新事件超过 48 小时且你最近用过 Cursor，通常是客户端仍登录旧账号。切换账号后 Cursor 的本地 `state.vscdb` 会更新，重新同步即可。
+- X 订阅（The X Subscription）账号的用量由 Cursor 与 Grok 共享：如果 Cursor 仪表盘本身没有新事件，请到 `grok.com/dashboard` 的 Usage 查看；CLI 只能读取 Cursor 仪表盘返回的 Cursor 事件。
+- 只有 X Premium+ / Grok 订阅、但 Cursor 里显示 `Free`：X Premium+ 不会自动把 Cursor 计划升级，需要在 `cursor.com/unify` 合并到 The X Subscription 后，Cursor 用量才进入共享池。`cursor.com/api/dashboard/get-sand-usage-status` 返回 `includedUsageSuperGrokPlan: "x-premium-plus"` 且 `cursorPlanName: "Free"` 就是这种状态。
 
 需要 HTTP/HTTPS 代理时，Node.js **22.21+ 或 24.5+** 可用 `NODE_USE_ENV_PROXY=1` 启用环境变量代理（[Node.js 官方说明](https://nodejs.org/en/learn/http/enterprise-network-configuration)）。以下为 macOS/Linux 终端示例，代理地址须替换为实际地址：
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.14.3",
+  "version": "0.14.5",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "scripts": {

package/src/index.js

@@ -76,7 +76,9 @@ async function showStatus() {
     // reads exactly like a healthy one, which is how a stale bundled CLI stayed
     // invisible (issue #100). state.json is the only local record of what was
     // actually uploaded, so count it per source.
-    const uploaded = uploadedItemCounts(loadState());
+    const state = loadState();
+    const uploaded = uploadedItemCounts(state);
+    const cursorInfo = state.parserMeta?.cursor;
     for (const tool of detected) {
       const buckets = uploaded.buckets.get(tool.id) || 0;
       const sessions = uploaded.sessions.get(tool.id) || 0;
@@ -86,6 +88,19 @@ async function showStatus() {
         console.log(`    ${tool.name}  ·  尚未上传过数据`);
         console.log(dimText('       本机检测到数据，但本地没有这条工具的上传记录：运行 `npx @vibe-cafe/vibe-usage` 同步'));
       }
+      if (tool.id === 'cursor' && cursorInfo) {
+        const detail = [];
+        if (cursorInfo.account) detail.push(`账号 ${cursorInfo.account}`);
+        if (cursorInfo.latestEventAt) {
+          detail.push(`最新事件 ${String(cursorInfo.latestEventAt).slice(0, 16).replace('T', ' ')}Z`);
+        }
+        if (Number.isFinite(cursorInfo.events)) detail.push(`${cursorInfo.events} 个事件`);
+        if (detail.length > 0) console.log(dimText(`       ${detail.join(' · ')}`));
+        const latest = Date.parse(cursorInfo.latestEventAt);
+        if (Number.isFinite(latest) && Date.now() - latest > 48 * 60 * 60 * 1000) {
+          console.log(dimText('       已超过 48 小时没有新的 Cursor 事件；如最近用过 Cursor，请确认 Cursor 登录的是这个账号'));
+        }
+      }
     }
     console.log();
   }

package/src/output.js

@@ -52,6 +52,65 @@ export function hint(msg) {
   console.log(dim(`提示: ${msg}`));
 }
 
+/**
+ * One redrawn status line for a phase that would otherwise leave the terminal
+ * blank for minutes: the settings round-trip (a timing-out endpoint re-trying),
+ * the local log scan, and a cold Codex index build. Without it the sync header
+ * is the last thing on screen, and "still working" is indistinguishable from
+ * "hung" — exactly how a slow first sync reads.
+ *
+ * TTY-only for the same reason as hint(): the Mac (`SyncEngine.swift`) and
+ * Windows (`sync_engine.rs`) apps run `sync` through a pipe and treat stdout as
+ * the result text, so a pipe must never receive these lines.
+ * `VIBE_USAGE_FORCE_PROGRESS=1` forces them on for tests, and
+ * `VIBE_USAGE_PROGRESS_INTERVAL_MS` overrides the redraw interval.
+ *
+ * `label` is a function so the caller owns the wording and its elapsed-time
+ * text; it is re-read on every redraw. The interval is unref'ed so a phase that
+ * never reaches `stop()` cannot hold the process open.
+ */
+export function liveStatus({ enabled = true, intervalMs } = {}) {
+  const configuredInterval = Number(process.env.VIBE_USAGE_PROGRESS_INTERVAL_MS);
+  const tickMs = intervalMs ?? (configuredInterval > 0 ? configuredInterval : 5000);
+  const active = enabled
+    && (!!process.stdout.isTTY || process.env.VIBE_USAGE_FORCE_PROGRESS === '1');
+  let label = null;
+  let timer = null;
+  let startedAt = 0;
+
+  function draw() {
+    if (label === null) return;
+    process.stdout.write(`\r${dim(`  ${label(Date.now() - startedAt)}`)}\x1b[K`);
+  }
+
+  return {
+    /** Show the line, or retarget it to the next phase. */
+    start(nextLabel) {
+      if (!active) return;
+      label = nextLabel;
+      startedAt = Date.now();
+      draw();
+      if (timer === null) {
+        timer = setInterval(draw, tickMs);
+        unrefTimer(timer);
+      }
+    },
+    /** Erase the line before regular output continues on it. */
+    stop() {
+      if (!active || label === null) return;
+      clearInterval(timer);
+      timer = null;
+      label = null;
+      process.stdout.write('\r\x1b[K');
+    },
+  };
+}
+
+/** Bun's timer objects and Node's both expose unref; tests run on either. */
+function unrefTimer(timer) {
+  if (typeof timer?.unref === 'function') timer.unref();
+}
+
 /** Print a blank line. */
 export const nl = () => console.log();
 

package/src/parsers/contract.js

@@ -2,8 +2,10 @@
  * Parser result contract.
  *
  * Every parser exports an async parse() returning either
- *   { buckets: object[], sessions: object[], skipped?: boolean, warnings?: string[], indexing?: object }
- * or a legacy bare buckets array.
+ *   { buckets: object[], sessions: object[], skipped?: boolean, warnings?: string[], indexing?: object,
+ *     info?: object }
+ * or a legacy bare buckets array. `info` is optional local diagnostics (for
+ * example Cursor's signed-in account and newest event); it is never uploaded.
  *
  * buckets entries are the aggregateToBuckets() output shape
  * ({ source, model, project, hostname?, bucketStart, inputTokens, ... }).
@@ -51,5 +53,6 @@ export function normalizeParserResult(source, result) {
     skipped: result?.skipped === true,
     warnings,
     ...(result?.indexing ? { indexing: result.indexing } : {}),
+    ...(result?.info && typeof result.info === 'object' ? { info: result.info } : {}),
   };
 }

package/src/parsers/cursor.js

@@ -7,6 +7,13 @@ import { queryDbJsonSnapshotOnLock, sqliteUnavailableError, isSqliteUnavailableE
 const STATE_DB_RELATIVE = join('User', 'globalStorage', 'state.vscdb');
 const ACCESS_TOKEN_KEY = 'cursorAuth/accessToken';
 const SESSION_COOKIE = 'WorkosCursorSessionToken';
+const CSV_PATH = '/api/dashboard/export-usage-events-csv';
+const EVENTS_PATH = '/api/dashboard/get-filtered-usage-events';
+const PAGE_SIZE = 1000;
+// Cursor's dashboard pages the events endpoint; 200k events is far above any
+// real personal account. Hitting the cap means the fallback is incomplete, so
+// the run is skipped instead of pruning incremental state with a partial view.
+const MAX_PAGES = 200;
 
 function getDefaultStateDbPath() {
   if (process.platform === 'darwin') {
@@ -41,6 +48,48 @@ export function getCursorStateDbPath() {
   return null;
 }
 
+/**
+ * Cursor stores this value as TEXT on most builds, but some (notably newer
+ * Windows builds) write the ASCII token as a UTF-16LE BLOB. `node:sqlite`
+ * returns a Uint8Array then, while the sqlite3 CLI returns a JS string whose
+ * characters carry interleaved NULs. Both used to read as "no token", which
+ * made Cursor silently stop syncing after a fresh sign-in.
+ */
+export function decodeTokenValue(value) {
+  if (typeof value === 'string') {
+    if (value.includes('\u0000')) {
+      const bytes = Buffer.from(value, 'latin1');
+      if (bytes.length % 2 === 0) {
+        const decoded = bytes.toString('utf16le').replace(/\u0000/g, '').trim();
+        if (decoded) return decoded;
+      }
+      return value.replace(/\u0000/g, '').trim() || null;
+    }
+    return value.trim() || null;
+  }
+
+  if (value instanceof Uint8Array) {
+    const bytes = Buffer.from(value);
+    if (bytes.length === 0) return null;
+    // ASCII UTF-16LE has a zero high byte for every character. Check that
+    // before UTF-8: the byte stream is also valid UTF-8, just with NULs.
+    let utf16 = bytes.length % 2 === 0;
+    for (let i = 0; utf16 && i < bytes.length; i += 2) {
+      if (bytes[i + 1] !== 0) utf16 = false;
+    }
+    const decoded = utf16
+      ? bytes.toString('utf16le').replace(/\u0000/g, '')
+      : bytes.toString('utf8');
+    return decoded.trim() || null;
+  }
+
+  // Defensive: a wrapper that JSON-encodes SQLite BLOBs.
+  if (value && value.type === 'Buffer' && Array.isArray(value.data)) {
+    return decodeTokenValue(Uint8Array.from(value.data));
+  }
+  return null;
+}
+
 function readAccessToken(dbPath) {
   // Cursor app holds a write lock; queryDbJsonSnapshotOnLock copies the WAL set
   // to a temp dir and retries on "database is locked".
@@ -49,25 +98,35 @@ function readAccessToken(dbPath) {
     tempPrefix: 'vibe-usage-cursor-',
     opts: { maxBuffer: 4 * 1024 * 1024, timeout: 15000 },
   });
-  const value = rows[0]?.value;
-  if (typeof value !== 'string') return null;
-  const t = value.trim();
-  return t || null;
+  return decodeTokenValue(rows[0]?.value);
 }
 
-function decodeJwtSub(token) {
+function decodeJwtPayload(token) {
   const payload = token.split('.')[1];
   if (!payload) return null;
   try {
     const b64 = payload.replace(/-/g, '+').replace(/_/g, '/');
     const padded = b64.padEnd(Math.ceil(b64.length / 4) * 4, '=');
-    const json = JSON.parse(Buffer.from(padded, 'base64').toString('utf-8'));
-    return typeof json.sub === 'string' ? json.sub.trim() : null;
+    return JSON.parse(Buffer.from(padded, 'base64').toString('utf-8'));
   } catch {
     return null;
   }
 }
 
+function decodeJwtSub(token) {
+  const json = decodeJwtPayload(token);
+  return typeof json?.sub === 'string' ? json.sub.trim() : null;
+}
+
+/** Local-only account label for warnings/status. Never uploaded. */
+export function cursorAccountLabel(sub) {
+  if (!sub) return null;
+  const [provider, id] = sub.includes('|') ? [sub.split('|')[0], sub.split('|').pop()] : [null, sub];
+  const trimmed = id || '';
+  const masked = trimmed.length > 12 ? `${trimmed.slice(0, 4)}…${trimmed.slice(-4)}` : trimmed;
+  return provider ? `${provider}|${masked}` : masked;
+}
+
 // cursor.com's CSV export is computed over the whole account, so it gets
 // slower the more usage the account has: heavy users time out on every run,
 // not intermittently. 10s (v0.7.11) and then 30s (#72) were both still short
@@ -123,8 +182,24 @@ function usageNetworkError(error, signal) {
   return err;
 }
 
-async function fetchUsageCsv(token) {
-  const url = `${(process.env.CURSOR_WEB_BASE_URL?.trim() || 'https://cursor.com').replace(/\/+$/, '')}/api/dashboard/export-usage-events-csv?strategy=tokens`;
+function skipped(message) {
+  const err = new Error(message);
+  err.skip = true;
+  return err;
+}
+
+function baseHeaders(accept) {
+  return {
+    Accept: accept,
+    Origin: 'https://cursor.com',
+    Referer: 'https://cursor.com/dashboard?tab=usage',
+    // Node's default UA is a common target for intermittent WAF blocks on
+    // cursor.com; match what the dashboard sends.
+    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+  };
+}
+
+function credentialAttempts(token) {
   const sub = decodeJwtSub(token);
   // The dashboard API authenticates via the WorkosCursorSessionToken cookie in
   // `{sub}%3A%3A{jwt}` form (what the browser sends). Bearer and bare-token
@@ -135,48 +210,55 @@ async function fetchUsageCsv(token) {
     ...(userId ? [`${userId}%3A%3A${token}`] : []),
     token,
   ];
-
-  // Browser-mimicking headers, matching what the dashboard sends (and what
-  // cursor-stats / cursor-price-tracking send) — Node's default UA is a
-  // common target for intermittent WAF blocks on cursor.com.
-  const baseHeaders = {
-    Accept: 'text/csv,*/*;q=0.8',
-    Origin: 'https://cursor.com',
-    Referer: 'https://cursor.com/dashboard?tab=usage',
-    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
-  };
-  const attempts = cookieValues.map(cv => ({ Cookie: `${SESSION_COOKIE}=${cv}` }));
+  const attempts = cookieValues.map(value => ({ Cookie: `${SESSION_COOKIE}=${value}` }));
   attempts.push({ Authorization: `Bearer ${token}` });
+  return attempts;
+}
 
+function cursorWebBase() {
+  return (process.env.CURSOR_WEB_BASE_URL?.trim() || 'https://cursor.com').replace(/\/+$/, '');
+}
+
+function authRejected(status, statusText) {
+  const err = new Error(`auth rejected (${status} ${statusText})`);
+  err.authRejected = true;
+  return err;
+}
+
+async function fetchCsv(headers, signal) {
+  const url = `${cursorWebBase()}${CSV_PATH}?strategy=tokens`;
+  let resp;
+  try {
+    resp = await fetch(url, { headers: { ...baseHeaders('text/csv,*/*;q=0.8'), ...headers }, signal });
+    // The export may time out or disconnect after headers have arrived.
+    // Keep body consumption under the same deadline and soft-skip handling.
+    if (resp.ok) return await resp.text();
+  } catch (err) {
+    throw usageNetworkError(err, signal);
+  }
+  if (resp.status === 401 || resp.status === 403) throw authRejected(resp.status, resp.statusText);
+  // 429/5xx are transient server-side states — soft-skip like network errors
+  // instead of surfacing them as auth failures every daemon cycle.
+  throw skipped(`Cursor usage export skipped (HTTP ${resp.status} ${resp.statusText})`);
+}
+
+async function fetchUsageCsv(token) {
   const failures = [];
-  for (const headers of attempts) {
-    let resp;
+  for (const headers of credentialAttempts(token)) {
     const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
     try {
-      resp = await fetch(url, {
-        headers: { ...baseHeaders, ...headers },
-        signal,
-      });
-      // The export may time out or disconnect after headers have arrived.
-      // Keep body consumption under the same deadline and soft-skip handling.
-      if (resp.ok) return await resp.text();
-    } catch (e) {
-      // Changing credentials cannot repair a network failure.
-      throw usageNetworkError(e, signal);
-    }
-    failures.push(`${resp.status} ${resp.statusText}`);
-    // Only auth rejections are worth retrying with different credentials.
-    // 429/5xx are transient server-side states — soft-skip like network errors
-    // instead of surfacing them as auth failures every daemon cycle.
-    if (resp.status !== 401 && resp.status !== 403) {
-      const err = new Error(`Cursor usage export skipped (HTTP ${resp.status} ${resp.statusText})`);
-      err.skip = true;
+      return await fetchCsv(headers, signal);
+    } catch (err) {
+      if (err?.authRejected) {
+        failures.push(String(err.message).replace(/^auth rejected /, ''));
+        continue;
+      }
       throw err;
     }
   }
-  // Every auth combo rejected — the stored token no longer works. Surface an
-  // actionable message: re-signing in inside Cursor rewrites the token.
-  throw new Error(`Cursor session rejected (${failures.join('; ')}). Open Cursor and sign in again (Cursor Settings → Account), then re-run sync.`);
+  throw new Error(
+    `Cursor session rejected (${failures.join('; ')}). Open Cursor and sign in again (Cursor Settings → Account), then re-run sync.`,
+  );
 }
 
 function parseCsv(text) {
@@ -219,41 +301,15 @@ function parseInt0(value) {
   return Number.isFinite(n) && n > 0 ? Math.round(n) : 0;
 }
 
-export async function parse() {
-  const dbPath = getCursorStateDbPath();
-  if (!dbPath) return { buckets: [], sessions: [] };
-
-  let token;
-  try {
-    token = readAccessToken(dbPath);
-  } catch (err) {
-    if (isSqliteUnavailableError(err)) {
-      throw sqliteUnavailableError('Cursor');
-    }
-    throw err;
-  }
-  if (!token) return { buckets: [], sessions: [] };
-
-  let csv;
-  try {
-    csv = await fetchUsageCsv(token);
-  } catch (err) {
-    // Network/timeout → skip with diagnostics (quiet sync suppresses these).
-    // Auth failure → bubble up so user sees they need to re-login in Cursor.
-    // Tell sync.js this was not a successful empty snapshot so it preserves
-    // Cursor's incremental state instead of pruning it as dead history.
-    if (err && err.skip) {
-      return {
-        buckets: [],
-        sessions: [],
-        skipped: true,
-        warnings: [`cursor: ${err.message}`],
-      };
-    }
-    throw err;
-  }
-  const rows = parseCsv(csv);
-  if (rows.length < 2) return { buckets: [], sessions: [] };
+/**
+ * Parse the legacy CSV export. Returns `unusable` (with a reason) when Cursor
+ * changed the header, returned no rows, or returned rows whose token columns
+ * are all empty — the caller then tries the events API instead of uploading an
+ * empty snapshot that would prune history.
+ */
+function entriesFromCsv(csv) {
+  const rows = parseCsv(String(csv).replace(/^\uFEFF/, ''));
+  if (rows.length < 2) return { entries: [], events: 0, latestEventAt: null, unusable: '返回了空表' };
 
   const header = rows[0].map(h => h.trim());
   const idx = (name) => header.indexOf(name);
@@ -267,30 +323,31 @@ export async function parse() {
   // A renamed column used to degrade silently: every row then parsed as zero
   // tokens, the run uploaded an empty snapshot, and sync.js pruned Cursor's
   // incremental state as if the account had gone quiet — the dashboard just
-  // stopped counting Cursor. Treat a header we do not recognise as a skipped
-  // run instead: the state survives and the user gets a warning.
+  // stopped counting Cursor. Treat a header we do not recognise as unusable
+  // and try the events API before giving up.
   const hasTokenColumn =
     inputCacheWriteIdx >= 0 || inputNoCacheIdx >= 0 || cacheReadIdx >= 0 || outputIdx >= 0;
   if (dateIdx < 0 || modelIdx < 0 || !hasTokenColumn) {
     return {
-      buckets: [],
-      sessions: [],
-      skipped: true,
-      warnings: [
-        'cursor: 导出表头与预期不符（需要 Date、Model 及至少一个 token 列），本次已跳过以保护增量状态；' +
-        'Cursor 可能更改了导出接口，请反馈。' +
-        `当前表头: ${header.slice(0, 8).join(', ')}`,
-      ],
+      entries: [],
+      events: 0,
+      latestEventAt: null,
+      unusable: `导出表头与预期不符（当前表头: ${header.slice(0, 8).join(', ')}）`,
     };
   }
 
   const entries = [];
+  let latestEventAt = null;
+  let latestTokenAt = null;
+  let eventCount = 0;
   for (let r = 1; r < rows.length; r++) {
     const row = rows[r];
     if (row.length === 1 && row[0].trim() === '') continue;
     const timestamp = parseDate(row[dateIdx]);
     const model = row[modelIdx]?.trim();
     if (!timestamp || !model) continue;
+    eventCount++;
+    if (!latestEventAt || timestamp > latestEventAt) latestEventAt = timestamp;
 
     const inputCacheWrite = inputCacheWriteIdx >= 0 ? parseInt0(row[inputCacheWriteIdx]) : 0;
     const inputNoCache = inputNoCacheIdx >= 0 ? parseInt0(row[inputNoCacheIdx]) : 0;
@@ -298,6 +355,7 @@ export async function parse() {
     const output = outputIdx >= 0 ? parseInt0(row[outputIdx]) : 0;
 
     if (inputCacheWrite + inputNoCache + cacheRead + output === 0) continue;
+    if (!latestTokenAt || timestamp > latestTokenAt) latestTokenAt = timestamp;
 
     entries.push({
       source: 'cursor',
@@ -315,5 +373,385 @@ export async function parse() {
     });
   }
 
-  return { buckets: aggregateToBuckets(entries), sessions: [] };
+  if (entries.length === 0) {
+    return {
+      entries,
+      events: eventCount,
+      latestEventAt,
+      latestTokenAt,
+      unusable: eventCount > 0 ? `返回了 ${eventCount} 行，但没有任何 token 计数` : '没有返回任何用量行',
+    };
+  }
+  return { entries, events: eventCount, latestEventAt, latestTokenAt };
+}
+
+function tokenCount(value) {
+  if (value == null) return 0;
+  const n = Number(String(value).replace(/,/g, '').trim());
+  return Number.isFinite(n) && n > 0 ? Math.round(n) : 0;
+}
+
+function eventTimestamp(value) {
+  if (value == null) return null;
+  const raw = typeof value === 'string' ? value.trim() : value;
+  if (raw === '') return null;
+  const numeric = Number(raw);
+  if (Number.isFinite(numeric) && numeric > 0) {
+    // The dashboard serializes Unix milliseconds as a string.
+    const date = new Date(numeric);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  const date = new Date(raw);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function eventDedupKey(event) {
+  if (typeof event?.usageEventId === 'string' && event.usageEventId) return event.usageEventId;
+  return JSON.stringify([event?.timestamp, event?.model, event?.tokenUsage]);
+}
+
+async function fetchAllEventPages(headers, signal, { startDate = '0' } = {}) {
+  const url = `${cursorWebBase()}${EVENTS_PATH}`;
+  const endDate = String(Date.now());
+  const events = [];
+  const seen = new Set();
+  let total = null;
+  let rawCount = 0;
+
+  for (let page = 1; page <= MAX_PAGES; page++) {
+    let resp;
+    try {
+      resp = await fetch(url, {
+        method: 'POST',
+        headers: { ...baseHeaders('application/json'), 'Content-Type': 'application/json', ...headers },
+        body: JSON.stringify({ page, pageSize: PAGE_SIZE, startDate, endDate }),
+        signal,
+      });
+    } catch (err) {
+      throw usageNetworkError(err, signal);
+    }
+
+    if (resp.status === 401 || resp.status === 403) throw authRejected(resp.status, resp.statusText);
+    if (!resp.ok) {
+      throw skipped(`Cursor usage request skipped (HTTP ${resp.status} ${resp.statusText})`);
+    }
+
+    let json;
+    try {
+      json = await resp.json();
+    } catch (err) {
+      if (err instanceof SyntaxError) {
+        throw skipped('Cursor usage request skipped (dashboard returned invalid JSON; the API may have changed).');
+      }
+      throw usageNetworkError(err, signal);
+    }
+
+    // An empty query window returns `{}` with no fields at all.
+    const pageEvents = json && typeof json === 'object' ? json.usageEventsDisplay : undefined;
+    if (!Array.isArray(pageEvents)) {
+      if (json && typeof json === 'object' && Object.keys(json).length === 0) {
+        total = 0;
+        break;
+      }
+      const reported = Number(json?.totalUsageEventsCount);
+      if (Number.isFinite(reported) && reported === 0) {
+        total = 0;
+        break;
+      }
+      throw skipped(
+        'Cursor usage request skipped (dashboard response has no usageEventsDisplay; the API may have changed). '
+        + `Keys: ${json && typeof json === 'object' ? Object.keys(json).slice(0, 8).join(', ') : typeof json}`,
+      );
+    }
+
+    const reported = Number(json.totalUsageEventsCount);
+    if (Number.isFinite(reported) && reported >= 0) total = reported;
+
+    rawCount += pageEvents.length;
+    for (const event of pageEvents) {
+      const key = eventDedupKey(event);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      events.push(event);
+    }
+
+    if (pageEvents.length < PAGE_SIZE) break;
+    if (total != null && rawCount >= total) break;
+    if (page === MAX_PAGES) {
+      throw skipped(`Cursor usage request skipped (more than ${MAX_PAGES * PAGE_SIZE} events; history left unchanged).`);
+    }
+  }
+
+  if (total != null && rawCount < total) {
+    throw skipped(
+      `Cursor usage request skipped (received ${rawCount} of ${total} events; history left unchanged).`,
+    );
+  }
+  return { events, total: total ?? events.length };
+}
+
+async function fetchUsageEvents(token, options = {}) {
+  const failures = [];
+  for (const headers of credentialAttempts(token)) {
+    const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+    try {
+      return await fetchAllEventPages(headers, signal, options);
+    } catch (err) {
+      if (err?.authRejected) {
+        failures.push(String(err.message).replace(/^auth rejected /, ''));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(
+    `Cursor session rejected (${failures.join('; ')}). Open Cursor and sign in again (Cursor Settings → Account), then re-run sync.`,
+  );
+}
+
+/**
+ * Fallback for accounts whose CSV export is empty or uses an unknown format
+ * (observed on some X Subscription / unified accounts, 2026-10). The events
+ * endpoint is the dashboard's own paginated source. Its `model` field is less
+ * accurate for older rows (`default` instead of `auto`/Composer), so it is only
+ * used when the CSV cannot provide usable data.
+ */
+function entriesFromEvents(events) {
+  const entries = [];
+  let latestEventAt = null;
+  let latestTokenAt = null;
+  let tokenEventCount = 0;
+
+  for (const event of events) {
+    const timestamp = eventTimestamp(event?.timestamp);
+    if (timestamp && (!latestEventAt || timestamp > latestEventAt)) latestEventAt = timestamp;
+
+    const model = typeof event?.model === 'string' ? event.model.trim() : '';
+    if (!timestamp || !model) continue;
+
+    const usage = event?.tokenUsage;
+    if (!usage || typeof usage !== 'object') continue;
+
+    const inputTokens = tokenCount(usage.inputTokens) + tokenCount(usage.cacheWriteTokens);
+    const outputTokens = tokenCount(usage.outputTokens);
+    const cachedInputTokens = tokenCount(usage.cacheReadTokens);
+    if (inputTokens + outputTokens + cachedInputTokens === 0) continue;
+    if (!latestTokenAt || timestamp > latestTokenAt) latestTokenAt = timestamp;
+
+    tokenEventCount++;
+    entries.push({
+      source: 'cursor',
+      model,
+      project: 'unknown',
+      hostname: 'cursor-cloud',
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens: 0,
+    });
+  }
+
+  return { entries, latestEventAt, latestTokenAt, tokenEventCount };
+}
+
+function laterDate(a, b) {
+  if (!a) return b || null;
+  if (!b) return a;
+  return a > b ? a : b;
+}
+
+function resultInfo({ account, latestEventAt, latestTokenAt, events, tokenEvents, fallbackLatestAt }) {
+  return {
+    ...(account ? { account } : {}),
+    ...(latestEventAt ? { latestEventAt: new Date(latestEventAt).toISOString() } : {}),
+    ...(latestTokenAt ? { latestTokenAt: new Date(latestTokenAt).toISOString() } : {}),
+    events,
+    tokenEvents,
+    ...(fallbackLatestAt ? { fallbackLatestAt } : {}),
+  };
+}
+
+export async function parse({ previousInfo } = {}) {
+  const dbPath = getCursorStateDbPath();
+  let token = null;
+  let sqliteUnavailable = false;
+
+  if (dbPath) {
+    try {
+      token = readAccessToken(dbPath);
+    } catch (err) {
+      if (!isSqliteUnavailableError(err)) throw err;
+      sqliteUnavailable = true;
+    }
+  }
+  if (!token) {
+    if (sqliteUnavailable) throw sqliteUnavailableError('Cursor');
+    return { buckets: [], sessions: [] };
+  }
+
+  const sub = decodeJwtSub(token);
+  const account = cursorAccountLabel(sub);
+
+  let csvResult;
+  try {
+    csvResult = entriesFromCsv(await fetchUsageCsv(token));
+  } catch (err) {
+    // Network/timeout → skip with diagnostics (quiet sync suppresses these).
+    // Auth failure → bubble up so user sees they need to re-login in Cursor.
+    // Tell sync.js this was not a successful empty snapshot so it preserves
+    // Cursor's incremental state instead of pruning it as dead history.
+    if (err && err.skip) {
+      return {
+        buckets: [],
+        sessions: [],
+        skipped: true,
+        warnings: [`cursor: ${err.message}`],
+      };
+    }
+    throw err;
+  }
+
+  if (!csvResult.unusable) {
+    let entries = csvResult.entries;
+    let latest = csvResult.latestEventAt;
+    let latestToken = csvResult.latestTokenAt ?? csvResult.latestEventAt;
+    let eventCount = csvResult.events;
+    let fallbackLatestAt = previousInfo?.fallbackLatestAt;
+    const warnings = [];
+
+    // The CSV can be valid but stop growing (observed after account
+    // switches/unification). Probe the dashboard events endpoint for the gap,
+    // but only take events after the CSV's newest *token* row: historical rows
+    // there are labelled `default`, and re-adding them would double-count
+    // history. Bounded to a recent gap so an idle account does not probe
+    // forever.
+    const boundaryMs = latestToken ? latestToken.getTime() : NaN;
+    const now = Date.now();
+    if (Number.isFinite(boundaryMs) && now - boundaryMs > 24 * 60 * 60 * 1000
+      && now - boundaryMs <= 7 * 24 * 60 * 60 * 1000) {
+      try {
+        const probe = await fetchUsageEvents(token, {
+          startDate: String(Math.max(0, boundaryMs - 60 * 60 * 1000)),
+        });
+        const newer = probe.events.filter((event) => {
+          const timestamp = eventTimestamp(event?.timestamp);
+          return timestamp && timestamp.getTime() > boundaryMs;
+        });
+        const extra = entriesFromEvents(newer);
+        if (extra.entries.length > 0) {
+          entries = entries.concat(extra.entries);
+          if (extra.latestEventAt && (!latest || extra.latestEventAt > latest)) {
+            latest = extra.latestEventAt;
+          }
+          if (extra.latestTokenAt && (!latestToken || extra.latestTokenAt > latestToken)) {
+            latestToken = extra.latestTokenAt;
+          }
+          eventCount += newer.length;
+          const probedThrough = Date.parse(fallbackLatestAt);
+          if (!Number.isFinite(probedThrough) || probedThrough < latestToken.getTime()) {
+            warnings.push(
+              `cursor: CSV 最新 token 事件停在 ${new Date(boundaryMs).toISOString()}，`
+              + `已从仪表盘事件接口补回 ${extra.tokenEventCount} 个更新的 token 事件；`
+              + '这些事件的模型名可能不完整（不影响 token 总量）。',
+            );
+          }
+          fallbackLatestAt = latestToken.toISOString();
+        }
+      } catch {
+        // The CSV data is still valid; a failed freshness probe must not
+        // discard it or fail the whole sync.
+      }
+    }
+
+    return {
+      buckets: aggregateToBuckets(entries),
+      sessions: [],
+      warnings,
+      info: resultInfo({
+        account,
+        latestEventAt: latest,
+        latestTokenAt: latestToken,
+        events: eventCount,
+        tokenEvents: entries.length,
+        fallbackLatestAt,
+      }),
+    };
+  }
+
+  // The CSV parsed but contained no usable usage events. Try the dashboard's
+  // events API before treating the account as empty. Only look at events newer
+  // than the previous sync's newest event: the events API labels many older
+  // rows as model `default`, and re-adding known history under that name would
+  // double-count it as a second set of buckets. On a first run (no previous
+  // info) the fallback is bounded to the last seven days for the same reason.
+  const previousLatest = Date.parse(previousInfo?.latestTokenAt ?? previousInfo?.latestEventAt);
+  const hasPreviousLatest = Number.isFinite(previousLatest);
+  const fallbackStart = hasPreviousLatest
+    ? Math.max(0, previousLatest - 60 * 60 * 1000)
+    : Date.now() - 7 * 24 * 60 * 60 * 1000;
+  let events;
+  try {
+    events = await fetchUsageEvents(token, { startDate: String(fallbackStart) });
+  } catch (err) {
+    if (err && err.skip) {
+      return {
+        buckets: [],
+        sessions: [],
+        skipped: true,
+        warnings: [
+          `cursor: CSV 导出不可用（${csvResult.unusable}）；事件接口也失败：${err.message}`,
+        ],
+        info: resultInfo({
+          account,
+          latestEventAt: csvResult.latestEventAt,
+          latestTokenAt: csvResult.latestTokenAt,
+          events: csvResult.events,
+          tokenEvents: csvResult.entries.length,
+        }),
+      };
+    }
+    throw err;
+  }
+
+  const candidateEvents = hasPreviousLatest
+    ? events.events.filter((event) => {
+        const timestamp = eventTimestamp(event?.timestamp);
+        return timestamp && timestamp.getTime() > previousLatest;
+      })
+    : events.events;
+  const fallback = entriesFromEvents(candidateEvents);
+  const windowLabel = hasPreviousLatest
+    ? `${new Date(previousLatest).toISOString()} 之后`
+    : '最近 7 天';
+  const info = resultInfo({
+    account,
+    latestEventAt: laterDate(fallback.latestEventAt, csvResult.latestEventAt),
+    latestTokenAt: laterDate(fallback.latestTokenAt, csvResult.latestTokenAt),
+    events: candidateEvents.length,
+    tokenEvents: fallback.tokenEventCount,
+  });
+
+  if (fallback.entries.length === 0) {
+    return {
+      buckets: [],
+      sessions: [],
+      skipped: true,
+      warnings: [
+        `cursor: CSV 导出不可用（${csvResult.unusable}），事件接口在${windowLabel}也没有读到 token 用量。`
+        + '如果刚切换到 X 订阅，Cursor 的用量可能并入 grok.com/dashboard；本次已跳过以保留历史。',
+      ],
+      info,
+    };
+  }
+
+  return {
+    buckets: aggregateToBuckets(fallback.entries),
+    sessions: [],
+    warnings: [
+      `cursor: CSV 导出不可用（${csvResult.unusable}），已从仪表盘事件接口补回${windowLabel}的 `
+      + `${fallback.tokenEventCount} 个 token 事件；这些事件的模型名可能显示为 default（不影响 token 总量）。`,
+    ],
+    info,
+  };
 }

package/src/state.js

@@ -52,24 +52,37 @@ function sameIdentity(a, b) {
 // `identity` is optional: callers that only read the recorded counts (e.g.
 // `status`) pass nothing and keep the pre-0.11.1 behaviour of taking the file
 // at face value.
+function parserMetaFrom(parsed) {
+  const meta = parsed?.parserMeta;
+  return meta && typeof meta === 'object' && !Array.isArray(meta) ? meta : {};
+}
+
 export function loadState(identity) {
   if (!existsSync(STATE_FILE)) return { buckets: {}, sessions: {} };
   try {
     const parsed = JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
     const buckets = parsed.buckets ?? {};
     const sessions = parsed.sessions ?? {};
+    // Local parser diagnostics (currently Cursor's account/newest event).
+    // Purely additive; older CLIs ignore it and it never enters an upload.
+    const parserMeta = parserMetaFrom(parsed);
+    const withMeta = (value) => (Object.keys(parserMeta).length > 0
+      ? { ...value, parserMeta }
+      : value);
     if (!isIdentity(identity) || !isIdentity(parsed.identity)) {
       // No identity recorded — written by a CLI older than 0.11.1. Adopt the
       // entries as-is rather than forcing a re-upload: on upgrade day that
       // would make every installed client re-send its whole history at once.
       // The next saveState() stamps the current identity, so any later re-bind
       // is caught.
-      return { buckets, sessions };
+      return withMeta({ buckets, sessions });
     }
-    if (sameIdentity(parsed.identity, identity)) return { buckets, sessions };
+    if (sameIdentity(parsed.identity, identity)) return withMeta({ buckets, sessions });
     // Bound to a different account or server: nothing recorded here was ever
     // uploaded to the current target, so start empty and re-send local history.
     // `identityChanged` is a runtime signal for the caller, never persisted.
+    // Parser diagnostics describe the old target's local source, so they are
+    // dropped with the old hashes.
     return { buckets: {}, sessions: {}, identityChanged: true };
   } catch {
     // Corrupt/unreadable state must not lose data — treat as empty, which
@@ -91,6 +104,10 @@ export function saveState(state, identity) {
     buckets: state.buckets ?? {},
     sessions: state.sessions ?? {},
   };
+  if (state.parserMeta && typeof state.parserMeta === 'object'
+    && Object.keys(state.parserMeta).length > 0) {
+    payload.parserMeta = state.parserMeta;
+  }
   if (isIdentity(identity)) {
     payload.identity = {
       apiUrl: identity.apiUrl,

package/src/sync.js

@@ -11,7 +11,7 @@ import { aggregateToBuckets } from './parsers/aggregate.js';
 import { normalizeParserResult } from './parsers/contract.js';
 import { extraRootList } from './extra-roots.js';
 import { planKikiMigration } from './kiki-migration.js';
-import { success, failure, warn, arrow, link, dim } from './output.js';
+import { success, failure, warn, arrow, link, dim, liveStatus } from './output.js';
 
 const BATCH_SIZE = 100;
 const SESSION_BATCH_SIZE = 500;
@@ -44,6 +44,11 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 
+/** Elapsed-time suffix for the live status line (`formatDuration` rounds 0 to `0s`). */
+function phaseElapsed(elapsedMs) {
+  return ` · 已用时 ${formatDuration(elapsedMs / 1000)}`;
+}
+
 export function resolveUploadProjectSetting(settings) {
   if (typeof settings?.uploadProject !== 'boolean') {
     const error = new Error('SETTINGS_UNAVAILABLE');
@@ -74,6 +79,67 @@ export function reaggregateHiddenProjectBuckets(buckets) {
   })));
 }
 
+/**
+ * Compare local parser diagnostics (Cursor's signed-in account and newest
+ * event) with the previous run and warn only on a meaningful change. The
+ * values live in state.json under `parserMeta`; they are local diagnostics,
+ * never uploaded, and older CLIs ignore them.
+ *
+ * This is how an account switch stops being silent: the old token keeps
+ * returning the old account's history, so the dashboard simply stops growing
+ * while every sync still "succeeds". `status` prints the recorded account and
+ * newest event for the same reason.
+ */
+export function applyParserInfos(state, parserInfos) {
+  if (!Array.isArray(parserInfos) || parserInfos.length === 0) return false;
+  if (!state.parserMeta || typeof state.parserMeta !== 'object') state.parserMeta = {};
+  let changed = false;
+
+  for (const { source, info } of parserInfos) {
+    if (!info || typeof info !== 'object' || Array.isArray(info)) continue;
+    const previous = state.parserMeta[source];
+    if (source === 'cursor') {
+      const warnings = [];
+      if (previous?.account && info.account && previous.account !== info.account) {
+        warnings.push(
+          `cursor: Cursor 登录账号已从 ${previous.account} 更换为 ${info.account}；`
+          + '如果这不是你刚切换的账号，请在 Cursor 设置中重新登录。',
+        );
+      }
+      if (previous?.latestEventAt && info.latestEventAt) {
+        const before = Date.parse(previous.latestEventAt);
+        const after = Date.parse(info.latestEventAt);
+        if (Number.isFinite(before) && Number.isFinite(after) && after < before) {
+          warnings.push(
+            `cursor: Cursor 最新事件从 ${previous.latestEventAt} 回退到 ${info.latestEventAt}；`
+            + '这通常意味着当前登录的是另一个（更旧的）Cursor 账号。',
+          );
+        }
+      }
+      if (previous?.tokenEvents > 0 && info.tokenEvents === 0) {
+        warnings.push(
+          `cursor: Cursor 本次没有读到可上传的 token 用量（账号 ${info.account || '未知'}，`
+          + `事件 ${info.events ?? 0}）。如果最近用过 Cursor，请运行 status 确认登录账号；`
+          + 'X 订阅的用量也可能并入 grok.com/dashboard。',
+        );
+      } else if (previous?.events > 0 && info.events === 0) {
+        warnings.push(
+          `cursor: Cursor 本次没有返回任何用量事件（账号 ${info.account || '未知'}）；`
+          + '如果最近用过 Cursor，请确认 Cursor 仍登录该账号。',
+        );
+      }
+      for (const message of warnings) {
+        process.stderr.write(`${dim(`  ${message}`)}\n`);
+      }
+    }
+    if (JSON.stringify(previous ?? null) !== JSON.stringify(info)) {
+      state.parserMeta[source] = info;
+      changed = true;
+    }
+  }
+  return changed;
+}
+
 // Parser execution is I/O bound (log reads, occasional network calls). Run a
 // bounded number at once to cut wall-clock sync time without the memory spike
 // of loading every tool's logs simultaneously.
@@ -127,6 +193,13 @@ export async function runSync({
   // Built from the same `apiUrl` the ingest calls below use, so the recorded
   // target and the actual target can never drift apart.
   const identity = stateIdentity({ apiUrl, apiKey: config.apiKey });
+  // Both the settings round-trip and the log scan below can run for minutes on
+  // a cold or proxied machine (a timing-out endpoint retrying, a cold Codex
+  // index, a 120s Cursor export). A live status line keeps that work
+  // distinguishable from a hang; it never reaches a pipe, so the desktop apps
+  // keep parsing bare result text from stdout.
+  const status = liveStatus({ enabled: !quiet });
+  status.start(elapsedMs => `正在读取上传设置${phaseElapsed(elapsedMs)}`);
   let uploadProject;
   try {
     const settings = await fetchSettings(apiUrl, config.apiKey);
@@ -143,6 +216,7 @@ export async function runSync({
       saveConfig(config);
     }
   } catch (err) {
+    status.stop();
     if (err.message === 'UNAUTHORIZED') {
       console.error(failure('API Key 无效，请运行 `npx @vibe-cafe/vibe-usage init` 重新配置。'));
       if (throws) throw err;
@@ -161,10 +235,16 @@ export async function runSync({
     }
   }
 
+  // Loaded before parsing so a stateful parser can use the previous run's
+  // diagnostics (Cursor uses the last event time to gate its events fallback
+  // and avoid re-uploading already-known history under a different model id).
+  const state = loadState(identity);
+
   let allBuckets = [];
   const allSessions = [];
   const parserResults = [];
   const parserProgress = [];
+  const parserInfos = [];
   // Sources whose parser ran to completion this sync. pruneState() below is
   // scoped to these so a transient parser failure doesn't evict that tool's
   // state and force a full re-upload next run.
@@ -173,13 +253,17 @@ export async function runSync({
   // Run parsers concurrently (bounded) so one slow parser (Cursor's network
   // fetch, a cold Codex index) can't stall the rest. Results are collected in
   // registry order so output and merged arrays stay deterministic.
+  const parserRegistry = Object.entries(parsers);
+  let parsedSources = 0;
+  status.start(elapsedMs => `正在扫描本地日志 ${parsedSources}/${parserRegistry.length}${phaseElapsed(elapsedMs)}`);
   const parserOutcomes = await mapWithConcurrency(
-    Object.entries(parsers),
+    parserRegistry,
     PARSER_CONCURRENCY,
     async ([source, parse]) => {
       try {
         const result = await parse({
           extraRoots: extraRootList(config.extraRoots?.[source]),
+          previousInfo: state.parserMeta?.[source],
           ...(source === 'codex' ? {
             codexExtraHome: resolveCodexExtraHome(config.codexExtraHome, codexExtraHome),
           } : {}),
@@ -187,9 +271,12 @@ export async function runSync({
         return { source, result };
       } catch (err) {
         return { source, error: err };
+      } finally {
+        parsedSources++;
       }
     },
   );
+  status.stop();
 
   for (const { source, result, error } of parserOutcomes) {
     if (error) {
@@ -204,10 +291,11 @@ export async function runSync({
       process.stderr.write(`${dim(`  ${source}: ${err.message}`)}\n`);
       continue;
     }
-    const { buckets, sessions, skipped, warnings, indexing } = normalized;
+    const { buckets, sessions, skipped, warnings, indexing, info } = normalized;
     if (indexing) {
       parserProgress.push({ source, ...indexing });
     }
+    if (info) parserInfos.push({ source, info });
     // Parser warnings always reach stderr, including quiet (daemon) runs: the
     // daemon log is the only trail a background failure leaves. Cursor's fetch
     // soft-skip used to be filtered out here to keep that log tidy, which made
@@ -231,14 +319,14 @@ export async function runSync({
     // Successful parsers emitted no live items. Prune their old keys even on
     // this fast path; otherwise deleting the final local log would leave dead
     // state entries forever. Failed-parser sources remain protected.
-    const state = loadState(identity);
     if (state.identityChanged && !quiet) {
       console.log(dim('检测到上传账号已更换，本次全量重传本地历史'));
     }
     const before = Object.keys(state.buckets).length + Object.keys(state.sessions).length;
     pruneState(state, new Set(), new Set(), okSources);
     const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
-    if (pruned > 0) saveState(state, identity);
+    const metaChanged = applyParserInfos(state, parserInfos);
+    if (pruned > 0 || metaChanged) saveState(state, identity);
     if (!quiet && parserProgress.length > 0) {
       for (const p of parserProgress) {
         console.log(dim(`  ${p.source}: 正在建立本地索引 ${p.completed}/${p.total}（下次同步继续）`));
@@ -294,10 +382,10 @@ export async function runSync({
   // an active one sends just the current 30-min bucket.
   // Missing/corrupt state.json => empty maps => one-time full upload, then
   // incremental forever after.
-  const state = loadState(identity);
   if (state.identityChanged && !quiet) {
     console.log(dim('检测到上传账号已更换，本次全量重传本地历史'));
   }
+  const metaChanged = applyParserInfos(state, parserInfos);
   let migration;
   try {
     migration = planKikiMigration(allBuckets, allSessions, state, config.kikiStartAt);
@@ -380,7 +468,7 @@ export async function runSync({
   const before = Object.keys(state.buckets).length + Object.keys(state.sessions).length;
   pruneState(state, liveBucketKeys, liveSessionKeys, okSources);
   const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
-  if (pruned > 0) saveState(state, identity);
+  if (pruned > 0 || metaChanged) saveState(state, identity);
 
   if (changedBuckets.length === 0 && changedSessions.length === 0) {
     if (!quiet) console.log(dim('无新增数据。'));