@vibe-cafe/vibe-usage 0.9.14 → 0.9.16

package/README.md

@@ -40,7 +40,7 @@ npx @vibe-cafe/vibe-usage daemon status     # Show background service status
 npx @vibe-cafe/vibe-usage daemon stop       # Stop background service
 npx @vibe-cafe/vibe-usage daemon restart    # Restart background service
 npx @vibe-cafe/vibe-usage reset        # Delete all data and re-upload from local logs
-npx @vibe-cafe/vibe-usage reset --local  # Delete this host's data only and re-upload
+npx @vibe-cafe/vibe-usage reset --local  # Delete this host's data only and re-upload (`--host` remains a legacy alias)
 npx @vibe-cafe/vibe-usage skill         # Install skill for AI coding assistants
 npx @vibe-cafe/vibe-usage skill --remove  # Remove installed skills
 npx @vibe-cafe/vibe-usage status       # Show config & detected tools
@@ -60,7 +60,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments) |
 | pi | `~/.pi/agent/sessions/` |
 | Qwen Code | `~/.qwen/tmp/` |
-| Kimi Code | `~/.kimi/sessions/<md5(workdir)>/<session-id>/wire.jsonl` (wire protocol 1.9, model from `~/.kimi/config.toml`, project from `~/.kimi/kimi.json`) |
+| Kimi Code | Current `~/.kimi-code/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), with project names from `session_index.jsonl`; legacy `~/.kimi/sessions/` remains supported |
 | Amp | `~/.local/share/amp/threads/` |
 | Droid | `~/.factory/sessions/` |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
@@ -77,7 +77,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 - Aggregates token usage into 30-minute buckets
 - Extracts session metadata from all parsers: active time (AI generation time, excluding queue/TTFT wait), total duration, message counts
 - Uploads buckets + sessions to your vibecafe.ai dashboard (always gzip-compressed, ~94% smaller)
-- Incremental: parsers still compute full totals from local logs each sync (idempotent), but only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Sync state is kept in `~/.vibe-usage/state.json`; deleting it just triggers a one-time full re-upload
+- Incremental: parsers still compute full totals from local logs each sync (idempotent), but only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Sync state is kept in `~/.vibe-usage/state.json`; failed 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
 - SQLite-backed tools (Cursor, OpenCode, Kiro, Hermes) 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 it falls back to the system `sqlite3` CLI
 - For continuous syncing, use `npx @vibe-cafe/vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 
@@ -125,6 +125,8 @@ npx skills add vibe-cafe/vibe-usage
 
 ## Development
 
+Run the Node test suite locally with `npm test`. CI covers Node 20 and 22 on Ubuntu and macOS.
+
 Test against a local vibe-cafe dev server without publishing:
 
 ```bash

package/package.json

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

package/src/config.js

@@ -1,8 +1,9 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, chmodSync, mkdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
-const CONFIG_DIR = join(homedir(), '.vibe-usage');
+// VIBE_USAGE_CONFIG_DIR overrides the dir (test hook).
+const CONFIG_DIR = process.env.VIBE_USAGE_CONFIG_DIR?.trim() || join(homedir(), '.vibe-usage');
 const isDev = process.env.VIBE_USAGE_DEV === '1';
 const CONFIG_FILE = join(CONFIG_DIR, isDev ? 'config.dev.json' : 'config.json');
 
@@ -21,5 +22,15 @@ export function loadConfig() {
 
 export function saveConfig(config) {
   mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  // The file holds the vbu_ API key — never leave it group/world-readable.
+  // mode only applies at file creation, so chmod explicitly for pre-existing
+  // files written before this hardening.
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', { encoding: 'utf-8', mode: 0o600 });
+  try {
+    chmodSync(CONFIG_FILE, 0o600);
+  } catch (err) {
+    // Windows permission models vary; on POSIX, do not silently leave an API
+    // key file broader than owner-only if hardening a pre-existing file fails.
+    if (process.platform !== 'win32') throw err;
+  }
 }

package/src/daemon-service.js

@@ -236,7 +236,16 @@ function stop() {
   }
 
   if (plat === 'launchd') {
-    const result = run('launchctl', ['stop', LAUNCHD_LABEL]);
+    // The plist sets KeepAlive=true, so `launchctl stop` is useless here —
+    // launchd immediately relaunches the job and the daemon keeps running.
+    // unload removes the job from launchd entirely; the plist file stays on
+    // disk, so `daemon restart` (load) and status detection keep working.
+    const paths = getServicePaths(plat);
+    if (!existsSync(paths.file)) {
+      console.log(dim('未安装 daemon 服务。'));
+      return;
+    }
+    const result = run('launchctl', ['unload', paths.file]);
     console.log(result.ok ? success('服务已停止。') : failure(`停止失败: ${result.output}`));
   }
 }
@@ -254,8 +263,11 @@ function restart() {
   }
 
   if (plat === 'launchd') {
-    run('launchctl', ['stop', LAUNCHD_LABEL]);
-    const result = run('launchctl', ['start', LAUNCHD_LABEL]);
+    // unload + load (not stop + start): stop can't win against KeepAlive, and
+    // load re-runs the job immediately thanks to RunAtLoad=true.
+    const paths = getServicePaths(plat);
+    run('launchctl', ['unload', paths.file]);
+    const result = run('launchctl', ['load', paths.file]);
     console.log(result.ok ? success('服务已重启。') : failure(`重启失败: ${result.output}`));
   }
 }

package/src/index.js

@@ -146,14 +146,17 @@ export async function run(rawArgs) {
     case 'daemon':
     case '--daemon': {
       const sub = args[1];
-      if (sub && ['install', 'uninstall', 'status', 'stop', 'restart'].includes(sub)) {
-        printSmallHeader();
-        const { manageDaemon } = await import('./daemon-service.js');
-        await manageDaemon(sub);
-      } else {
+      if (sub === undefined) {
         // Foreground daemon loop — no header, just start syncing
         const { runDaemon } = await import('./daemon.js');
         await runDaemon();
+      } else {
+        // manageDaemon validates the subcommand and exits 1 on unknown ones —
+        // a typo (e.g. `daemon stauts`) must never fall through to the
+        // infinite foreground loop.
+        printSmallHeader();
+        const { manageDaemon } = await import('./daemon-service.js');
+        await manageDaemon(sub);
       }
       break;
     }
@@ -191,7 +194,7 @@ export async function run(rawArgs) {
     npx @vibe-cafe/vibe-usage daemon stop       Stop background service
     npx @vibe-cafe/vibe-usage daemon restart    Restart background service
     npx @vibe-cafe/vibe-usage reset        Delete all data and re-upload
-    npx @vibe-cafe/vibe-usage reset --local  Delete data for this host only and re-upload
+    npx @vibe-cafe/vibe-usage reset --local  Delete data for this host only and re-upload (--host is a legacy alias)
     npx @vibe-cafe/vibe-usage skill         Install skill for AI coding tools
     npx @vibe-cafe/vibe-usage skill --remove  Remove installed skills
     npx @vibe-cafe/vibe-usage status       Show config and detected tools
@@ -202,7 +205,9 @@ export async function run(rawArgs) {
 `);
       break;
     }
-    default: {
+    case undefined: {
+      // Bare invocation (no command): first run OR a one-shot --key setup →
+      // init; already configured → sync.
       const config = loadConfig();
       if (!config?.apiKey || apiKey) {
         // First run OR user passed --key for a one-shot setup — init.js prints the big header
@@ -214,6 +219,15 @@ export async function run(rawArgs) {
         const { runSync } = await import('./sync.js');
         await runSync();
       }
+      break;
+    }
+    default: {
+      // Compatibility is explicit above: --key, --daemon, reset --host, and
+      // the no-command init/sync behavior remain supported. Unknown words were
+      // never public commands; failing them avoids typo-triggered side effects.
+      console.error(`Unknown command: ${command}`);
+      console.error('Run `vibe-usage help` to see available commands.');
+      process.exit(1);
     }
   }
 }

package/src/parsers/codex.js

@@ -1,4 +1,4 @@
-import { createReadStream, readdirSync, existsSync } from 'node:fs';
+import { createReadStream, readdirSync, existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { createInterface } from 'node:readline';
@@ -42,9 +42,15 @@ function findJsonlFiles(dir) {
   return results;
 }
 
-function readLines(filePath) {
+function readLines(filePath, snapshotSize) {
   return createInterface({
-    input: createReadStream(filePath, { encoding: 'utf-8' }),
+    input: createReadStream(filePath, {
+      encoding: 'utf-8',
+      // Rollouts are append-only while Codex is working. Bound both parser
+      // passes to the size captured before pass 1 so they see the same prefix
+      // even when the live file grows between reads.
+      ...(snapshotSize == null ? {} : { end: snapshotSize - 1 }),
+    }),
     crlfDelay: Infinity,
   });
 }
@@ -143,6 +149,34 @@ function longestReplayPrefix(child, parent) {
   return matched;
 }
 
+/**
+ * Return the longest prefix of `child` found contiguously anywhere in
+ * `parent`. A live sub-agent rollout can be observed while Codex is still
+ * copying the parent block, before that copy reaches the parent snapshot's
+ * end. In that state the exact records are inherited history even though the
+ * stricter completed-replay suffix match above deliberately rejects them.
+ */
+function longestPartialReplayPrefix(child, parent) {
+  if (child.length === 0 || parent.length === 0) return 0;
+
+  const prefix = new Array(child.length).fill(0);
+  for (let i = 1, matched = 0; i < child.length; i++) {
+    while (matched > 0 && child[i] !== child[matched]) matched = prefix[matched - 1];
+    if (child[i] === child[matched]) matched++;
+    prefix[i] = matched;
+  }
+
+  let matched = 0;
+  let longest = 0;
+  for (const fingerprint of parent) {
+    while (matched > 0 && fingerprint !== child[matched]) matched = prefix[matched - 1];
+    if (fingerprint === child[matched]) matched++;
+    longest = Math.max(longest, matched);
+    if (matched === child.length) matched = prefix[matched - 1];
+  }
+  return longest;
+}
+
 // `task_started.started_at` is stored at one-second precision while the
 // canonical session timestamp has milliseconds. Real Codex Desktop rollouts
 // start the child task within a few seconds of creating the child session.
@@ -160,7 +194,7 @@ const OWN_TASK_START_WINDOW_MS = 5_000;
  * full prefix. Together they bound matching to source records that existed at
  * spawn without over-skipping child work when the parent later grows.
  */
-async function indexSessionFile(filePath) {
+async function indexSessionFile(filePath, snapshotSize) {
   let sessionId = null;
   let forkedFromId = null;
   let parentThreadId = null;
@@ -178,7 +212,7 @@ async function indexSessionFile(filePath) {
   let firstTaskBoundary = null;
   let ownTaskBoundary = null;
 
-  for await (const line of readLines(filePath)) {
+  for await (const line of readLines(filePath, snapshotSize)) {
     if (!line.trim()) continue;
     try {
       const obj = JSON.parse(line);
@@ -261,12 +295,13 @@ function replayBoundary(meta, sessionById) {
   const parentAtSpawn = parent && meta.sessionStartedAtMs != null
     ? upperBound(parent.tokenTimes, meta.sessionStartedAtMs)
     : null;
-  const replayTokenCount = parentAtSpawn == null
-    ? 0
-    : longestReplayPrefix(
-      meta.tokenFingerprints,
-      parent.tokenFingerprints.slice(0, parentAtSpawn)
-    );
+  const parentSnapshot = parentAtSpawn == null
+    ? []
+    : parent.tokenFingerprints.slice(0, parentAtSpawn);
+  const replayTokenCount = longestReplayPrefix(meta.tokenFingerprints, parentSnapshot);
+  const partialReplayTokenCount = meta.isSubagent
+    ? longestPartialReplayPrefix(meta.tokenFingerprints, parentSnapshot)
+    : 0;
 
   if (meta.isSubagent) {
     // Direct evidence inside the child wins. Legacy single-meta rollouts did
@@ -292,11 +327,25 @@ function replayBoundary(meta, sessionById) {
         : null);
     if (direct) {
       return {
-        rawTokenCount: Math.max(replayTokenCount, direct.rawTokenCount),
+        rawTokenCount: Math.max(
+          replayTokenCount,
+          partialReplayTokenCount,
+          direct.rawTokenCount
+        ),
         recordIndex: direct.recordIndex,
       };
     }
-    return { rawTokenCount: replayTokenCount, recordIndex: null };
+
+    // A recognized sub-agent can be synced while Codex is only partway
+    // through appending the copied parent block. The completed-replay matcher
+    // correctly rejects that interior slice, but counting it would create a
+    // temporary spike that disappears on the next sync. Exact payload overlap
+    // with the known parent is sufficient evidence to defer those leading
+    // records until the rollout reaches a stable suffix or task boundary.
+    return {
+      rawTokenCount: Math.max(replayTokenCount, partialReplayTokenCount),
+      recordIndex: null,
+    };
   }
 
   if (meta.forkedFromId) {
@@ -311,7 +360,16 @@ export async function parse() {
 
   const entries = [];
   const sessionEvents = [];
-  const files = dirs.flatMap(findJsonlFiles);
+  const files = [];
+  for (const filePath of dirs.flatMap(findJsonlFiles)) {
+    try {
+      const snapshotSize = statSync(filePath).size;
+      if (snapshotSize > 0) files.push({ filePath, snapshotSize });
+    } catch {
+      // The file may move to archived_sessions between discovery and stat.
+      // Its archived copy will be picked up on the next sync.
+    }
+  }
   if (files.length === 0) return { buckets: [], sessions: [] };
 
   // Pass 1: build a compact per-file index. Keep the most complete physical
@@ -319,10 +377,10 @@ export async function parse() {
   // sessions/ and archived_sessions/ cannot double its token buckets.
   const sessionById = new Map();
   const fileMeta = new Map();
-  for (const filePath of files) {
+  for (const { filePath, snapshotSize } of files) {
     let meta;
     try {
-      meta = await indexSessionFile(filePath);
+      meta = await indexSessionFile(filePath, snapshotSize);
     } catch {
       continue;
     }
@@ -336,7 +394,7 @@ export async function parse() {
   }
 
   // Pass 2: parse usage while skipping the replay prefix resolved above.
-  for (const filePath of files) {
+  for (const { filePath, snapshotSize } of files) {
     const fm = fileMeta.get(filePath);
     if (!fm) continue;
     if (fm.sessionId && sessionById.get(fm.sessionId)?.filePath !== filePath) continue;
@@ -357,7 +415,7 @@ export async function parse() {
     let turnContextModel = 'unknown';
     let prevTotal = null;
     let prevCumulativeTotal = null;
-    for await (const line of readLines(filePath)) {
+    for await (const line of readLines(filePath, snapshotSize)) {
       if (!line.trim()) continue;
       try {
         const obj = JSON.parse(line);
@@ -483,6 +541,13 @@ export async function parse() {
         continue;
       }
     }
+
+    // The byte bound makes append-only growth invisible to both passes. If a
+    // rollout was instead truncated or replaced in place, fail the Codex
+    // parser rather than upload totals produced from two different snapshots.
+    if (parsedRecordIndex !== fm.parsedRecordCount || rawTokenSeen !== fm.rawTokenCount) {
+      throw new Error('Codex rollout changed while syncing; retry on the next sync');
+    }
   }
 
   return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };

package/src/parsers/cursor.js

@@ -210,7 +210,9 @@ export async function parse() {
   } catch (err) {
     // Network/timeout → silent skip (avoid noisy daemon logs every 5 min).
     // Auth failure → bubble up so user sees they need to re-login in Cursor.
-    if (err && err.skip) return { buckets: [], sessions: [] };
+    // 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 };
     throw err;
   }
   const rows = parseCsv(csv);

package/src/parsers/kimi-code.js

@@ -33,7 +33,8 @@ import { aggregateToBuckets, extractSessions } from './index.js';
 // Current format: ~/.kimi-code
 // ---------------------------------------------------------------------------
 
-const KIMI_CODE_DIR = join(homedir(), '.kimi-code');
+// VIBE_USAGE_KIMI_CODE_DIR overrides the root (test hook).
+const KIMI_CODE_DIR = process.env.VIBE_USAGE_KIMI_CODE_DIR?.trim() || join(homedir(), '.kimi-code');
 const KIMI_CODE_SESSIONS_DIR = join(KIMI_CODE_DIR, 'sessions');
 const KIMI_CODE_SESSION_INDEX = join(KIMI_CODE_DIR, 'session_index.jsonl');
 
@@ -76,6 +77,11 @@ function projectFromBucketName(name) {
   return m ? m[1] : name;
 }
 
+function usageTokens(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
 // Collect every agents/<id>/wire.jsonl under sessions/wd_<...>/session_<...>/.
 function findKimiCodeWireFiles(baseDir) {
   const results = [];
@@ -148,30 +154,45 @@ function parseKimiCode() {
       try { evt = JSON.parse(line); } catch { continue; }
 
       const type = evt.type;
-      // Top-level `time` is integer milliseconds since epoch.
-      const time = typeof evt.time === 'number' ? evt.time : null;
-
-      // Session timing: a user turn vs. anything the model emits.
-      if (type === 'turn.prompt' && evt.origin?.kind === 'user' && time) {
-        const ts = new Date(time);
-        if (!isNaN(ts.getTime())) {
-          sessionEvents.push({ sessionId: wireFile, source: 'kimi-code', project, timestamp: ts, role: 'user' });
+      // Top-level `time` is integer milliseconds since epoch. Validate it:
+      // JSON numbers can overflow to Infinity (e.g. 1e400 parses fine), and
+      // any out-of-range value yields an Invalid Date that later crashes
+      // aggregateToBuckets() (RangeError from toISOString) — one corrupt line
+      // would take down this tool's entire parse.
+      const time = typeof evt.time === 'number' && Number.isFinite(evt.time) ? evt.time : null;
+      const ts = time !== null ? new Date(time) : null;
+      const tsValid = ts !== null && !isNaN(ts.getTime());
+
+      // Session timing: a user turn vs. anything the model emits. All agent
+      // wires under one sessionDir belong to the same logical user session;
+      // grouping by wireFile would create separate zero-user sessions for
+      // subagents instead of attributing their work to the parent turn.
+      if (type === 'turn.prompt' && evt.origin?.kind === 'user') {
+        if (tsValid) {
+          sessionEvents.push({ sessionId: sessionDir, source: 'kimi-code', project, timestamp: ts, role: 'user' });
         }
         continue;
       }
 
       if (type !== 'usage.record') continue;
+      // Every usage.record is a delta. `turn` is the normal successful-step
+      // scope; `session` is used for other real model calls (for example
+      // retry/compaction work), not for a cumulative summary. Count both.
+      // No valid timestamp → can't bucket accurately. Skip instead of stamping
+      // "now": this parser is stateless, so a "now" fallback would re-key the
+      // same record into a fresh 30-min bucket on every sync (duplicates).
+      if (!tsValid) continue;
 
       const usage = evt.usage;
       if (!usage) continue;
 
-      const inputTokens = usage.inputOther || 0;
-      const outputTokens = usage.output || 0;
-      const cachedInputTokens = usage.inputCacheRead || 0;
+      // Cache creation is billed non-cached input, matching the common bucket
+      // model used by the other parsers; cache reads stay in their own field.
+      const inputTokens = usageTokens(usage.inputOther) + usageTokens(usage.inputCacheCreation);
+      const outputTokens = usageTokens(usage.output);
+      const cachedInputTokens = usageTokens(usage.inputCacheRead);
       if (!inputTokens && !outputTokens && !cachedInputTokens) continue;
 
-      const ts = time ? new Date(time) : new Date();
-
       entries.push({
         source: 'kimi-code',
         model: evt.model || 'unknown',
@@ -185,9 +206,7 @@ function parseKimiCode() {
 
       // Each usage.record marks an assistant step completing — use it as an
       // assistant timing event so active-time math has both sides of a turn.
-      if (time && !isNaN(ts.getTime())) {
-        sessionEvents.push({ sessionId: wireFile, source: 'kimi-code', project, timestamp: ts, role: 'assistant' });
-      }
+      sessionEvents.push({ sessionId: sessionDir, source: 'kimi-code', project, timestamp: ts, role: 'assistant' });
     }
   }
 
@@ -198,7 +217,8 @@ function parseKimiCode() {
 // Legacy format: ~/.kimi  (kept for users who haven't migrated to ~/.kimi-code)
 // ---------------------------------------------------------------------------
 
-const KIMI_DIR = join(homedir(), '.kimi');
+// VIBE_USAGE_KIMI_DIR overrides the legacy root (test hook).
+const KIMI_DIR = process.env.VIBE_USAGE_KIMI_DIR?.trim() || join(homedir(), '.kimi');
 const KIMI_SESSIONS_DIR = join(KIMI_DIR, 'sessions');
 const KIMI_WORKDIRS_JSON = join(KIMI_DIR, 'kimi.json');
 const KIMI_CONFIG_TOML = join(KIMI_DIR, 'config.toml');

package/src/reset.js

@@ -1,8 +1,9 @@
 import { createInterface } from 'node:readline';
 import { hostname as getHostname } from 'node:os';
-import { loadConfig, saveConfig } from './config.js';
+import { loadConfig } from './config.js';
 import { deleteAllData } from './api.js';
 import { runSync } from './sync.js';
+import { clearState } from './state.js';
 import { success, failure, arrow, link, dim } from './output.js';
 
 function prompt(question) {
@@ -15,19 +16,32 @@ function prompt(question) {
   });
 }
 
-export async function runReset(args = []) {
-  const hostOnly = args.includes('--local');
+export async function runReset(args = [], deps = {}) {
+  // Injectable for tests — the production defaults hit readline, the network,
+  // and the real sync pipeline.
+  const ask = deps.prompt ?? prompt;
+  const deleteRemote = deps.deleteAllData ?? deleteAllData;
+  const resync = deps.runSync ?? runSync;
+
+  // --host was the original public spelling before --local replaced it.
+  // Keep the old flag as an alias so existing reset scripts stay safe: losing
+  // the filter would turn a host-only reset into a destructive account-wide
+  // reset.
+  const hostOnly = args.includes('--local') || args.includes('--host');
   const config = loadConfig();
   if (!config?.apiKey) {
     console.error(failure('尚未配置，请先运行 `npx @vibe-cafe/vibe-usage init`。'));
     process.exit(1);
   }
 
-  const currentHost = getHostname().replace(/\.local$/, '');
+  // Target the hostname persisted at init — the same one sync.js uploads
+  // under. A fresh os.hostname() can have drifted since (macOS mDNS adds -2
+  // suffixes), which would delete zero rows, or another machine's rows.
+  const currentHost = config.hostname || getHostname().replace(/\.local$/, '');
   const apiUrl = config.apiUrl || 'https://vibecafe.ai';
 
   if (hostOnly) {
-    const answer = await prompt(`将删除当前机器（${currentHost}）的用量数据并从本地日志重新上传，继续? (y/N) `);
+    const answer = await ask(`将删除当前机器（${currentHost}）的用量数据并从本地日志重新上传，继续? (y/N) `);
     if (answer.toLowerCase() !== 'y') {
       console.log(dim('已取消。'));
       return;
@@ -35,7 +49,7 @@ export async function runReset(args = []) {
 
     console.log(dim(`  正在删除 ${currentHost} 的云端数据...`));
     try {
-      const result = await deleteAllData(apiUrl, config.apiKey, { hostname: currentHost });
+      const result = await deleteRemote(apiUrl, config.apiKey, { hostname: currentHost });
       console.log(success(`已删除 ${result.deleted} buckets · ${result.sessions ?? 0} sessions`));
     } catch (err) {
       if (err.message === 'UNAUTHORIZED') {
@@ -46,7 +60,7 @@ export async function runReset(args = []) {
       process.exit(1);
     }
   } else {
-    const answer = await prompt('将删除所有用量数据并从本地日志重新上传，继续? (y/N) ');
+    const answer = await ask('将删除所有用量数据并从本地日志重新上传，继续? (y/N) ');
     if (answer.toLowerCase() !== 'y') {
       console.log(dim('已取消。'));
       return;
@@ -54,7 +68,7 @@ export async function runReset(args = []) {
 
     console.log(dim('  正在删除所有云端数据...'));
     try {
-      const result = await deleteAllData(apiUrl, config.apiKey);
+      const result = await deleteRemote(apiUrl, config.apiKey);
       console.log(success(`已删除 ${result.deleted} buckets · ${result.sessions ?? 0} sessions`));
     } catch (err) {
       if (err.message === 'UNAUTHORIZED') {
@@ -66,13 +80,15 @@ export async function runReset(args = []) {
     }
   }
 
-  // Clear local state (legacy — no state files needed for current parsers)
-  config.lastSync = null;
-  saveConfig(config);
+  // The remote rows are gone, so every local item must count as "changed" on
+  // the re-sync below. Without this, sync.js's incremental diff matches every
+  // item against state.json and uploads zero bytes — the deleted data would
+  // never come back.
+  clearState();
 
   console.log();
   console.log(dim('  从本地日志重新同步...'));
-  await runSync();
+  await resync();
 
   console.log();
   console.log(`${arrow('Dashboard')} ${link(`${apiUrl}/usage`)}`);

package/src/sync.js

@@ -34,12 +34,23 @@ export async function runSync({ throws = false, quiet = false } = {}) {
   const allBuckets = [];
   const allSessions = [];
   const parserResults = [];
+  // 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.
+  const okSources = new Set();
 
   for (const [source, parse] of Object.entries(parsers)) {
     try {
       const result = await parse();
       const buckets = Array.isArray(result) ? result : result.buckets;
       const sessions = Array.isArray(result) ? [] : (result.sessions || []);
+      if (!Array.isArray(buckets) || !Array.isArray(sessions)) {
+        throw new TypeError('Parser returned an invalid result');
+      }
+      // A parser may deliberately suppress a transient error (Cursor network
+      // timeout) to keep daemon logs quiet. Its empty result is not proof that
+      // its prior data disappeared, so it must not be pruned this run.
+      if (!result?.skipped) okSources.add(source);
       if (buckets.length > 0) allBuckets.push(...buckets);
       if (sessions.length > 0) allSessions.push(...sessions);
       if (buckets.length > 0 || sessions.length > 0) {
@@ -52,6 +63,14 @@ export async function runSync({ throws = false, quiet = false } = {}) {
   }
 
   if (allBuckets.length === 0 && allSessions.length === 0) {
+    // 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();
+    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);
     if (!quiet) console.log(dim('暂无新数据。'));
     return 0;
   }
@@ -135,7 +154,7 @@ export async function runSync({ throws = false, quiet = false } = {}) {
   // to upload success. If we deferred this to the batch loop, a first-batch
   // failure would throw before any saveState and the prune would be lost.
   const before = Object.keys(state.buckets).length + Object.keys(state.sessions).length;
-  pruneState(state, liveBucketKeys, liveSessionKeys);
+  pruneState(state, liveBucketKeys, liveSessionKeys, okSources);
   const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
   if (pruned > 0) saveState(state);
 
@@ -241,4 +260,3 @@ export async function runSync({ throws = false, quiet = false } = {}) {
     process.exit(1);
   }
 }
-