@vibe-cafe/vibe-usage 0.13.1 → 0.14.0

package/README.md

@@ -92,13 +92,14 @@ Quota results are never uploaded or added to incremental sync state. Credential-
 | Oh My Pi | `~/.omp/agent/sessions/`, `~/.omp/profiles/*/agent/sessions/`, and `$XDG_DATA_HOME/omp/{sessions,profiles/*/sessions}`; recognizes OMP's `$PI_CODING_AGENT_DIR`, current v3 title slots and path/hashed session directories, deduplicates copied records, includes cache writes in input, and splits reasoning from OMP's inclusive output count |
 | pi | `~/.pi/agent/sessions/` or `$PI_CODING_AGENT_DIR/sessions/`, plus the session directory Pi itself was pointed at via `PI_CODING_AGENT_SESSION_DIR` or `sessionDir` in `~/.pi/agent/settings.json`, plus explicitly added `pi-coding-agent` roots for stores only reachable through `pi --session <file>` (fixture/relocation override: `VIBE_USAGE_PI_SESSION_DIRS`). Cache writes are included in input usage; reasoning is read from Pi's `usage.reasoning` (legacy `usage.reasoningTokens` still accepted) and split out of the inclusive output total |
 | Qwen Code | `~/.qwen/tmp/` |
+| Kiki | `$KIKI_HOME/sessions/` (default `~/.kiki/sessions/`; fixture override: `VIBE_USAGE_KIKI_DIR` sets the home). Reports **`kiki` / Kiki**, independently of Kimi Code, using the shared per-agent `usage.record` reader. Main/subagent deltas, retries and compaction are counted; cache creation joins input because no TTL is recorded, while cache reads stay separate. Exact copied records for the same session/agent count once, without collapsing repeated calls inside a wire. Known routing prefixes in `KIKI_MODEL_PREFIXES` are removed; other slash-bearing model ids are preserved. No estimated cache ratios or source-data rewrites. |
 | Kimi Code | Current `<home>/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`. Every home with that layout is scanned: the CLI home (`$KIMI_CODE_HOME`, else `~/.kimi-code`) plus the Kimi Work desktop app's embedded runtime home (`<Electron userData>/kimi-desktop/daimon-share/daimon/runtime/kimi-code/home`), which the app never writes into the CLI home; legacy `~/.kimi/sessions/` is parsed alongside (`kimi migrate` never carries usage over, so both stores are always merged) |
-| MiniMax Code (mcode) | `$MCODE_HOME/v2/sqlite/runtime-state.sqlite` (default `~/.minimax/v2/sqlite/runtime-state.sqlite`; fixture override: `VIBE_USAGE_MCODE_DB`). Reads only allow-listed token ledger fields and session workspace/project paths, uses basename-only projects, folds cache writes into input, keeps cache reads and reasoning separate, and never selects raw/message JSON payloads. WAL/lock reads use a disposable snapshot; malformed or incompatible databases are skipped to preserve incremental state. |
+| MiniMax Code (mcode) | `$MCODE_HOME/v2/sqlite/runtime-state.sqlite` (default `~/.minimax/v2/sqlite/runtime-state.sqlite`; also reads the roots the CLI relocates to — `$MINIMAX_DATA_DIR` / `$MAVIS_DATA_DIR`, each `~/.minimax-<profile>`, the pre-npm `~/.minimax-code` user-data dir and the pre-rename `~/.mavis` home — and merges them, dropping rows a store only holds as a copy; fixture override: `VIBE_USAGE_MCODE_DB`). Reads only allow-listed token ledger fields and session workspace/project paths, uses basename-only projects, folds cache writes into input, keeps cache reads and reasoning separate, and never selects raw/message JSON payloads. WAL/lock reads use a disposable snapshot; malformed or incompatible databases are skipped to preserve incremental state (a broken extra store is reported as a warning instead of blanking the live one). |
 | MiMoCode | `$MIMOCODE_HOME/data/mimocode.db`, `$XDG_DATA_HOME/mimocode/mimocode.db`, or `~/.local/share/mimocode/mimocode.db` (SQLite; exact input, output, reasoning, and cache-read tokens from assistant messages; honors `MIMOCODE_DB`; cache-write tokens are included in input usage) |
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |
 | DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads V0–V4 logs, including `session.v4.jsonl.zstd` from DSH's V4 integration format, with multi-frame Zstandard support (Node ≥ 22.15 built-in, `zstd` CLI fallback) and plain JSONL support. Each session uses its highest `session[.vN].jsonl[.zstd]` generation once, so frozen pre-migration logs are not double-counted. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork history uses V0/V1 `seedLength` or V2–V4's last `session/end-seed` tagged `inherited: true`, and is skipped only when the parent copy confirms it; missing parents retain the sole local history. Unknown versions warn and protect sync state. |
-| Hermes (CLI / Desktop) | `<home>/state.db` + `<home>/profiles/<name>/state.db` (SQLite, multi-profile). Home: `$HERMES_HOME`, otherwise `~/.hermes` on macOS/Linux or `%LOCALAPPDATA%\hermes` on Windows (falls back to an existing `~/.hermes` only when the Windows native root is absent). Cache writes join input; reasoning is separated from inclusive output. Usage is currently a cumulative session total attributed to session start: a session spanning several days does **not** yet provide an accurate daily breakdown. |
+| Hermes (CLI / Desktop) | `<home>/state.db` + `<home>/profiles/<name>/state.db` (SQLite, multi-profile). Home: `$HERMES_HOME`, otherwise `~/.hermes` on macOS/Linux or `%LOCALAPPDATA%\hermes` on Windows (falls back to an existing `~/.hermes` only when the Windows native root is absent). Additional homes: `config add-root hermes <path>` (a directory containing `state.db` or `profiles/*/state.db`), scanned alongside the default and deduped. Cache writes join input; reasoning is separated from inclusive output. Usage is currently a cumulative session total attributed to session start: a session spanning several days does **not** yet provide an accurate daily breakdown. |
 | Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
 | Cline (CLI / SDK / Desktop app) | All variants write the same `~/.cline/data/sessions/*/*.messages.json` per-call metrics (the desktop app's manifest says `source: "desktop"`; its Electron userData holds only WebView caches), plus legacy `~/.cline/{,data/}state/taskHistory.json` and editor extension stores. Honors `CLINE_DIR`, `CLINE_DATA_DIR`, and `CLINE_SESSION_DATA_DIR`; copied history is deduplicated |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
@@ -111,6 +112,30 @@ Quota results are never uploaded or added to incremental sync state. Credential-
 | Qoder CN | China edition (qoder.com.cn, separate account). Same two shapes under `~/Library/Application Support/QoderCN/SharedClientCache/cache/db/local.db` (`QODER_CN_HOME` / `VIBE_USAGE_QODER_CN_DB`) and `~/.qoder-cn/projects/` (`QODERCN_CONFIG_DIR` / `VIBE_USAGE_QODER_CN_PROJECTS`); reported as source `qoder-cn` |
 | Devin | `$XDG_DATA_HOME/devin/cli/sessions.db` (default `~/.local/share/devin/cli/sessions.db`; fixture override `VIBE_USAGE_DEVIN_DB`). Devin CLI and Devin Desktop share this one WAL store. Reads only allow-listed fields from `message_nodes.chat_message` via `json_extract` — per-request `metadata.metrics` token counters on assistant messages, `generation_model`, `is_user_input`, timestamps — joined to `sessions.working_directory`/`model`; message content and the session credit/ACU billing fields are never selected. Cache writes fold into input, cache reads stay separate. The node forest stores some logical messages at several nodes, so rows are deduplicated by session + message id. Synthetic user records (cache keepalives) are not counted as human prompts |
 
+### Kiki setup and compatibility-collector migration
+
+For a relocated Kiki home, set `KIKI_HOME` before installing the background service; reinstall an existing service to capture a changed home. A home already collected by Kimi Code is not collected again as Kiki. Server deployment must register `kiki` with display name **Kiki** before this support is published; an unregistered source is reported in `dropped.unknownSources`, not retried under `kimi-code`. This collects token usage, not a Kiki subscription balance.
+
+If you used a compatibility collector that uploaded Kiki as `kimi-code`, **keep its `state.json`, hostname and project-upload setting**. On the first independent Kiki upload, matching legacy bucket/session keys pause Kiki only; other tools continue and overlapping old Kimi buckets are not overwritten with smaller Kimi-only totals. The legacy match recognises both the CLI's own bucket coordinates and the published collector's identity: Kiki's `kap-server` export (`vibe-kimi-bucket-v1`) uploaded source `kimi-code` with `project: 'unknown'` and `hostname: kiki-<stream_id>`, which never equals the session project and machine hostname this CLI writes, so a row with the same model and half-hour window but a different project/hostname and a different recorded hash also triggers the guard. An unchanged Kimi-only bucket does not trigger it. An unrelated Kimi history does not trigger it. Missing state or changed identity cannot prove whether cloud history overlaps; resolve that with the maintainer before importing history.
+
+Choose an explicit UTC half-hour cut **T** with no compatibility uploads at or after T. Finish and verify the old collector's coverage below T, stop that collector, then configure the new CLI before its first sync:
+
+```bash
+npx @vibe-cafe/vibe-usage config set kikiStartAt 2026-10-05T12:30:00Z  # replace with your verified cut
+```
+
+A cut (or the guard) withholds real Kiki history and freezes the overlapping old `kimi-code` rows, so those server cells stop following local growth. `sync` reports this on stderr even in quiet/daemon runs: the withheld bucket/session counts and time range, the frozen row counts, and both remedies. If the cut overlaps recorded legacy buckets, Kiki stays paused; set a later verified cut. Kiki tokens at/after T are sent as `kiki`; old mixed buckets below T remain untouched under `kimi-code`. Sessions starting before T retain their old timing identity, even if their later tokens are in new Kiki buckets.
+
+Once independent Kiki uploads are recorded, the cut cannot be changed to a *different* time by `config set`. It can always be cleared with:
+
+```bash
+npx @vibe-cafe/vibe-usage config set kikiStartAt none  # only if you are certain no compatibility collector ever ran
+```
+
+`none` deletes the cut and re-admits the previously withheld pre-cut Kiki history under `kiki`; if a legacy collector had in fact run, that history double counts, so only use it when you know it never did. Do not run both collectors for the same interval, delete state to bypass the check, or use a whole-account reset as a migration shortcut.
+
+To relabel old history, the maintainer needs the old bucket keys, raw per-tool token contributions, the cut and the target account/device. A hash of a mixed Kimi/Kiki bucket cannot be split client-side. This CLI neither deletes cloud rows nor copies that history into a second source.
+
 ## How It Works
 
 - Parses local session logs from each AI coding tool
@@ -206,7 +231,8 @@ Config stored at `~/.vibe-usage/config.json` (dev: `config.dev.json`).
 | `apiUrl` | Server URL (default: `https://vibecafe.ai`) |
 | `hostname` | Stable device name for usage tracking (set at init, reused across syncs) |
 | `codexExtraHome` | Optional additional Codex Home scanned together with `$CODEX_HOME` / `~/.codex` |
-| `extraRoots` | Tool-specific additional roots managed by the commands below; currently supports `codex`, `grok`, `antigravity`, and `pi-coding-agent` |
+| `kikiStartAt` | Explicit UTC half-hour cut for migrating a collector that reported Kiki as `kimi-code`; see the Kiki migration steps above. Unset for new installations; `config set kikiStartAt none` clears an existing cut |
+| `extraRoots` | Tool-specific additional roots managed by the commands below; currently supports `antigravity`, `claude-code`, `codex`, `grok`, `hermes`, `opencode`, and `pi-coding-agent` |
 
 The `hostname` is captured once during `init` and reused for all future syncs. This prevents macOS mDNS hostname changes (e.g., `MacBook-Pro` → `MacBook-Pro-2`) from creating duplicate device entries. To change it manually:
 
@@ -231,6 +257,10 @@ npx @vibe-cafe/vibe-usage config add-root opencode /path/to/other/opencode
 # Grok expects a Grok Home containing sessions/.
 npx @vibe-cafe/vibe-usage config add-root grok /path/to/grok-home
 
+# Hermes expects a Hermes home containing state.db or profiles/*/state.db.
+# This is in addition to ~/.hermes and $HERMES_HOME, not a replacement.
+npx @vibe-cafe/vibe-usage config add-root hermes /path/to/hermes-home
+
 # Antigravity expects an alternate HOME containing .gemini/antigravity*/conversations/.
 npx @vibe-cafe/vibe-usage config add-root antigravity /path/to/alternate-home
 

package/package.json

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

package/src/daemon-service.js

@@ -135,15 +135,18 @@ const PRESERVED_SERVICE_ENV = [
   'DSH_HOME',
   'GROK_HOME',
   'HERMES_HOME',
+  'KIKI_HOME',
   'KIMI_CODE_HOME',
   'KIRO_BASE_PATH',
   'KIRO_CLI_DB_PATH',
   'KIRO_CLI_SESSIONS_DIR',
   'KIRO_SESSIONS_DIR',
   'KIRO_USER_PATH',
+  'MAVIS_DATA_DIR',
   'MCODE_HOME',
   'MIMOCODE_HOME',
   'MIMOCODE_DB',
+  'MINIMAX_DATA_DIR',
   'PI_CONFIG_DIR',
   'PI_CODING_AGENT_DIR',
   'PI_CODING_AGENT_SESSION_DIR',

package/src/extra-roots.js

@@ -3,8 +3,9 @@ import { homedir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
 import { openCodeStore } from './opencode-roots.js';
 import { codexSessionDirs } from './codex-roots.js';
+import { inspectHermesHome } from './hermes-roots.js';
 
-export const EXTRA_ROOT_SOURCES = ['antigravity', 'claude-code', 'codex', 'grok', 'opencode', 'pi-coding-agent'];
+export const EXTRA_ROOT_SOURCES = ['antigravity', 'claude-code', 'codex', 'grok', 'opencode', 'pi-coding-agent', 'hermes'];
 
 // Probing a candidate Pi store has three outcomes, never two: a confirmed
 // session, a directory proven to hold none, and one that could not be read.
@@ -322,6 +323,16 @@ export function validateExtraRoot(source, value) {
       reason: '需要是直接包含 Pi 会话 .jsonl 的目录，或包含 sessions/ 的 Pi agent 目录',
     };
   }
+  if (source === 'hermes') {
+    const inspected = inspectHermesHome(path);
+    return {
+      ok: inspected.ok,
+      path,
+      reason: inspected.error
+        ? `无法读取 Hermes 目录: ${inspected.error.message}`
+        : '需要包含可读的 state.db 或 profiles/*/state.db',
+    };
+  }
   const dirs = source === 'grok'
     ? [grokSessionsDir(path)]
     : antigravityConversationDirs(path);

package/src/hermes-roots.js

@@ -1,5 +1,5 @@
-import { readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { accessSync, constants, readdirSync, realpathSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 
 // Match the Hermes CLI/Desktop layout. Windows installers use LOCALAPPDATA;
@@ -26,10 +26,27 @@ function statIfPresent(path, onError) {
   }
 }
 
-// Parsing must fail on unreadable stores: a partial result would allow sync
-// to prune that profile's previous state. Detection alone is best-effort.
-export function discoverHermesDatabases({ onError = err => { throw err; } } = {}) {
-  const home = getHermesHome({ onError });
+function isReadableFile(path) {
+  try {
+    if (!statSync(path).isFile()) return false;
+    accessSync(path, constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Identity for dedup: symlinks and relative spellings of one database are one store.
+export function hermesPathKey(path) {
+  const resolved = resolve(path);
+  try {
+    return realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+
+function collectHermesDatabases(home, onError) {
   const dbs = [];
 
   const defaultDb = join(home, 'state.db');
@@ -54,6 +71,43 @@ export function discoverHermesDatabases({ onError = err => { throw err; } } = {}
   return dbs;
 }
 
-export function findHermesDataDirs() {
-  return discoverHermesDatabases({ onError: () => {} }).map(db => db.path);
+// Parsing must fail on unreadable stores: a partial result would allow sync
+// to prune that profile's previous state. Detection alone is best-effort.
+export function discoverHermesDatabases({ onError = err => { throw err; } } = {}) {
+  return collectHermesDatabases(getHermesHome({ onError }), onError);
+}
+
+// Scoped to the given home, not getHermesHome(). `ok` requires a readable
+// state.db or profiles/<name>/state.db. `error` means the read could not be
+// finished (anything other than a missing path); callers must skip the source
+// instead of reporting an empty success.
+export function inspectHermesHome(home) {
+  let error = null;
+  const dbs = collectHermesDatabases(home, (err) => {
+    error = error || err;
+  });
+  return {
+    dbs,
+    error,
+    ok: error == null && dbs.some(db => isReadableFile(db.path)),
+  };
+}
+
+export function findHermesDataDirs(extraHomes = []) {
+  const dbs = discoverHermesDatabases({ onError: () => {} });
+  const seen = new Set(dbs.map(db => hermesPathKey(db.path)));
+  for (const home of extraHomes) {
+    if (typeof home !== 'string' || !home.trim()) continue;
+    const inspected = inspectHermesHome(home);
+    // Detection is best-effort. The parser reports an unreadable extra home
+    // as skipped so a failed stat cannot be uploaded as "no data".
+    if (!inspected.ok) continue;
+    for (const db of inspected.dbs) {
+      const key = hermesPathKey(db.path);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      dbs.push(db);
+    }
+  }
+  return dbs.map(db => db.path);
 }

package/src/index.js

@@ -12,6 +12,7 @@ import { dim as dimText, failure, hint, smallHeader, warn } from './output.js';
 import { loadState } from './state.js';
 import { fetchAccount } from './api.js';
 import { COLLECTOR_VERSION } from './client-meta.js';
+import { kikiStartTime } from './kiki-migration.js';
 
 function printSmallHeader() {
   console.log();
@@ -123,7 +124,7 @@ async function printBoundAccount(apiUrl, apiKey) {
   }
 }
 
-const VALID_CONFIG_KEYS = ['apiKey', 'apiUrl', 'hostname', 'codexExtraHome'];
+const VALID_CONFIG_KEYS = ['apiKey', 'apiUrl', 'hostname', 'codexExtraHome', 'kikiStartAt'];
 
 function handleConfig(args) {
   const sub = args[0];
@@ -165,6 +166,31 @@ function handleConfig(args) {
         value = validation.path;
       }
       const config = loadConfig() || {};
+      if (key === 'kikiStartAt') {
+        // `none` is the documented escape hatch for a user who asserts no
+        // compatibility collector ever ran. It clears the cut (deleting the
+        // key so nothing ever stores or prints the literal) and is allowed at
+        // any time, unlike changing to a different time once `kiki|` state
+        // exists — otherwise a user who set a cut could never back it out.
+        if (value === 'none') {
+          if ('kikiStartAt' in config) delete config.kikiStartAt;
+          saveConfig(config);
+          console.log(warn('已清除 Kiki 切点：早于原切点的 Kiki 历史现在会作为 kiki 上传。若实际上运行过把 Kiki 记为 kimi-code 的兼容采集器，这会与原记录双计，请自行确认。'));
+          break;
+        }
+        try {
+          const time = kikiStartTime(value);
+          const state = loadState();
+          const hasKikiState = [...Object.keys(state.buckets), ...Object.keys(state.sessions)].some(key => key.startsWith('kiki|'));
+          if (hasKikiState && kikiStartTime(config.kikiStartAt) !== time) {
+            throw new Error('已保存的 Kiki 切点不能直接更改；请先与服务端维护者协调历史迁移。');
+          }
+          value = new Date(time).toISOString();
+        } catch (err) {
+          console.error(failure(err.message));
+          process.exit(1);
+        }
+      }
       config[key] = value;
       saveConfig(config);
       break;
@@ -305,7 +331,7 @@ const FULL_HELP = `
     ${BARE} config get <key>   Get a config value
     ${BARE} config set <key> <value>  Set a config value
     ${BARE} config set codexExtraHome <path>  Persist another Codex Home
-    ${BARE} config add-root <tool> <path>  Add a Claude Code, Codex, Grok, OpenCode, Antigravity, or Pi data root
+    ${BARE} config add-root <tool> <path>  Add a Claude Code, Codex, Grok, OpenCode, Antigravity, Pi, or Hermes data root
     ${BARE} config remove-root <tool> <path>  Remove an added data root
     ${BARE} config roots  Show added data roots as JSON
     ${BARE} help         Show the short help

package/src/kiki-migration.js

@@ -0,0 +1,109 @@
+import { bucketKey, bucketHash, sessionKey } from './state.js';
+
+const HALF_HOUR_MS = 1_800_000;
+
+export function kikiStartTime(value) {
+  if (value === undefined) return null;
+  const time = typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:(?:00|30):00(?:\.000)?Z$/.test(value)
+    ? Date.parse(value) : NaN;
+  const canonical = typeof value === 'string' ? value.replace(/(?:\.000)?Z$/, '.000Z') : '';
+  if (!Number.isSafeInteger(time) || time < 0 || time % HALF_HOUR_MS !== 0
+    || new Date(time).toISOString() !== canonical) {
+    throw new Error('kikiStartAt 必须是 UTC 半小时边界，例如 2026-10-05T12:30:00Z');
+  }
+  return time;
+}
+
+// State bucket keys are `source|model|project|hostname|bucketStart`
+// (state.js bucketKey). The one collector path that ever reported Kiki as
+// kimi-code is Kiki's own kap-server export (`vibe-kimi-bucket-v1`): it uploads
+// source `kimi-code` with project 'unknown' and hostname `kiki-<stream_id>`.
+// Neither of those can ever equal the coordinates this CLI writes (the session
+// project and the machine hostname), so an exact-key lookup alone silently
+// misses that history and lets it double count. Treat a current Kiki bucket as
+// legacy-overlapping when a `kimi-code|` state row shares its model and
+// bucketStart but was recorded under a different project/hostname and its
+// recorded hash differs from this CLI's own current Kimi-only hash for the
+// coordinate. That hash guard keeps an unchanged genuine Kimi snapshot (or an
+// unrelated Kimi history) from being mistaken for compatibility evidence.
+function legacyBucketKeys(state, kikiBucket, kimiHashes) {
+  const coordinate = bucketKey({ ...kikiBucket, source: 'kimi-code' });
+  const keys = [];
+  // Exact-key rule: the row uses this CLI's own coordinates, and its hash no
+  // longer matches the genuine Kimi-only bucket (a changed or absent snapshot).
+  if (coordinate in state.buckets && state.buckets[coordinate] !== kimiHashes.get(coordinate)) {
+    keys.push(coordinate);
+  }
+  const [source, model] = coordinate.split('|');
+  const bucketStart = coordinate.slice(coordinate.lastIndexOf('|') + 1);
+  for (const key of Object.keys(state.buckets)) {
+    if (!key.startsWith('kimi-code|')) continue;
+    const parts = key.split('|');
+    if (parts[0] !== source || parts[1] !== model || parts[parts.length - 1] !== bucketStart) continue;
+    // Same model and window, but a different project/hostname: recorded by
+    // something other than this CLI's own current Kimi snapshot. The coordinate
+    // key itself is excluded here — it is the exact-key rule above.
+    if (parts[2] === kikiBucket.project && parts[3] === kikiBucket.hostname) continue;
+    if (state.buckets[key] === kimiHashes.get(coordinate)) continue;
+    keys.push(key);
+  }
+  return keys;
+}
+
+// The unpublished compatibility collector reported Kiki as kimi-code. Its
+// state contains hashes, not source contributions: overlap is a conservative
+// migration signal, never proof that a particular Kimi bucket contains Kiki.
+export function planKikiMigration(buckets, sessions, state, startAt) {
+  const start = kikiStartTime(startAt);
+  const kikiBuckets = buckets.filter(b => b.source === 'kiki');
+  const kikiSessions = sessions.filter(s => s.source === 'kiki');
+  const kimiHashes = new Map(buckets.filter(b => b.source === 'kimi-code').map(b => [bucketKey(b), bucketHash(b)]));
+  const legacyBuckets = new Set();
+  for (const b of kikiBuckets) {
+    for (const key of legacyBucketKeys(state, b, kimiHashes)) legacyBuckets.add(key);
+  }
+  // Sessions are keyed `source|sessionHash`, so the collector's project and
+  // hostname never enter the key — the exact rule already matches it.
+  const legacySessions = new Set(kikiSessions.map(s => sessionKey({ ...s, source: 'kimi-code' }))
+    .filter(key => key in state.sessions));
+  const hasKikiState = [...Object.keys(state.buckets), ...Object.keys(state.sessions)]
+    .some(key => key.startsWith('kiki|'));
+  const overlapAfterCut = start !== null && [...legacyBuckets]
+    .some(key => Date.parse(key.slice(key.lastIndexOf('|') + 1)) >= start);
+  const blocked = !hasKikiState && (start === null
+    ? legacyBuckets.size > 0 || legacySessions.size > 0 : overlapAfterCut);
+  const migrating = blocked || start !== null;
+  const preserveBuckets = migrating ? new Set([...legacyBuckets].filter(key => blocked
+    || Date.parse(key.slice(key.lastIndexOf('|') + 1)) < start)) : new Set();
+  const preserveSessions = migrating ? legacySessions : new Set();
+  const nextBuckets = buckets.filter(b => b.source !== 'kiki' || (!blocked && (start === null || Date.parse(b.bucketStart) >= start)));
+  // Freeze a session straddling the cut rather than upload its old timing
+  // under a new source. All post-cut token records still contribute buckets.
+  const nextSessions = sessions.filter(s => s.source !== 'kiki' || (!blocked && (start === null || Date.parse(s.firstMessageAt) >= start)));
+  // Everything Kiki the plan drops — blocked rows, or rows before the cut —
+  // is reported so the user learns real history is being withheld rather than
+  // silently lost. `frozenBuckets`/`frozenSessions` count the kimi-code rows
+  // this run holds at their recorded hash: their growth stops uploading, so
+  // the server cell goes stale until the user resolves the migration.
+  const plannedKikiBuckets = new Set(nextBuckets.filter(b => b.source === 'kiki'));
+  const plannedKikiSessions = new Set(nextSessions.filter(s => s.source === 'kiki'));
+  const withheldBuckets = kikiBuckets.filter(b => !plannedKikiBuckets.has(b));
+  const withheldSessions = kikiSessions.filter(s => !plannedKikiSessions.has(s));
+  const starts = withheldBuckets.map(b => Date.parse(b.bucketStart)).filter(Number.isFinite);
+  return {
+    blocked,
+    preserveBuckets,
+    preserveSessions,
+    buckets: nextBuckets,
+    sessions: nextSessions,
+    withheld: {
+      buckets: withheldBuckets.length,
+      sessions: withheldSessions.length,
+      totalTokens: withheldBuckets.reduce((sum, b) => sum + (Number(b.totalTokens) || 0), 0),
+      earliest: starts.length > 0 ? new Date(Math.min(...starts)).toISOString() : null,
+      latest: starts.length > 0 ? new Date(Math.max(...starts)).toISOString() : null,
+    },
+    frozenBuckets: preserveBuckets.size,
+    frozenSessions: preserveSessions.size,
+  };
+}

package/src/kiki-roots.js

@@ -0,0 +1,30 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { join, posix, win32 } from 'node:path';
+import { homedir } from 'node:os';
+import { resolveKimiCodeRoots } from './kimi-roots.js';
+
+// Kiki is a separate tool, even when it uses a Kimi model/provider.
+export const KIKI_SOURCE_ID = 'kiki';
+
+export function resolveKikiRoots(env = process.env, platform = process.platform, home = homedir()) {
+  const pathImpl = platform === 'win32' ? win32 : posix;
+  return [env.VIBE_USAGE_KIKI_DIR?.trim() || env.KIKI_HOME?.trim() || pathImpl.join(home, '.kiki')];
+}
+
+// Never collect the same physical home under both tool identities.
+export function independentKikiRoots(excludeRoots = [], roots = resolveKikiRoots()) {
+  const identity = path => {
+    try { return realpathSync(path); } catch { return path; }
+  };
+  const seen = new Set(excludeRoots.map(identity));
+  return roots.filter(root => {
+    const key = identity(root);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+export function findKikiDataDirs() {
+  return independentKikiRoots(resolveKimiCodeRoots()).map(root => join(root, 'sessions')).filter(existsSync);
+}

package/src/parsers/hermes.js

@@ -1,4 +1,5 @@
-import { discoverHermesDatabases } from '../hermes-roots.js';
+import { discoverHermesDatabases, hermesPathKey, inspectHermesHome } from '../hermes-roots.js';
+import { normalizeExtraRoot } from '../extra-roots.js';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { toCount } from './fs-utils.js';
 import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
@@ -9,24 +10,43 @@ import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from '.
  * Hermes supports multiple profiles — the default profile lives at
  * <home>/state.db, while named profiles live at <home>/profiles/<name>/state.db.
  * The home is shared by CLI/Desktop: ~/.hermes on macOS/Linux, LOCALAPPDATA/hermes
- * on Windows, or an explicit HERMES_HOME.
- * Each profile is an independent HERMES_HOME with its own state.db, so we scan all of them.
+ * on Windows, or an explicit HERMES_HOME. Additional homes configured with
+ * `config add-root hermes <path>` are scanned too and deduped against that default.
+ * Each profile is an independent store with its own state.db, so we scan all of them.
  *
  * Token buckets come from the sessions table (cumulative per-session totals).
  * Session timing comes from the messages table (per-message role + timestamp).
  */
-export async function parse() {
+export async function parse({ extraRoots = [] } = {}) {
   const dbs = discoverHermesDatabases();
+  const seen = new Set(dbs.map(db => hermesPathKey(db.path)));
+  for (const root of extraRoots) {
+    const path = normalizeExtraRoot(root);
+    const inspected = inspectHermesHome(path);
+    // Missing or unreadable configured homes must not look like an empty sync,
+    // even when the path is the default home / HERMES_HOME already scanned above.
+    // Databases already reached through that default are skipped via `seen`.
+    if (inspected.error || !inspected.ok) return skippedExtra(path, inspected.error);
+    for (const db of inspected.dbs) {
+      const key = hermesPathKey(db.path);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      dbs.push(db);
+    }
+  }
   if (dbs.length === 0) return { buckets: [], sessions: [] };
 
-  const entries = [];
-  const sessionEvents = [];
-
+  // Read every store first: which copy of a session we count is decided across
+  // all of them, not per store.
+  const stores = [];
   for (const { path: dbPath, profile } of dbs) {
     let sessionRows;
     try {
       const columns = new Set(queryDb(dbPath, 'PRAGMA table_info(sessions)').map(row => row.name));
       const cacheWriteColumn = columns.has('cache_write_tokens') ? 'cache_write_tokens' : '0';
+      // No WHERE filter here: choosing the richest copy below needs every row,
+      // and `sessions` holds one row per session. The liveness filter the old
+      // query applied is kept in JS, so the emitted set is unchanged.
       sessionRows = queryDb(dbPath, `SELECT
         id,
         model,
@@ -36,15 +56,51 @@ export async function parse() {
         cache_read_tokens as cacheReadTokens,
         ${cacheWriteColumn} as cacheWriteTokens,
         reasoning_tokens as reasoningTokens
-        FROM sessions
-        WHERE input_tokens > 0 OR output_tokens > 0
-          OR cache_read_tokens > 0 OR ${cacheWriteColumn} > 0 OR reasoning_tokens > 0`);
+        FROM sessions`);
     } catch (err) {
       if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('Hermes');
       throw err;
     }
+    stores.push({ dbPath, profile, sessionRows });
+  }
+
+  const sessionId = row => (typeof row.id === 'string' ? row.id.trim() : '');
+  const tokenTotal = row => toCount(row.inputTokens) + toCount(row.outputTokens)
+    + toCount(row.cacheReadTokens) + toCount(row.cacheWriteTokens) + toCount(row.reasoningTokens);
 
+  // A session's id is its stable record identity and its token columns are
+  // cumulative per-session totals, so one session reached through two databases
+  // (a copied or migrated home, a backup directory, a symlinked store) must be
+  // counted once. Path identity above only stops the same file being read twice
+  // -- it cannot see two files holding the same session, which counted that
+  // session's tokens twice while the timing stream, grouped by session hash,
+  // still reported a single session. Every other extra-root source dedups by
+  // its own record identity and keeps the most complete copy (opencode by
+  // session+message id, grok by session id, pi by message id); this is the same
+  // rule, with the earliest store winning a tie exactly as opencode lets the
+  // default root win.
+  const owners = new Map();
+  for (const store of stores) {
+    for (const row of store.sessionRows) {
+      const id = sessionId(row);
+      // A row with no id cannot be proven to be a copy of another row, so it
+      // stays scoped to its own store rather than collapsing with its siblings.
+      if (!id) continue;
+      const previous = owners.get(id);
+      if (!previous || tokenTotal(row) > tokenTotal(previous.row)) owners.set(id, { store, row });
+    }
+  }
+
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const { profile, sessionRows } of stores) {
     for (const row of sessionRows) {
+      const id = sessionId(row);
+      if (id && owners.get(id).row !== row) continue; // a richer copy owns this session
+      // Rows with no tokens at all contribute no bucket, as in the old query.
+      if (tokenTotal(row) === 0) continue;
+
       // started_at is a Unix timestamp (float)
       const timestamp = new Date(row.startedAt * 1000);
       if (isNaN(timestamp.getTime())) continue;
@@ -65,7 +121,16 @@ export async function parse() {
         reasoningOutputTokens: reasoning,
       });
     }
+  }
 
+  // Timing events carry their own record identity: one (session, role,
+  // timestamp) triple is one message, and a copied store repeats it verbatim.
+  // extractSessions counts every event it is handed, so without this the copy
+  // inflated messageCount while the session hash -- and therefore the session
+  // count -- stayed the same, leaving the two streams disagreeing about the
+  // same history. Dedup by that triple, first store winning.
+  const seenMessages = new Set();
+  for (const { dbPath, profile } of stores) {
     // A failed query is not an empty session history. Let sync protect this
     // source's previous state instead of uploading/pruning a partial result.
     const messageRows = queryDb(dbPath, `SELECT
@@ -79,6 +144,9 @@ export async function parse() {
     for (const row of messageRows) {
       const timestamp = new Date(row.timestamp * 1000);
       if (isNaN(timestamp.getTime())) continue;
+      const key = `${row.sessionId ?? ''}|${row.role}|${timestamp.getTime()}`;
+      if (seenMessages.has(key)) continue;
+      seenMessages.add(key);
 
       sessionEvents.push({
         sessionId: row.sessionId,
@@ -96,3 +164,14 @@ export async function parse() {
 function queryDb(dbPath, sql) {
   return queryDbJson(dbPath, sql);
 }
+
+function skippedExtra(path, error) {
+  return {
+    buckets: [],
+    sessions: [],
+    skipped: true,
+    warnings: [error
+      ? `hermes: 额外根目录读取失败，已保留上次同步数据: ${path}`
+      : `hermes: 额外根目录不可用，已跳过本次 Hermes 同步: ${path}`],
+  };
+}

package/src/parsers/index.js

@@ -14,6 +14,7 @@ import { parse as parseOpenclaw } from './openclaw.js';
 import { parse as parseOmp } from './omp.js';
 import { parse as parseQwenCode } from './qwen-code.js';
 import { parse as parseKimiCode } from './kimi-code.js';
+import { parse as parseKiki } from './kiki.js';
 import { parse as parseAmp } from './amp.js';
 import { parse as parseAlma } from './alma.js';
 import { parse as parseDroid } from './droid.js';
@@ -50,6 +51,7 @@ export const parsers = {
   'qoder': parseQoder,
   'qoder-cn': parseQoderCn,
   'qwen-code': parseQwenCode,
+  'kiki': parseKiki,
   'kimi-code': parseKimiCode,
   'amp': parseAmp,
   'alma': parseAlma,

package/src/parsers/kiki.js

@@ -0,0 +1,29 @@
+import { KIKI_SOURCE_ID, independentKikiRoots } from '../kiki-roots.js';
+import { parseCurrentKimiRoots } from './kimi-code.js';
+import { resolveKimiCodeRoots } from '../kimi-roots.js';
+
+// Strip only known routing/provider prefixes, never arbitrary slash-bearing
+// model ids (e.g. Qwen/Qwen3.8-Flash). Nested known routes are stripped in order.
+export const KIKI_MODEL_PREFIXES = Object.freeze([
+  'axon', 'axon-message', 'axon-chat', 'kimi-code', 'anthropic',
+  'deepseek', 'z-ai', 'hub', 'stealth', 'st', 'minimax',
+]);
+
+export function normalizeKikiModel(model, prefixes = KIKI_MODEL_PREFIXES) {
+  if (typeof model !== 'string' || !model) return 'unknown';
+  let normalized = model;
+  for (;;) {
+    const slash = normalized.indexOf('/');
+    if (slash < 0 || slash === normalized.length - 1
+      || !prefixes.includes(normalized.slice(0, slash))) return normalized;
+    normalized = normalized.slice(slash + 1);
+  }
+}
+
+export async function parse({ excludeRoots = [] } = {}) {
+  return parseCurrentKimiRoots(independentKikiRoots([...resolveKimiCodeRoots(), ...excludeRoots]), {
+    source: KIKI_SOURCE_ID,
+    normalizeModel: normalizeKikiModel,
+    deduplicateCopies: true,
+  }) ?? { buckets: [], sessions: [] };
+}

package/src/parsers/kimi-code.js

@@ -1,4 +1,4 @@
-import { readdirSync, readFileSync, existsSync, realpathSync } from 'node:fs';
+import { readdirSync, readFileSync, existsSync, realpathSync, statSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
@@ -97,14 +97,25 @@ function usageTokens(value) {
 }
 
 // Collect every agents/<id>/wire.jsonl under sessions/wd_<...>/session_<...>/.
-function findKimiCodeWireFiles(baseDir) {
+// `failures` collects read errors on paths that exist: an absent home is a
+// normal empty result, but an existing-and-unreadable one must surface as a
+// skip (see parseCurrentKimiRoots) so sync.js cannot prune that source's state.
+function findKimiCodeWireFiles(baseDir, failures) {
   const results = [];
-  if (!existsSync(baseDir)) return results;
+  let baseStat;
+  try {
+    baseStat = statSync(baseDir);
+  } catch (err) {
+    if (err.code !== 'ENOENT') failures.push({ path: baseDir, code: err.code || err.message });
+    return results;
+  }
+  if (!baseStat.isDirectory()) return results;
 
   let workDirs;
   try {
     workDirs = readdirSync(baseDir, { withFileTypes: true });
-  } catch {
+  } catch (err) {
+    failures.push({ path: baseDir, code: err.code || err.message });
     return results;
   }
 
@@ -116,7 +127,8 @@ function findKimiCodeWireFiles(baseDir) {
     let sessions;
     try {
       sessions = readdirSync(workDirPath, { withFileTypes: true });
-    } catch {
+    } catch (err) {
+      if (err.code !== 'ENOENT') failures.push({ path: workDirPath, code: err.code || err.message });
       continue;
     }
 
@@ -128,7 +140,10 @@ function findKimiCodeWireFiles(baseDir) {
       let agents;
       try {
         agents = readdirSync(agentsDir, { withFileTypes: true });
-      } catch {
+      } catch (err) {
+        // A missing agents/ directory is a normal empty session; any other
+        // error means data we would otherwise have collected is unreadable.
+        if (err.code !== 'ENOENT') failures.push({ path: agentsDir, code: err.code || err.message });
         continue;
       }
 
@@ -149,12 +164,12 @@ function findKimiCodeWireFiles(baseDir) {
  * Two roots can resolve to the same store (symlink, relocated home), so the
  * same physical wire file is returned once.
  */
-function findKimiCodeWireFilesInAllRoots() {
+function findKimiCodeWireFilesInAllRoots(roots, failures) {
   const results = [];
   const seen = new Set();
-  for (const root of resolveKimiCodeRoots()) {
+  for (const root of roots) {
     const sessionIndex = loadSessionIndex(join(root, 'session_index.jsonl'));
-    for (const { wireFile, sessionDir, bucketProject } of findKimiCodeWireFiles(join(root, 'sessions'))) {
+    for (const { wireFile, sessionDir, bucketProject } of findKimiCodeWireFiles(join(root, 'sessions'), failures)) {
       let identity = wireFile;
       try { identity = realpathSync(wireFile); } catch { /* keep the literal path */ }
       if (seen.has(identity)) continue;
@@ -165,18 +180,48 @@ function findKimiCodeWireFilesInAllRoots() {
   return results;
 }
 
-function parseKimiCode() {
-  const wireFiles = findKimiCodeWireFilesInAllRoots();
-  if (wireFiles.length === 0) return null;
+/** Shared current wire reader; Kiki uses the same per-agent delta protocol. */
+export function parseCurrentKimiRoots(roots, {
+  source = 'kimi-code',
+  normalizeModel = model => model || 'unknown',
+  deduplicateCopies = false,
+} = {}) {
+  const failures = [];
+  const wireFiles = findKimiCodeWireFilesInAllRoots(roots, failures);
+  if (wireFiles.length === 0 && failures.length === 0) return null;
 
   const entries = [];
   const sessionEvents = [];
-
-  for (const { wireFile, sessionDir, project } of wireFiles) {
+  const seenRecords = new Set();
+  const logicalSessions = new Map();
+
+  for (const file of wireFiles) {
+    const { wireFile } = file;
+    let { sessionDir, project } = file;
+    const sessionId = basename(sessionDir);
+    const agentId = basename(join(wireFile, '..'));
+    if (deduplicateCopies) {
+      // Copied homes retain session/agent directory ids. Keep first-copy
+      // attribution and merge exact accounting/timing records, not whole files.
+      if (!logicalSessions.has(sessionId)) logicalSessions.set(sessionId, { sessionDir, project });
+      ({ sessionDir, project } = logicalSessions.get(sessionId));
+    }
+    const occurrences = new Map();
+    const copied = fields => {
+      if (!deduplicateCopies) return false;
+      const fingerprint = JSON.stringify([sessionId, agentId, ...fields]);
+      const occurrence = (occurrences.get(fingerprint) || 0) + 1;
+      occurrences.set(fingerprint, occurrence);
+      const key = JSON.stringify([fingerprint, occurrence]);
+      if (seenRecords.has(key)) return true;
+      seenRecords.add(key);
+      return false;
+    };
     let content;
     try {
       content = readFileSync(wireFile, 'utf-8');
-    } catch {
+    } catch (err) {
+      failures.push({ path: wireFile, code: err.code || err.message });
       continue;
     }
 
@@ -200,8 +245,8 @@ function parseKimiCode() {
       // 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' });
+        if (tsValid && !copied([type, time, evt.turnId, evt.origin?.kind])) {
+          sessionEvents.push({ sessionId: sessionDir, source, project, timestamp: ts, role: 'user' });
         }
         continue;
       }
@@ -224,10 +269,15 @@ function parseKimiCode() {
       const outputTokens = usageTokens(usage.output);
       const cachedInputTokens = usageTokens(usage.inputCacheRead);
       if (!inputTokens && !outputTokens && !cachedInputTokens) continue;
+      // Wire records have no request UUID. Match exact allow-listed payloads
+      // only across copies of the same session/agent, retaining occurrence
+      // counts so identical real calls within one wire are never collapsed.
+      if (copied([type, time, evt.model, evt.usageScope, evt.turnId,
+        usage.inputOther, usage.inputCacheRead, usage.inputCacheCreation, usage.output])) continue;
 
       entries.push({
-        source: 'kimi-code',
-        model: evt.model || 'unknown',
+        source,
+        model: normalizeModel(evt.model),
         project,
         timestamp: ts,
         inputTokens,
@@ -238,11 +288,19 @@ 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.
-      sessionEvents.push({ sessionId: sessionDir, source: 'kimi-code', project, timestamp: ts, role: 'assistant' });
+      sessionEvents.push({ sessionId: sessionDir, source, project, timestamp: ts, role: 'assistant' });
     }
   }
 
-  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+  const result = { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+  if (failures.length > 0) {
+    // A read failure must never look like an empty success: sync.js would then
+    // mark the source ok and prune its incremental state, forcing a full
+    // re-upload of untouched history. Wording matches the parser conventions.
+    result.skipped = true;
+    result.warnings = failures.map(({ path, code }) => `${source}: 无法读取 ${path}: ${code}`);
+  }
+  return result;
 }
 
 // ---------------------------------------------------------------------------
@@ -432,10 +490,17 @@ export async function parse() {
   // Always parse both stores and merge (see the header comment): legacy usage
   // is never carried into ~/.kimi-code by `kimi migrate`, so a migrated user's
   // history exists only in ~/.kimi.
-  const current = parseKimiCode();
+  const current = parseCurrentKimiRoots(resolveKimiCodeRoots());
   const legacy = parseLegacyKimi();
-  return {
+  const result = {
     buckets: [...(current?.buckets ?? []), ...legacy.buckets],
     sessions: [...(current?.sessions ?? []), ...legacy.sessions],
   };
+  // A current-home read failure must protect this source's incremental state;
+  // legacy buckets that did parse may still upload, like other partial parsers.
+  if (current?.skipped) {
+    result.skipped = true;
+    result.warnings = current.warnings ?? [];
+  }
+  return result;
 }

package/src/parsers/mcode.js

@@ -6,7 +6,7 @@ import {
   isSqliteUnavailableError,
   sqliteUnavailableError,
 } from './sqlite.js';
-import { getMcodeDbPath } from '../tools.js';
+import { getMcodeDbPath, getMcodeDbPaths } from '../tools.js';
 
 const SOURCE = 'mcode';
 
@@ -47,7 +47,8 @@ const USAGE_SQL = `
 /**
  * Resolve the mcode runtime-state SQLite database. Mirrors the precedence used
  * by sibling tools (MiMoCode, DimAgent): explicit env var wins, then a
- * tool-specific HOME, then the default layout.
+ * tool-specific HOME (MCODE_HOME), then the mcode CLI's own relocation
+ * variables (MINIMAX_DATA_DIR / MAVIS_DATA_DIR), then the default layout.
  *
  * Defaults to `<homedir()>/.minimax/v2/sqlite/runtime-state.sqlite`, which is
  * where the mcode CLI keeps its WAL database on macOS / Linux.
@@ -56,6 +57,16 @@ export function resolveMcodeDbPath(env = process.env) {
   return getMcodeDbPath(env);
 }
 
+/**
+ * Every mcode store worth reading: the resolved default above, plus a
+ * `~/.minimax-<profile>` per active profile, the pre-npm `~/.minimax-code`
+ * and the pre-rename `~/.mavis` homes (and their profiles) when they hold a
+ * runtime-state database.
+ */
+export function resolveMcodeDbPaths(env = process.env, home) {
+  return getMcodeDbPaths(env, home);
+}
+
 /**
  * Token count (ms vs seconds). The mcode runtime writes ts as integer
  * milliseconds — confirmed against the live schema (`typeof(ts)=integer`,
@@ -89,92 +100,116 @@ function dbHasColumns(dbPath, table, columns) {
 }
 
 export async function parse() {
-  const dbPath = resolveMcodeDbPath();
-  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
-
-  // Schema guard: every allow-listed column must exist. If the mcode
-  // runtime ever renames / drops a column, fail soft (skipped) so the
-  // incremental sync keeps the last good upload state for this source.
-  let schemaOk;
-  try {
-    schemaOk =
-      dbHasColumns(dbPath, 'local_runtime_token_usage', TOKEN_COLUMNS) &&
-      dbHasColumns(dbPath, 'local_runtime_sessions', SESSION_COLUMNS);
-  } catch (err) {
-    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
-    return { buckets: [], sessions: [], skipped: true };
-  }
-  if (!schemaOk) {
-    return { buckets: [], sessions: [], skipped: true };
-  }
-
-  // Read tokens and session project metadata from one statement/snapshot.
-  let usageRows;
-  try {
-    usageRows = queryDbJsonSnapshotOnLock(dbPath, USAGE_SQL, {
-      tempPrefix: 'vibe-usage-mcode',
-    });
-  } catch (err) {
-    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
-    return { buckets: [], sessions: [], skipped: true };
-  }
+  const dbPaths = getMcodeDbPaths();
+  // The first store that exists is the one the running CLI would use; schema
+  // or read failures there keep the fail-soft contract below. Later stores are
+  // best-effort extras (profiles, pre-npm / pre-rename homes) and a broken one
+  // must not suppress the live store.
+  const primary = dbPaths.find(path => existsSync(path));
 
   const entries = [];
+  const warnings = [];
+  // mcode's own migration can COPY a relocated legacy tree into ~/.minimax, so
+  // both copies exist. Collapse rows that reappear unchanged in a later store;
+  // duplicates inside one store are left alone — there they are the ledger.
+  const seenAcrossStores = new Set();
+
+  for (const dbPath of dbPaths) {
+    if (!existsSync(dbPath)) continue;
+    const isPrimary = dbPath === primary;
+
+    // Schema guard: every allow-listed column must exist. If the mcode
+    // runtime ever renames / drops a column, fail soft (skipped) so the
+    // incremental sync keeps the last good upload state for this source.
+    let schemaOk;
+    try {
+      schemaOk =
+        dbHasColumns(dbPath, 'local_runtime_token_usage', TOKEN_COLUMNS) &&
+        dbHasColumns(dbPath, 'local_runtime_sessions', SESSION_COLUMNS);
+    } catch (err) {
+      if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
+      schemaOk = false;
+    }
+    if (!schemaOk) {
+      if (isPrimary) return { buckets: [], sessions: [], skipped: true };
+      warnings.push(`MiniMax Code: 跳过结构不兼容的数据库 ${dbPath}`);
+      continue;
+    }
 
-  for (const row of usageRows) {
-    const sessionId = row.session_id != null ? String(row.session_id) : '';
-    if (!sessionId) continue;
-    const ts = tsToDate(row.ts);
-    if (!ts) continue;
-
-    // MCode stores output and reasoning as separate counters. Its own
-    // summary code computes total = input + output + reasoning, so do not
-    // subtract reasoning from output here.
-    const inputRaw = toNonNegative(row.input_tokens);
-    const cacheWrite = toNonNegative(row.cache_write_tokens);
-    const outputRaw = toNonNegative(row.output_tokens);
-    const reasoningRaw = toNonNegative(row.reasoning_tokens);
-    const cacheRead = toNonNegative(row.cache_read_tokens);
-
-    const inputTokens = inputRaw + cacheWrite;
-    const reasoningOutputTokens = reasoningRaw;
-    const outputTokens = outputRaw;
-    const cachedInputTokens = cacheRead;
-
-    if (
-      inputTokens +
-        outputTokens +
-        cachedInputTokens +
-        reasoningOutputTokens ===
-      0
-    ) {
+    // Read tokens and session project metadata from one statement/snapshot.
+    let usageRows;
+    try {
+      usageRows = queryDbJsonSnapshotOnLock(dbPath, USAGE_SQL, {
+        tempPrefix: 'vibe-usage-mcode',
+      });
+    } catch (err) {
+      if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('mcode');
+      if (isPrimary) return { buckets: [], sessions: [], skipped: true };
+      warnings.push(`MiniMax Code: 无法读取 ${dbPath}，已跳过: ${err.message}`);
       continue;
     }
 
-    const projectPath = row.project_workspace_dir || row.workspace_dir;
-    const project = projectPath ? projectFromPath(String(projectPath)) : 'unknown';
-    const model = row.model != null && String(row.model).trim()
-      ? String(row.model).trim()
-      : 'unknown';
-
-    entries.push({
-      source: SOURCE,
-      model,
-      project,
-      timestamp: ts,
-      inputTokens,
-      outputTokens,
-      cachedInputTokens,
-      reasoningOutputTokens,
-    });
+    const identitiesInStore = new Set();
+    for (const row of usageRows) {
+      // Identity covers every selected column; only a byte-identical ledger
+      // row can collapse, and only against an earlier store.
+      const identity = JSON.stringify(row);
+      if (seenAcrossStores.has(identity)) continue;
+      identitiesInStore.add(identity);
+
+      const sessionId = row.session_id != null ? String(row.session_id) : '';
+      if (!sessionId) continue;
+      const ts = tsToDate(row.ts);
+      if (!ts) continue;
+
+      // MCode stores output and reasoning as separate counters. Its own
+      // summary code computes total = input + output + reasoning, so do not
+      // subtract reasoning from output here.
+      const inputRaw = toNonNegative(row.input_tokens);
+      const cacheWrite = toNonNegative(row.cache_write_tokens);
+      const outputRaw = toNonNegative(row.output_tokens);
+      const reasoningRaw = toNonNegative(row.reasoning_tokens);
+      const cacheRead = toNonNegative(row.cache_read_tokens);
+
+      const inputTokens = inputRaw + cacheWrite;
+      const reasoningOutputTokens = reasoningRaw;
+      const outputTokens = outputRaw;
+      const cachedInputTokens = cacheRead;
+
+      if (
+        inputTokens +
+          outputTokens +
+          cachedInputTokens +
+          reasoningOutputTokens ===
+        0
+      ) {
+        continue;
+      }
+
+      const projectPath = row.project_workspace_dir || row.workspace_dir;
+      const project = projectPath ? projectFromPath(String(projectPath)) : 'unknown';
+      const model = row.model != null && String(row.model).trim()
+        ? String(row.model).trim()
+        : 'unknown';
+
+      entries.push({
+        source: SOURCE,
+        model,
+        project,
+        timestamp: ts,
+        inputTokens,
+        outputTokens,
+        cachedInputTokens,
+        reasoningOutputTokens,
+      });
+    }
+    for (const identity of identitiesInStore) seenAcrossStores.add(identity);
   }
 
   return {
     buckets: aggregateToBuckets(entries),
-    // The token ledger contains assistant usage rows only. Reconstructing
-    // user prompts would require reading message payloads, which this parser
-    // deliberately never selects, so mcode emits buckets only like Alma.
     sessions: [],
+    ...(warnings.length > 0 ? { warnings } : {}),
   };
 }
 

package/src/sync.js

@@ -10,6 +10,7 @@ import { parsers } from './parsers/index.js';
 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';
 
 const BATCH_SIZE = 100;
@@ -297,10 +298,55 @@ export async function runSync({
   if (state.identityChanged && !quiet) {
     console.log(dim('检测到上传账号已更换，本次全量重传本地历史'));
   }
+  let migration;
+  try {
+    migration = planKikiMigration(allBuckets, allSessions, state, config.kikiStartAt);
+  } catch (err) {
+    process.stderr.write(`${dim(`  kiki: ${err.message}`)}\n`);
+    migration = planKikiMigration(allBuckets, allSessions, state);
+    migration.buckets = migration.buckets.filter(b => b.source !== 'kiki');
+    migration.sessions = migration.sessions.filter(s => s.source !== 'kiki');
+    // The invalid cut drops every Kiki row regardless of what the fallback
+    // plan did; report that as withheld so the diagnostic is not silent.
+    const droppedBuckets = allBuckets.filter(b => b.source === 'kiki');
+    const droppedSessions = allSessions.filter(s => s.source === 'kiki');
+    const droppedStarts = droppedBuckets.map(b => Date.parse(b.bucketStart)).filter(Number.isFinite);
+    migration.withheld = {
+      buckets: droppedBuckets.length,
+      sessions: droppedSessions.length,
+      totalTokens: droppedBuckets.reduce((sum, b) => sum + (Number(b.totalTokens) || 0), 0),
+      earliest: droppedStarts.length > 0 ? new Date(Math.min(...droppedStarts)).toISOString() : null,
+      latest: droppedStarts.length > 0 ? new Date(Math.max(...droppedStarts)).toISOString() : null,
+    };
+    okSources.delete('kiki');
+  }
+  if (migration.blocked) {
+    okSources.delete('kiki');
+    process.stderr.write(`${dim('  kiki: 历史与 kimi-code 同步记录重叠，暂停 Kiki 上传以避免双计。请保留 state.json，停用旧兼容采集器并按 README 迁移，显式设置 config set kikiStartAt <UTC半小时切点>。')}\n`);
+  }
+  // A cut (or the guard) withholds real Kiki history and freezes legacy
+  // kimi-code rows; neither is silent, even in quiet/daemon runs. The user
+  // learns the counts and time range, and both ways out: set a verified cut, or
+  // clear the guard when they know no compatibility collector ever ran.
+  const withheld = migration.withheld;
+  if (withheld.buckets > 0 || withheld.sessions > 0
+    || migration.frozenBuckets > 0 || migration.frozenSessions > 0) {
+    const parts = [];
+    if (withheld.buckets > 0 || withheld.sessions > 0) {
+      const range = withheld.earliest ? `，时间范围 ${withheld.earliest} 至 ${withheld.latest}` : '';
+      parts.push(`本次未上传 ${withheld.buckets} 个桶 / ${withheld.sessions} 个会话（${withheld.totalTokens} tokens${range}）`);
+    }
+    if (migration.frozenBuckets > 0 || migration.frozenSessions > 0) {
+      parts.push(`已冻结 ${migration.frozenBuckets} 个旧 kimi-code 桶 / ${migration.frozenSessions} 个会话，其增长不再上传（服务端记录会停留在旧值）`);
+    }
+    process.stderr.write(`${dim(`  kiki: ${parts.join('；')}。若这段历史应归入 Kiki，请设置切点 config set kikiStartAt <UTC半小时切点>；若确认从未运行过兼容采集器，可用 config set kikiStartAt none 解除保护。`)}\n`);
+  }
+  allBuckets = migration.buckets;
+  const uploadSessions = migration.sessions;
   const changedBuckets = [];
   const changedSessions = [];
-  const liveBucketKeys = new Set();
-  const liveSessionKeys = new Set();
+  const liveBucketKeys = new Set(migration.preserveBuckets);
+  const liveSessionKeys = new Set(migration.preserveSessions);
   // key -> hash, committed to state only after the owning batch's upload
   // succeeds (a failed batch re-sends next sync — no silent gap).
   const pendingBucketState = new Map();
@@ -310,15 +356,15 @@ export async function runSync({
     const key = bucketKey(b);
     const h = bucketHash(b);
     liveBucketKeys.add(key);
-    if (state.buckets[key] === h) continue;
+    if (migration.preserveBuckets.has(key) || state.buckets[key] === h) continue;
     changedBuckets.push(b);
     pendingBucketState.set(key, h);
   }
-  for (const s of allSessions) {
+  for (const s of uploadSessions) {
     const key = sessionKey(s);
     const h = sessionHash(s);
     liveSessionKeys.add(key);
-    if (state.sessions[key] === h) continue;
+    if (migration.preserveSessions.has(key) || state.sessions[key] === h) continue;
     changedSessions.push(s);
     pendingSessionState.set(key, h);
   }

package/src/tools.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { delimiter, dirname, isAbsolute, join, posix, resolve, win32 } from 'node:path';
 import { homedir } from 'node:os';
 import { getOpenCodeStores } from './opencode-roots.js';
@@ -10,6 +10,7 @@ import {
   discoverCodexHomes,
   extraRootList,
   grokSessionsDir,
+  normalizeExtraRoot,
 } from './extra-roots.js';
 import { findClineDataDirs } from './cline-roots.js';
 import { findCodeartsAgentDbs, resolveCodeartsAgentRoots } from './codearts-roots.js';
@@ -17,6 +18,7 @@ import { findColaDataDirs, getColaSessionsDir } from './cola-roots.js';
 import { findCraftDataDirs } from './craft-roots.js';
 import { findHermesDataDirs, getHermesHome } from './hermes-roots.js';
 import { findKimiCodeDataDirs } from './kimi-roots.js';
+import { findKikiDataDirs, KIKI_SOURCE_ID, resolveKikiRoots } from './kiki-roots.js';
 import { findOmpDataDirs, findPiDataDirs } from './pi-roots.js';
 import { findQoderDataDirs, getQoderProjectsDir } from './qoder-roots.js';
 import { findWorkbuddyDataDirs } from './workbuddy-roots.js';
@@ -176,15 +178,75 @@ export function findDshDataDirs() {
   return [getDshSessionsDir()].filter(existsSync);
 }
 
-/** mcode runtime database: VIBE_USAGE_MCODE_DB wins, then MCODE_HOME, then ~/.minimax. */
+const MCODE_DB_RELATIVE = join('v2', 'sqlite', 'runtime-state.sqlite');
+
+// Data-root variables the mcode CLI itself resolves, in its own precedence.
+// MCODE_HOME stays first as vibe-usage's pre-existing fixture override, then
+// the two public relocation variables from the mcode README.
+const MCODE_ROOT_ENV = ['MCODE_HOME', 'MINIMAX_DATA_DIR', 'MAVIS_DATA_DIR'];
+
+function mcodeRootFromEnv(env) {
+  for (const key of MCODE_ROOT_ENV) {
+    const value = env[key]?.trim();
+    if (!value) continue;
+    if (!isAbsolute(value)) {
+      throw new Error(`${key} must be an absolute path, got: ${JSON.stringify(value)}`);
+    }
+    return value;
+  }
+  return null;
+}
+
+/** mcode runtime database: VIBE_USAGE_MCODE_DB wins, then MCODE_HOME / MINIMAX_DATA_DIR / MAVIS_DATA_DIR, then ~/.minimax. */
 export function getMcodeDbPath(env = process.env, home = homedir()) {
   const override = env.VIBE_USAGE_MCODE_DB?.trim();
   if (override) return isAbsolute(override) ? override : resolve(override);
-  if (env.MCODE_HOME && !isAbsolute(env.MCODE_HOME)) {
-    throw new Error(`MCODE_HOME must be an absolute path, got: ${JSON.stringify(env.MCODE_HOME)}`);
+  const root = mcodeRootFromEnv(env) || join(home, '.minimax');
+  return join(root, MCODE_DB_RELATIVE);
+}
+
+/**
+ * Every mcode runtime database worth parsing.
+ *
+ * The mcode CLI relocates its whole data root with MINIMAX_DATA_DIR /
+ * MAVIS_DATA_DIR, scopes it to ~/.minimax-<profile> when a profile is active,
+ * and earlier source builds kept user data at ~/.minimax-code; the pre-rename
+ * home (~/.mavis) stays readable through the CLI's own compat link. Reading
+ * only ~/.minimax silently misses every session written in those layouts.
+ *
+ * Explicit roots keep returning their single unresolved path so a missing
+ * file still yields an empty result; the default layout only returns stores
+ * that exist, deduplicated by physical file so a compat symlink cannot make
+ * the same ledger count twice.
+ */
+export function getMcodeDbPaths(env = process.env, home = homedir()) {
+  if (env.VIBE_USAGE_MCODE_DB?.trim() || mcodeRootFromEnv(env)) return [getMcodeDbPath(env, home)];
+  const candidates = [
+    join(home, '.minimax'),
+    join(home, '.minimax-code'),
+    join(home, '.mavis'),
+  ];
+  try {
+    const profiles = readdirSync(home, { withFileTypes: true })
+      .filter(entry => entry.isDirectory() && /^\.(?:minimax|mavis)-.+$/.test(entry.name))
+      .map(entry => join(home, entry.name))
+      .sort();
+    candidates.push(...profiles);
+  } catch {
+    // Unreadable home directory: fall back to the default layout below.
+  }
+  const paths = [];
+  const seen = new Set();
+  for (const dir of candidates) {
+    const dbPath = join(dir, MCODE_DB_RELATIVE);
+    if (!existsSync(dbPath)) continue;
+    let identity = dbPath;
+    try { identity = realpathSync(dbPath); } catch { /* keep the literal path */ }
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    paths.push(dbPath);
   }
-  const root = env.MCODE_HOME || join(home, '.minimax');
-  return join(root, 'v2', 'sqlite', 'runtime-state.sqlite');
+  return paths;
 }
 
 // Devin (CLI and Desktop share one agent backend) keeps all sessions in a
@@ -405,11 +467,15 @@ export const TOOLS = [
     id: 'qwen-code',
     dataDir: join(homedir(), '.qwen', 'tmp'),
   },
+  {
+    name: 'Kiki',
+    id: KIKI_SOURCE_ID,
+    dataDir: join(resolveKikiRoots()[0], 'sessions'),
+    detectDataDirs: findKikiDataDirs,
+  },
   {
     name: 'Kimi Code',
     id: 'kimi-code',
-    // Current layout is ~/.kimi-code/sessions; ~/.kimi/sessions is the legacy
-    // path. The parser reads whichever exists (preferring ~/.kimi-code).
     dataDir: join(homedir(), '.kimi-code', 'sessions'),
     detectDataDirs: findKimiCodeDataDirs,
   },
@@ -417,7 +483,7 @@ export const TOOLS = [
     name: 'MiniMax Code',
     id: 'mcode',
     dataDir: join(homedir(), '.minimax', 'v2', 'sqlite', 'runtime-state.sqlite'),
-    detectDataDirs: () => [getMcodeDbPath()].filter(existsSync),
+    detectDataDirs: () => getMcodeDbPaths().filter(existsSync),
   },
   {
     name: 'MiMoCode',
@@ -460,7 +526,9 @@ export const TOOLS = [
     name: 'Hermes',
     id: 'hermes',
     dataDir: join(getHermesHome(), 'state.db'),
-    detectDataDirs: findHermesDataDirs,
+    detectDataDirs: ({ extraRoots } = {}) => findHermesDataDirs(
+      extraRootList(extraRoots?.hermes).map(root => normalizeExtraRoot(root)),
+    ),
   },
   {
     name: 'Kiro',