@geoqiao/pi-usage 0.1.0

package/vendor/vibe-usage/src/parsers/hermes.js

@@ -0,0 +1,123 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
+
+const HERMES_HOME = process.env.HERMES_HOME || join(homedir(), '.hermes');
+
+/**
+ * Parse Hermes Agent usage data from its SQLite databases.
+ *
+ * Hermes supports multiple profiles — the default profile lives at
+ * ~/.hermes/state.db, while named profiles live at ~/.hermes/profiles/<name>/state.db.
+ * Each profile is an independent HERMES_HOME 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() {
+  const dbs = discoverDbPaths(HERMES_HOME);
+  if (dbs.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const { path: dbPath, profile } of dbs) {
+    let sessionRows;
+    try {
+      sessionRows = queryDb(dbPath, `SELECT
+        id,
+        model,
+        started_at as startedAt,
+        input_tokens as inputTokens,
+        output_tokens as outputTokens,
+        cache_read_tokens as cacheReadTokens,
+        reasoning_tokens as reasoningTokens
+        FROM sessions
+        WHERE input_tokens > 0 OR output_tokens > 0`);
+    } catch (err) {
+      if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('Hermes');
+      throw err;
+    }
+
+    for (const row of sessionRows) {
+      // started_at is a Unix timestamp (float)
+      const timestamp = new Date(row.startedAt * 1000);
+      if (isNaN(timestamp.getTime())) continue;
+
+      // Hermes stores input_tokens exclusive of cache (Anthropic-style semantics)
+      entries.push({
+        source: 'hermes',
+        model: row.model || 'unknown',
+        project: profile,
+        timestamp,
+        inputTokens: row.inputTokens || 0,
+        outputTokens: row.outputTokens || 0,
+        cachedInputTokens: row.cacheReadTokens || 0,
+        reasoningOutputTokens: row.reasoningTokens || 0,
+      });
+    }
+
+    let messageRows;
+    try {
+      messageRows = queryDb(dbPath, `SELECT
+        session_id as sessionId,
+        role,
+        timestamp
+        FROM messages
+        WHERE role IN ('user', 'assistant')
+        ORDER BY timestamp`);
+    } catch {
+      // Messages query failed for this profile — skip its session events
+      continue;
+    }
+
+    for (const row of messageRows) {
+      const timestamp = new Date(row.timestamp * 1000);
+      if (isNaN(timestamp.getTime())) continue;
+
+      sessionEvents.push({
+        sessionId: row.sessionId,
+        source: 'hermes',
+        project: profile,
+        timestamp,
+        role: row.role === 'user' ? 'user' : 'assistant',
+      });
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}
+
+function discoverDbPaths(home) {
+  const dbs = [];
+
+  const defaultDb = join(home, 'state.db');
+  if (existsSync(defaultDb)) dbs.push({ path: defaultDb, profile: 'default' });
+
+  const profilesDir = join(home, 'profiles');
+  if (existsSync(profilesDir)) {
+    let entries;
+    try {
+      entries = readdirSync(profilesDir, { withFileTypes: true });
+    } catch {
+      return dbs;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const profileDb = join(profilesDir, entry.name, 'state.db');
+      try {
+        if (statSync(profileDb).isFile()) dbs.push({ path: profileDb, profile: entry.name });
+      } catch {
+        // missing or unreadable — skip
+      }
+    }
+  }
+
+  return dbs;
+}
+
+function queryDb(dbPath, sql) {
+  return queryDbJson(dbPath, sql);
+}

package/vendor/vibe-usage/src/parsers/index.js

@@ -0,0 +1,61 @@
+import { parse as parseClaudeCode } from './claude-code.js';
+import { parse as parseCline } from './cline.js';
+import { parse as parseCodex } from './codex.js';
+import { parse as parseCopilotCli } from './copilot-cli.js';
+import { parse as parseCraftAgent } from './craft-agent.js';
+import { parse as parseCursor } from './cursor.js';
+import { parse as parseDimAgent } from './dimagent.js';
+import { parse as parseRooCode } from './roo-code.js';
+import { parse as parseGeminiCli } from './gemini-cli.js';
+import { parse as parseGrok } from './grok.js';
+import { parse as parseOpencode } from './opencode.js';
+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 parseAmp } from './amp.js';
+import { parse as parseAlma } from './alma.js';
+import { parse as parseDroid } from './droid.js';
+import { parse as parseDsh } from './dsh.js';
+import { parse as parseAntigravity } from './antigravity.js';
+import { parse as parseHermes } from './hermes.js';
+import { parse as parseKiro } from './kiro.js';
+import { parse as parseMcode } from './mcode.js';
+import { parse as parseMimocode } from './mimocode.js';
+import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
+import { parse as parseZcode } from './zcode.js';
+import { parse as parseTraeCli } from './trae-cli.js';
+import { parse as parseWorkbuddy } from './workbuddy.js';
+
+export const parsers = {
+  'claude-code': parseClaudeCode,
+  'codex': parseCodex,
+  'grok': parseGrok,
+  'copilot-cli': parseCopilotCli,
+  'craft-agent': parseCraftAgent,
+  'cursor': parseCursor,
+  'dimagent': parseDimAgent,
+  'gemini-cli': parseGeminiCli,
+  'opencode': parseOpencode,
+  'openclaw': parseOpenclaw,
+  'omp': parseOmp,
+  'pi-coding-agent': parsePiCodingAgent,
+  'qwen-code': parseQwenCode,
+  'kimi-code': parseKimiCode,
+  'amp': parseAmp,
+  'alma': parseAlma,
+  'droid': parseDroid,
+  'dsh': parseDsh,
+  'antigravity': parseAntigravity,
+  'trae-cli': parseTraeCli,
+  'hermes': parseHermes,
+  'kiro': parseKiro,
+  'mcode': parseMcode,
+  'mimocode': parseMimocode,
+  'cline': parseCline,
+  'roo-code': parseRooCode,
+  'workbuddy': parseWorkbuddy,
+  'zcode': parseZcode,
+};
+
+export { roundToHalfHour, aggregateToBuckets, extractSessions } from './aggregate.js';

package/vendor/vibe-usage/src/parsers/kimi-code.js

@@ -0,0 +1,467 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { mergeRequestTypes } from '../../../../src/analytics.js';
+
+/**
+ * Kimi Code CLI parser. MoonshotAI/kimi-cli (a.k.a. "Kimi Code").
+ *
+ * Two on-disk layouts are supported:
+ *
+ * 1. Current ("~/.kimi-code", protocol >= 1.4). Sessions live at
+ *      ~/.kimi-code/sessions/wd_<slug>_<hash>/session_<id>/agents/<agentId>/wire.jsonl
+ *    Each line is a self-describing event with a top-level integer-ms `time`:
+ *      {"type":"usage.record","model":"kimi-code/kimi-for-coding",
+ *       "usage":{"inputOther","output","inputCacheRead","inputCacheCreation"},
+ *       "usageScope":"turn","time":<ms>}
+ *    `usage.record` events are per-step deltas (one per assistant step), so they
+ *    sum to the session total. The model name rides on each record — no config
+ *    lookup needed. User turns are `turn.prompt` with origin.kind === "user".
+ *    The real working directory per session is recorded in
+ *      ~/.kimi-code/session_index.jsonl  -> {sessionId, sessionDir, workDir}
+ *    which gives an accurate project name (last path component of workDir).
+ *
+ * 2. Legacy ("~/.kimi", protocol 1.1 / 1.9). Sessions live at
+ *      ~/.kimi/sessions/<md5(workdir)>/<session-id>/wire.jsonl
+ *    with a different envelope (StatusUpdate.payload.token_usage, float-second
+ *    `timestamp`) and the model in ~/.kimi/config.toml. Kept for users who have
+ *    not migrated; see parseLegacyKimi() below.
+ *
+ * Both stores are always parsed and merged. `kimi migrate` translates legacy
+ * context.jsonl into the new wire format but DROPS the `_usage` records, so
+ * historical token usage only ever exists in the legacy store — parsing both
+ * cannot double-count, while skipping legacy whenever ~/.kimi-code has any
+ * session silently loses a migrated user's entire history.
+ */
+
+// ---------------------------------------------------------------------------
+// Current format: ~/.kimi-code
+// ---------------------------------------------------------------------------
+
+// VIBE_USAGE_KIMI_CODE_DIR overrides the root (test hook). Otherwise resolve
+// the data root the same way the CLI itself does: $KIMI_CODE_HOME, then
+// ~/.kimi-code. Ignoring KIMI_CODE_HOME means users with a custom home get
+// zero usage parsed.
+const KIMI_CODE_DIR = process.env.VIBE_USAGE_KIMI_CODE_DIR?.trim()
+  || process.env.KIMI_CODE_HOME?.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');
+
+function projectNameFromPath(path) {
+  if (typeof path !== 'string' || !path) return null;
+  return basename(path.replace(/[/\\]+$/, '')) || path;
+}
+
+/**
+ * Map each session directory (absolute path) to a project name, read from
+ * ~/.kimi-code/session_index.jsonl. Falls back gracefully if the file is
+ * missing or malformed — callers default to the wd_ bucket name.
+ */
+function loadSessionIndex() {
+  const map = new Map();
+  if (!existsSync(KIMI_CODE_SESSION_INDEX)) return map;
+
+  let content;
+  try {
+    content = readFileSync(KIMI_CODE_SESSION_INDEX, 'utf-8');
+  } catch {
+    return map;
+  }
+
+  for (const line of content.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    const dir = entry?.sessionDir;
+    const project = projectNameFromPath(entry?.workDir);
+    if (typeof dir === 'string' && dir && project) map.set(dir, project);
+  }
+  return map;
+}
+
+// Strip the trailing _<hash> from a "wd_<slug>_<hash>" bucket name so the slug
+// can serve as a last-resort project label when session_index has no entry.
+function projectFromBucketName(name) {
+  const m = /^wd_(.+)_[0-9a-f]+$/.exec(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 = [];
+  if (!existsSync(baseDir)) return results;
+
+  let workDirs;
+  try {
+    workDirs = readdirSync(baseDir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+
+  for (const workDir of workDirs) {
+    if (!workDir.isDirectory()) continue;
+    const workDirPath = join(baseDir, workDir.name);
+    const bucketProject = projectFromBucketName(workDir.name);
+
+    let sessions;
+    try {
+      sessions = readdirSync(workDirPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const session of sessions) {
+      if (!session.isDirectory()) continue;
+      const sessionDir = join(workDirPath, session.name);
+      const agentsDir = join(sessionDir, 'agents');
+
+      let agents;
+      try {
+        agents = readdirSync(agentsDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+
+      for (const agent of agents) {
+        if (!agent.isDirectory()) continue;
+        const wireFile = join(agentsDir, agent.name, 'wire.jsonl');
+        if (existsSync(wireFile)) {
+          results.push({ wireFile, sessionDir, bucketProject });
+        }
+      }
+    }
+  }
+  return results;
+}
+
+// Current wire: step.end repeats the step.begin UUID and carries the exact
+// usage later emitted by usage.record. Scope alone is NOT request evidence.
+function currentStepEvidence(step, evt) {
+  const e = evt.type === 'context.append_loop_event' ? evt.event : null;
+  if (['turn.prompt', 'turn.cancel', 'full_compaction.begin', 'full_compaction.complete'].includes(evt.type)) return null;
+  if (!e || typeof e !== 'object' || typeof e.type !== 'string') return evt.type === 'context.append_loop_event' ? null : step;
+  if (['step.interrupted', 'step.retry'].includes(e.type)) return null;
+  if (e.type === 'step.begin') return { uuid: e.uuid, turnId: e.turnId, step: e.step, tool: false, invalid: !!step };
+  if (!step) return null;
+  if (['tool.call', 'content.part', 'step.end'].includes(e.type)) {
+    if (!step.uuid || e.turnId !== step.turnId || e.step !== step.step
+        || (e.type === 'step.end' ? e.uuid : e.stepUuid) !== step.uuid) step.invalid = true;
+  }
+  if (step.usage && ['tool.call', 'content.part'].includes(e.type)) step.invalid = true;
+  if (e.type === 'tool.call') step.tool = true;
+  if (e.type === 'step.end') {
+    step.usage = e.usage;
+    step.requestType = step.tool || e.finishReason === 'tool_use' ? 'tool'
+      : ['stop', 'end_turn'].includes(e.finishReason) ? 'non_tool' : 'other';
+  }
+  return step;
+}
+
+function parseKimiCode() {
+  const wireFiles = findKimiCodeWireFiles(KIMI_CODE_SESSIONS_DIR);
+  if (wireFiles.length === 0) return null;
+
+  const sessionIndex = loadSessionIndex();
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const { wireFile, sessionDir, bucketProject } of wireFiles) {
+    let content;
+    try {
+      content = readFileSync(wireFile, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const project = sessionIndex.get(sessionDir) || bucketProject || 'unknown';
+    let step = null;
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      let evt;
+      try { evt = JSON.parse(line); } catch { step = null; continue; }
+      if (!evt || typeof evt !== 'object') { step = null; continue; }
+      step = currentStepEvidence(step, evt);
+      const requestType = evt.type === 'usage.record' && evt.usageScope === 'turn' && step?.usage && evt.usage && !step.invalid
+        && ['inputOther', 'output', 'inputCacheRead', 'inputCacheCreation'].every(key => (step.usage[key] ?? 0) === (evt.usage[key] ?? 0))
+        ? step.requestType : 'other';
+      if (evt.type === 'usage.record') step = null;
+
+      const type = evt.type;
+      // 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;
+
+      // 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;
+
+      entries.push({
+        source: 'kimi-code',
+        model: evt.model || 'unknown',
+        requestType,
+        project,
+        timestamp: ts,
+        inputTokens,
+        outputTokens,
+        cachedInputTokens,
+        reasoningOutputTokens: 0,
+      });
+
+      // 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' });
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}
+
+// ---------------------------------------------------------------------------
+// Legacy format: ~/.kimi  (kept for users who haven't migrated to ~/.kimi-code)
+// ---------------------------------------------------------------------------
+
+// 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');
+
+function findLegacyWireFiles(baseDir) {
+  const results = [];
+  if (!existsSync(baseDir)) return results;
+
+  try {
+    for (const workDir of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!workDir.isDirectory()) continue;
+      const workDirPath = join(baseDir, workDir.name);
+
+      try {
+        for (const session of readdirSync(workDirPath, { withFileTypes: true })) {
+          if (!session.isDirectory()) continue;
+          const wireFile = join(workDirPath, session.name, 'wire.jsonl');
+          if (existsSync(wireFile)) {
+            results.push({ filePath: wireFile, workDirHash: workDir.name });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+
+function loadLegacyProjectMap() {
+  const map = new Map();
+  if (!existsSync(KIMI_WORKDIRS_JSON)) return map;
+
+  let config;
+  try {
+    config = JSON.parse(readFileSync(KIMI_WORKDIRS_JSON, 'utf-8'));
+  } catch {
+    return map;
+  }
+
+  if (Array.isArray(config.work_dirs)) {
+    for (const entry of config.work_dirs) {
+      const path = entry?.path;
+      if (typeof path !== 'string' || !path) continue;
+      const hash = createHash('md5').update(path).digest('hex');
+      map.set(hash, projectNameFromPath(path));
+    }
+  }
+
+  for (const key of ['workspaces', 'projects']) {
+    const obj = config[key];
+    if (!obj || typeof obj !== 'object') continue;
+    for (const [hash, info] of Object.entries(obj)) {
+      const path = typeof info === 'string' ? info : (info?.path || info?.dir);
+      if (typeof path === 'string' && path) map.set(hash, projectNameFromPath(path));
+    }
+  }
+
+  return map;
+}
+
+const TOML_MODEL_SECTION_RE = /^\s*\[models\.(?:"([^"]+)"|([A-Za-z0-9_-]+))\]/m;
+const TOML_DEFAULT_MODEL_RE = /^\s*default_model\s*=\s*["']([^"']+)["']/m;
+
+function loadLegacyModelFromConfig() {
+  if (!existsSync(KIMI_CONFIG_TOML)) return 'unknown';
+
+  let content;
+  try {
+    content = readFileSync(KIMI_CONFIG_TOML, 'utf-8');
+  } catch {
+    return 'unknown';
+  }
+
+  const defaultMatch = content.match(TOML_DEFAULT_MODEL_RE);
+  if (defaultMatch) return defaultMatch[1];
+
+  const sectionMatch = content.match(TOML_MODEL_SECTION_RE);
+  if (sectionMatch) return sectionMatch[1] || sectionMatch[2];
+
+  return 'unknown';
+}
+
+const LEGACY_USER_EVENT_TYPES = new Set(['TurnBegin', 'UserMessage', 'user_message', 'Input']);
+
+function parseLegacyKimi() {
+  const wireFiles = findLegacyWireFiles(KIMI_SESSIONS_DIR);
+  if (wireFiles.length === 0) return { buckets: [], sessions: [] };
+
+  const projectMap = loadLegacyProjectMap();
+  const defaultModel = loadLegacyModelFromConfig();
+  const entries = [];
+  const sessionEvents = [];
+  const seenMessageIds = new Map();
+
+  for (const { filePath, workDirHash } of wireFiles) {
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const project = projectMap.get(workDirHash) || workDirHash;
+    let currentModel = defaultModel;
+    let lastTimestamp = null;
+    let step = null;
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      let raw;
+      try { raw = JSON.parse(line); } catch { step = null; continue; }
+      if (!raw || typeof raw !== 'object') { step = null; continue; }
+
+      const envelope = raw.message || raw;
+      const type = envelope.type || raw.type;
+      const payload = envelope.payload || raw.payload;
+      if (['StepBegin', 'StepRetry', 'CompactionEnd'].includes(type)) step = { tool: false, content: false };
+      if (['TurnBegin', 'TurnEnd', 'StepInterrupted', 'CompactionBegin'].includes(type)) step = null;
+      if (step && type === 'ToolCall') step.tool = true;
+      if (step && type === 'ContentPart') step.content = true;
+      if (!payload) { step = null; continue; }
+
+      if (typeof raw.timestamp === 'number') {
+        lastTimestamp = raw.timestamp * 1000;
+      } else if (typeof payload.timestamp === 'number') {
+        lastTimestamp = payload.timestamp * 1000;
+      }
+      if (payload.model) currentModel = payload.model;
+
+      if (lastTimestamp) {
+        const evTs = new Date(lastTimestamp);
+        if (!isNaN(evTs.getTime())) {
+          sessionEvents.push({
+            sessionId: filePath,
+            source: 'kimi-code',
+            project,
+            timestamp: evTs,
+            role: LEGACY_USER_EVENT_TYPES.has(type) ? 'user' : 'assistant',
+          });
+        }
+      }
+
+      if (type !== 'StatusUpdate') continue;
+
+      const tokenUsage = payload.token_usage;
+      if (!tokenUsage) continue;
+
+      // StatusUpdate.token_usage is sent after kosong.step returns the full
+      // response, before waiting for tools. Retries/compaction reset evidence;
+      // nested SubagentEvent output never belongs to this assistant step.
+      const requestType = step?.tool ? 'tool' : step?.content ? 'non_tool' : 'other';
+      step = null;
+      if (!tokenUsage.input_other && !tokenUsage.output
+        && !tokenUsage.input_cache_read && !tokenUsage.input_cache_creation) continue;
+      const messageId = payload.message_id;
+      if (messageId && seenMessageIds.has(messageId)) {
+        const prior = seenMessageIds.get(messageId);
+        if (prior) prior.requestType = mergeRequestTypes(prior.requestType, requestType);
+        continue;
+      }
+      if (messageId) seenMessageIds.set(messageId, null);
+
+      // No valid timestamp → 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 (!lastTimestamp) continue;
+      const ts = new Date(lastTimestamp);
+      if (isNaN(ts.getTime())) continue;
+
+      entries.push({
+        source: 'kimi-code',
+        model: currentModel,
+        requestType,
+        project,
+        timestamp: ts,
+        // Cache creation is billed non-cached input, matching the current
+        // parser and the common bucket model used by the other parsers.
+        inputTokens: (tokenUsage.input_other || 0) + (tokenUsage.input_cache_creation || 0),
+        outputTokens: tokenUsage.output || 0,
+        cachedInputTokens: tokenUsage.input_cache_read || 0,
+        reasoningOutputTokens: 0,
+      });
+      if (messageId) seenMessageIds.set(messageId, entries.at(-1));
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}
+
+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 legacy = parseLegacyKimi();
+  return {
+    buckets: [...(current?.buckets ?? []), ...legacy.buckets],
+    sessions: [...(current?.sessions ?? []), ...legacy.sessions],
+  };
+}