vibeusage 0.3.5 → 0.5.0

package/README.md

@@ -86,7 +86,7 @@ This is useful when you want to copy an install command from the dashboard or le
 | **Every Code** | Auto-detected | `notify` hook | `~/.code/sessions/**/rollout-*.jsonl` |
 | **Claude Code** | Auto-detected | `Stop` + `SessionEnd` hooks | local hook output |
 | **Gemini CLI** | Auto-detected | `SessionEnd` hook | `~/.gemini/tmp/**/chats/session-*.json` |
-| **OpenCode** | Auto-detected | plugin + local parsing | `~/.local/share/opencode/opencode.db` (legacy message files are fallback only) |
+| **OpenCode** | Auto-detected | plugin + local parsing | `~/.local/share/opencode/opencode.db` (SQLite is the only supported local accounting source) |
 | **Hermes** | Auto-detected when installed | plugin + local parsing | `~/.vibeusage/tracker/hermes.usage.jsonl` |
 | **OpenClaw** | Auto-detected when installed | session plugin | local sanitized usage ledger |
 
@@ -273,7 +273,7 @@ npx vibeusage status
 npx vibeusage doctor
 ```
 
-If OpenCode support is incomplete, the most common issue is missing `sqlite3` on `PATH`, or a local SQLite query failure.
+VibeUsage reads OpenCode usage only from `opencode.db`, so the most common issues are missing `sqlite3` on `PATH`, a missing database file, or a local SQLite query failure.
 
 ### My OpenClaw usage is not showing up. What should I check?
 

package/README.zh-CN.md

@@ -86,7 +86,7 @@ npx --yes vibeusage init --link-code <code>
 | **Every Code** | 自动检测 | `notify` hook | `~/.code/sessions/**/rollout-*.jsonl` |
 | **Claude Code** | 自动检测 | `Stop` + `SessionEnd` hooks | 本地 hook 输出 |
 | **Gemini CLI** | 自动检测 | `SessionEnd` hook | `~/.gemini/tmp/**/chats/session-*.json` |
-| **OpenCode** | 自动检测 | plugin + 本地解析 | `~/.local/share/opencode/opencode.db`（旧 message 文件仅作 fallback） |
+| **OpenCode** | 自动检测 | plugin + 本地解析 | `~/.local/share/opencode/opencode.db`（SQLite 是唯一受支持的本地 accounting source） |
 | **OpenClaw** | 安装后自动检测 | session plugin | 本地 sanitized usage ledger |
 
 ### OpenClaw 说明

package/package.json

@@ -1,8 +1,16 @@
 {
   "name": "vibeusage",
-  "version": "0.3.5",
+  "version": "0.5.0",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/victorGPT/vibeusage.git"
+  },
+  "bugs": {
+    "url": "https://github.com/victorGPT/vibeusage/issues"
+  },
+  "homepage": "https://github.com/victorGPT/vibeusage#readme",
   "bin": {
     "tracker": "bin/tracker.js",
     "vibeusage": "bin/tracker.js",

package/src/commands/init.js

@@ -190,7 +190,7 @@ function renderWelcome() {
       DIVIDER,
       "",
       "This tool will:",
-      "  - Analyze your local AI CLI configurations (Codex, Every Code, Claude, Gemini, Opencode, Hermes, OpenClaw)",
+      "  - Analyze your local AI CLI configurations (Codex, Every Code, Claude Code, Gemini, Kimi, Hermes, OpenCode, OpenClaw)",
       "  - Set up lightweight hooks to track your flow state",
       "  - Link your device to your VibeScore account",
       "",
@@ -486,7 +486,7 @@ try {
   const originalPath =
     source === 'every-code'
       ? codeOriginalPath
-      : source === 'claude' || source === 'opencode' || source === 'gemini'
+      : source === 'claude' || source === 'opencode' || source === 'gemini' || source === 'kimi'
         ? null
         : codexOriginalPath;
   if (originalPath) {

package/src/commands/sync.js

@@ -8,10 +8,11 @@ const {
   listRolloutFiles,
   listClaudeProjectFiles,
   listGeminiSessionFiles,
-  listOpencodeMessageFiles,
+  listKimiSessionFiles,
   parseRolloutIncremental,
   parseClaudeIncremental,
   parseGeminiIncremental,
+  parseKimiIncremental,
   parseOpencodeIncremental,
   normalizeHourlyState,
   getHourlyBucket,
@@ -72,9 +73,10 @@ async function cmdSync(argv) {
     const claudeProjectsDir = path.join(home, ".claude", "projects");
     const geminiHome = process.env.GEMINI_HOME || path.join(home, ".gemini");
     const geminiTmpDir = path.join(geminiHome, "tmp");
+    const kimiHome = process.env.KIMI_HOME || path.join(home, ".kimi");
+    const kimiSessionsDir = path.join(kimiHome, "sessions");
     const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
     const opencodeHome = process.env.OPENCODE_HOME || path.join(xdgDataHome, "opencode");
-    const opencodeStorageDir = path.join(opencodeHome, "storage");
     const opencodeDbPath = path.join(opencodeHome, "opencode.db");
 
     const sources = [
@@ -181,28 +183,38 @@ async function cmdSync(argv) {
       });
     }
 
-    const opencodeFiles = await listOpencodeMessageFiles(opencodeStorageDir);
-    let opencodeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    if (progress?.enabled && opencodeFiles.length > 0) {
-      progress.start(
-        `Parsing Opencode ${renderBar(0)} 0/${formatNumber(opencodeFiles.length)} files | buckets 0`,
-      );
+    const kimiFiles = await listKimiSessionFiles(kimiSessionsDir);
+    let kimiResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (kimiFiles.length > 0) {
+      if (progress?.enabled) {
+        progress.start(
+          `Parsing Kimi ${renderBar(0)} 0/${formatNumber(kimiFiles.length)} files | buckets 0`,
+        );
+      }
+      kimiResult = await parseKimiIncremental({
+        sessionFiles: kimiFiles,
+        cursors,
+        queuePath,
+        projectQueuePath,
+        onProgress: (p) => {
+          if (!progress?.enabled) return;
+          const pct = p.total > 0 ? p.index / p.total : 1;
+          progress.update(
+            `Parsing Kimi ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
+              p.bucketsQueued,
+            )}`,
+          );
+        },
+        source: "kimi",
+      });
     }
+
+    let opencodeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     opencodeResult = await parseOpencodeIncremental({
-      messageFiles: opencodeFiles,
       opencodeDbPath,
       cursors,
       queuePath,
       projectQueuePath,
-      onProgress: (p) => {
-        if (!progress?.enabled) return;
-        const pct = p.total > 0 ? p.index / p.total : 1;
-        progress.update(
-          `Parsing Opencode ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-            p.total,
-          )} files | buckets ${formatNumber(p.bucketsQueued)}`,
-        );
-      },
       source: "opencode",
     });
 
@@ -380,6 +392,7 @@ async function cmdSync(argv) {
         openclawResult.filesProcessed +
         claudeResult.filesProcessed +
         geminiResult.filesProcessed +
+        kimiResult.filesProcessed +
         opencodeResult.filesProcessed;
       const totalBuckets =
         parseResult.bucketsQueued +
@@ -387,6 +400,7 @@ async function cmdSync(argv) {
         openclawResult.bucketsQueued +
         claudeResult.bucketsQueued +
         geminiResult.bucketsQueued +
+        kimiResult.bucketsQueued +
         opencodeResult.bucketsQueued;
       process.stdout.write(
         [

package/src/lib/integrations/claude.js

@@ -8,7 +8,7 @@ const { isDir, isFile } = require("./utils");
 
 module.exports = {
   name: "claude",
-  summaryLabel: "Claude",
+  summaryLabel: "Claude Code",
   statusLabel: "Claude plugin",
   async probe(ctx) {
     const hasConfigDir = await isDir(ctx.claude.configDir);

package/src/lib/integrations/context.js

@@ -7,6 +7,11 @@ const {
   resolveGeminiSettingsPath,
   buildGeminiHookCommand,
 } = require("../gemini-config");
+const {
+  resolveKimiConfigDir,
+  resolveKimiConfigPath,
+  buildKimiHookCommand,
+} = require("../kimi-config");
 const { resolveOpencodeConfigDir } = require("../opencode-config");
 const { resolveOpenclawSessionPluginPaths } = require("../openclaw-session-plugin");
 const { resolveHermesPluginPaths } = require("../hermes-config");
@@ -25,6 +30,7 @@ async function createIntegrationContext({
   const codeHome = env.CODE_HOME || path.join(home, ".code");
   const claudeDir = path.join(home, ".claude");
   const geminiConfigDir = resolveGeminiConfigDir({ home, env });
+  const kimiConfigDir = resolveKimiConfigDir({ home, env });
   const opencodeConfigDir = resolveOpencodeConfigDir({ home, env });
 
   return {
@@ -55,6 +61,12 @@ async function createIntegrationContext({
       settingsPath: resolveGeminiSettingsPath({ configDir: geminiConfigDir }),
       hookCommand: buildGeminiHookCommand(resolvedNotifyPath),
     },
+    kimi: {
+      configDir: kimiConfigDir,
+      configPath: resolveKimiConfigPath({ configDir: kimiConfigDir }),
+      hookCommand: buildKimiHookCommand(resolvedNotifyPath),
+      sessionsDir: path.join(kimiConfigDir, "sessions"),
+    },
     opencode: {
       configDir: opencodeConfigDir,
     },

package/src/lib/integrations/index.js

@@ -3,6 +3,7 @@ const codex = require("./codex");
 const everyCode = require("./every-code");
 const claude = require("./claude");
 const gemini = require("./gemini");
+const kimi = require("./kimi");
 const opencode = require("./opencode");
 const hermes = require("./hermes");
 const openclawSession = require("./openclaw-session");
@@ -12,6 +13,7 @@ const INTEGRATIONS = [
   everyCode,
   claude,
   gemini,
+  kimi,
   opencode,
   hermes,
   openclawSession,

package/src/lib/integrations/kimi.js

@@ -0,0 +1,105 @@
+const {
+  isKimiHookConfigured,
+  upsertKimiHook,
+  removeKimiHook,
+  probeKimiHook,
+} = require("../kimi-config");
+const { isDir, isFile } = require("./utils");
+
+module.exports = {
+  name: "kimi",
+  summaryLabel: "Kimi",
+  statusLabel: "Kimi hooks",
+  async probe(ctx) {
+    const hasConfigDir = await isDir(ctx.kimi.configDir);
+    if (!hasConfigDir) {
+      return baseProbe(this, { status: "not_installed", detail: "Config not found" });
+    }
+    const hasConfigFile = await isFile(ctx.kimi.configPath);
+    if (!hasConfigFile) {
+      return baseProbe(this, {
+        status: "not_installed",
+        detail: "config.toml not found",
+      });
+    }
+    const state = await probeKimiHook({
+      configPath: ctx.kimi.configPath,
+      hookCommand: ctx.kimi.hookCommand,
+    });
+    if (state.configured) {
+      return baseProbe(this, {
+        status: "ready",
+        detail: "Hooks installed",
+        configured: true,
+      });
+    }
+    return baseProbe(this, {
+      status: state.drifted ? "drifted" : "not_installed",
+      detail: state.drifted
+        ? "Run vibeusage init to reconcile hooks"
+        : "Run vibeusage init to install hooks",
+    });
+  },
+  async install(ctx) {
+    if (!(await isDir(ctx.kimi.configDir))) {
+      return action(this, "skipped", false, "Config not found");
+    }
+    if (!(await isFile(ctx.kimi.configPath))) {
+      return action(this, "skipped", false, "config.toml not found");
+    }
+    const result = await upsertKimiHook({
+      configPath: ctx.kimi.configPath,
+      hookCommand: ctx.kimi.hookCommand,
+    });
+    return action(
+      this,
+      result.changed ? "installed" : "set",
+      Boolean(result.changed),
+      result.changed ? "Hooks installed" : "Hooks already installed",
+    );
+  },
+  async uninstall(ctx) {
+    if (!(await isDir(ctx.kimi.configDir))) {
+      return action(this, "skipped", false, "config dir not found");
+    }
+    const result = await removeKimiHook({ configPath: ctx.kimi.configPath });
+    if (result.removed) {
+      return action(this, "removed", true, ctx.kimi.configPath);
+    }
+    if (result.skippedReason === "hook-missing") {
+      return action(this, "unchanged", false, "no change", {
+        skippedReason: result.skippedReason,
+      });
+    }
+    return action(this, "skipped", false, "config.toml not found");
+  },
+  renderStatusValue(probe) {
+    if (probe.status === "ready") return "set";
+    if (probe.status === "not_installed") return "unset";
+    return probe.status;
+  },
+};
+
+function baseProbe(descriptor, values) {
+  return {
+    name: descriptor.name,
+    summaryLabel: descriptor.summaryLabel,
+    statusLabel: descriptor.statusLabel,
+    configured: false,
+    ...values,
+  };
+}
+
+function action(descriptor, status, changed, detail, extras = {}) {
+  return {
+    name: descriptor.name,
+    label: descriptor.summaryLabel,
+    status,
+    changed,
+    detail,
+    ...extras,
+  };
+}
+
+// Expose for tests / diagnostics that want the probe-only check.
+module.exports.isKimiHookConfigured = isKimiHookConfigured;

package/src/lib/integrations/opencode.js

@@ -3,8 +3,8 @@ const { isDir } = require("./utils");
 
 module.exports = {
   name: "opencode",
-  summaryLabel: "Opencode Plugin",
-  statusLabel: "Opencode plugin",
+  summaryLabel: "OpenCode Plugin",
+  statusLabel: "OpenCode plugin",
   async probe(ctx) {
     const hasConfigDir = await isDir(ctx.opencode.configDir);
     if (!hasConfigDir) {

package/src/lib/kimi-config.js

@@ -0,0 +1,221 @@
+const os = require("node:os");
+const path = require("node:path");
+const fs = require("node:fs/promises");
+
+const { ensureDir } = require("./fs");
+
+const DEFAULT_EVENTS = ["SessionEnd", "Stop"];
+const DEFAULT_TIMEOUT = 30;
+const MANAGED_START = "# --- vibeusage Kimi hooks START (managed, do not edit) ---";
+const MANAGED_END = "# --- vibeusage Kimi hooks END ---";
+
+function resolveKimiConfigDir({ home = os.homedir(), env = process.env } = {}) {
+  const explicit = typeof env.KIMI_HOME === "string" ? env.KIMI_HOME.trim() : "";
+  if (explicit) return path.resolve(explicit);
+  return path.join(home, ".kimi");
+}
+
+function resolveKimiConfigPath({ configDir }) {
+  return path.join(configDir, "config.toml");
+}
+
+function buildKimiHookCommand(notifyPath) {
+  const cmd = typeof notifyPath === "string" ? notifyPath : "";
+  return `/usr/bin/env node ${quoteArg(cmd)} --source=kimi`;
+}
+
+async function upsertKimiHook({
+  configPath,
+  hookCommand,
+  events = DEFAULT_EVENTS,
+  timeout = DEFAULT_TIMEOUT,
+}) {
+  const existing = await readFileOrEmpty(configPath);
+  const normalizedEvents = normalizeEvents(events);
+  const nextBlock = buildManagedBlock({
+    hookCommand,
+    events: normalizedEvents,
+    timeout: normalizeTimeout(timeout),
+  });
+  const { content, changed } = replaceManagedBlock(existing, nextBlock);
+  if (!changed) return { changed: false, backupPath: null };
+  const backupPath = await writeWithBackup({ configPath, content });
+  return { changed: true, backupPath };
+}
+
+async function removeKimiHook({ configPath }) {
+  const existing = await readFileOrEmpty(configPath);
+  if (!existing) return { removed: false, skippedReason: "config-missing", backupPath: null };
+  const { content, changed } = stripManagedBlock(existing);
+  if (!changed) return { removed: false, skippedReason: "hook-missing", backupPath: null };
+  const backupPath = await writeWithBackup({ configPath, content });
+  return { removed: true, skippedReason: null, backupPath };
+}
+
+async function isKimiHookConfigured({
+  configPath,
+  hookCommand,
+  events = DEFAULT_EVENTS,
+  timeout = DEFAULT_TIMEOUT,
+}) {
+  const probe = await probeKimiHook({ configPath, hookCommand, events, timeout });
+  return probe.configured;
+}
+
+async function probeKimiHook({
+  configPath,
+  hookCommand,
+  events = DEFAULT_EVENTS,
+  timeout = DEFAULT_TIMEOUT,
+}) {
+  const existing = await readFileOrEmpty(configPath);
+  if (!existing) {
+    return { configured: false, anyPresent: false, drifted: false };
+  }
+  const block = extractManagedBlock(existing);
+  if (!block) {
+    return { configured: false, anyPresent: false, drifted: false };
+  }
+  const expected = buildManagedBlock({
+    hookCommand,
+    events: normalizeEvents(events),
+    timeout: normalizeTimeout(timeout),
+  });
+  return {
+    configured: block === expected,
+    anyPresent: true,
+    drifted: block !== expected,
+  };
+}
+
+function buildManagedBlock({ hookCommand, events, timeout }) {
+  const lines = [MANAGED_START];
+  for (const event of events) {
+    lines.push(
+      "[[hooks]]",
+      `event = ${tomlString(event)}`,
+      `command = ${tomlString(hookCommand)}`,
+      `timeout = ${timeout}`,
+    );
+    lines.push("");
+  }
+  lines.push(MANAGED_END);
+  return lines.join("\n");
+}
+
+function replaceManagedBlock(existing, nextBlock) {
+  const startIdx = existing.indexOf(MANAGED_START);
+  const endIdx = existing.indexOf(MANAGED_END);
+
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    const blockEnd = endIdx + MANAGED_END.length;
+    const current = existing.slice(startIdx, blockEnd);
+    if (current === nextBlock) return { content: existing, changed: false };
+    const before = existing.slice(0, startIdx);
+    let after = existing.slice(blockEnd);
+    if (after.startsWith("\n")) after = after.slice(1);
+    const beforeTrimmed = before.replace(/\n+$/, "");
+    const prefix = beforeTrimmed.length > 0 ? `${beforeTrimmed}\n\n` : "";
+    const suffix = after.length > 0 ? `\n\n${after.replace(/^\n+/, "")}` : "\n";
+    return { content: `${prefix}${nextBlock}${suffix}`, changed: true };
+  }
+
+  const base = existing.replace(/\n+$/, "");
+  const prefix = base.length > 0 ? `${base}\n\n` : "";
+  return { content: `${prefix}${nextBlock}\n`, changed: true };
+}
+
+function stripManagedBlock(existing) {
+  const startIdx = existing.indexOf(MANAGED_START);
+  const endIdx = existing.indexOf(MANAGED_END);
+  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) {
+    return { content: existing, changed: false };
+  }
+  const blockEnd = endIdx + MANAGED_END.length;
+  const before = existing.slice(0, startIdx).replace(/\n+$/, "");
+  let after = existing.slice(blockEnd);
+  after = after.replace(/^\n+/, "");
+  if (before.length === 0 && after.length === 0) {
+    return { content: "", changed: true };
+  }
+  if (before.length === 0) return { content: `${after.endsWith("\n") ? after : `${after}\n`}`, changed: true };
+  if (after.length === 0) return { content: `${before}\n`, changed: true };
+  return { content: `${before}\n\n${after.endsWith("\n") ? after : `${after}\n`}`, changed: true };
+}
+
+function extractManagedBlock(existing) {
+  const startIdx = existing.indexOf(MANAGED_START);
+  const endIdx = existing.indexOf(MANAGED_END);
+  if (startIdx === -1 || endIdx === -1 || endIdx < startIdx) return null;
+  const blockEnd = endIdx + MANAGED_END.length;
+  return existing.slice(startIdx, blockEnd);
+}
+
+function normalizeEvents(raw) {
+  const values = Array.isArray(raw) ? raw : [raw];
+  const out = [];
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    const normalized = value.trim();
+    if (!normalized || out.includes(normalized)) continue;
+    out.push(normalized);
+  }
+  return out.length > 0 ? out : DEFAULT_EVENTS.slice();
+}
+
+function normalizeTimeout(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return DEFAULT_TIMEOUT;
+  return Math.floor(n);
+}
+
+function tomlString(value) {
+  const v = typeof value === "string" ? value : String(value ?? "");
+  return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function quoteArg(value) {
+  const v = typeof value === "string" ? value : "";
+  if (!v) return '""';
+  if (/^[A-Za-z0-9_\-./:@]+$/.test(v)) return v;
+  return `"${v.replace(/"/g, '\\"')}"`;
+}
+
+async function readFileOrEmpty(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err && err.code === "ENOENT") return "";
+    throw err;
+  }
+}
+
+async function writeWithBackup({ configPath, content }) {
+  await ensureDir(path.dirname(configPath));
+  let backupPath = null;
+  try {
+    const st = await fs.stat(configPath);
+    if (st && st.isFile()) {
+      backupPath = `${configPath}.bak.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+      await fs.copyFile(configPath, backupPath);
+    }
+  } catch (_e) {
+    // no existing file
+  }
+  await fs.writeFile(configPath, content, "utf8");
+  return backupPath;
+}
+
+module.exports = {
+  DEFAULT_EVENTS,
+  DEFAULT_TIMEOUT,
+  MANAGED_START,
+  MANAGED_END,
+  resolveKimiConfigDir,
+  resolveKimiConfigPath,
+  buildKimiHookCommand,
+  upsertKimiHook,
+  removeKimiHook,
+  isKimiHookConfigured,
+  probeKimiHook,
+};

package/src/lib/opencode-usage-audit.js

@@ -2,7 +2,7 @@ const fs = require("node:fs/promises");
 const os = require("node:os");
 const path = require("node:path");
 
-const { listOpencodeMessageFiles, parseOpencodeIncremental } = require("./rollout");
+const { parseOpencodeIncremental } = require("./rollout");
 
 const BUCKET_SEPARATOR = "|";
 const DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -31,7 +31,6 @@ function addTotals(target, delta) {
 }
 
 async function buildLocalHourlyTotals({ storageDir, source = "opencode" }) {
-  const messageFiles = await listOpencodeMessageFiles(storageDir);
   const opencodeDbPath = path.resolve(storageDir, "..", "opencode.db");
   const queuePath = path.join(
     os.tmpdir(),
@@ -39,7 +38,7 @@ async function buildLocalHourlyTotals({ storageDir, source = "opencode" }) {
   );
   const cursors = { version: 1, files: {}, hourly: null, opencode: null, opencodeSqlite: null };
 
-  await parseOpencodeIncremental({ messageFiles, opencodeDbPath, cursors, queuePath, source });
+  await parseOpencodeIncremental({ opencodeDbPath, cursors, queuePath, source });
   await fs.rm(queuePath, { force: true }).catch(() => {});
 
   const byHour = new Map();

package/src/lib/rollout.js

@@ -63,6 +63,25 @@ async function listGeminiSessionFiles(tmpDir) {
   return out;
 }
 
+async function listKimiSessionFiles(sessionsDir) {
+  const out = [];
+  const projects = await safeReadDir(sessionsDir);
+  for (const project of projects) {
+    if (!project.isDirectory()) continue;
+    const projectDir = path.join(sessionsDir, project.name);
+    const sessions = await safeReadDir(projectDir);
+    for (const session of sessions) {
+      if (!session.isDirectory()) continue;
+      const wirePath = path.join(projectDir, session.name, "wire.jsonl");
+      const st = await fs.stat(wirePath).catch(() => null);
+      if (!st || !st.isFile()) continue;
+      out.push(wirePath);
+    }
+  }
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
 async function listOpencodeMessageFiles(storageDir) {
   const out = [];
   const messageDir = path.join(storageDir, "message");
@@ -227,6 +246,8 @@ async function parseClaudeIncremental({
     const prev = cursors.files[key] || null;
     const inode = st.ino || 0;
     const startOffset = prev && prev.inode === inode ? prev.offset || 0 : 0;
+    const priorSeenIds =
+      prev && prev.inode === inode && Array.isArray(prev.seenIds) ? prev.seenIds : [];
 
     const projectContext = projectEnabled
       ? await resolveProjectContextForFile({
@@ -250,11 +271,13 @@ async function parseClaudeIncremental({
       projectTouchedBuckets,
       projectRef,
       projectKey,
+      priorSeenIds,
     });
 
     cursors.files[key] = {
       inode,
       offset: result.endOffset,
+      seenIds: result.seenIds,
       updatedAt: new Date().toISOString(),
     };
 
@@ -397,23 +420,21 @@ async function parseGeminiIncremental({
   return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
 }
 
-async function parseOpencodeIncremental({
-  messageFiles,
-  opencodeDbPath,
+async function parseKimiIncremental({
+  sessionFiles,
   cursors,
   queuePath,
   projectQueuePath,
   onProgress,
   source,
   publicRepoResolver,
-  readSqliteRows,
 }) {
   await ensureDir(path.dirname(queuePath));
   let filesProcessed = 0;
   let eventsAggregated = 0;
 
   const cb = typeof onProgress === "function" ? onProgress : null;
-  const files = Array.isArray(messageFiles) ? messageFiles : [];
+  const files = Array.isArray(sessionFiles) ? sessionFiles : [];
   const totalFiles = files.length;
   const hourlyState = normalizeHourlyState(cursors?.hourly);
   const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
@@ -421,14 +442,8 @@ async function parseOpencodeIncremental({
   const projectTouchedBuckets = projectEnabled ? new Set() : null;
   const projectMetaCache = projectEnabled ? new Map() : null;
   const publicRepoCache = projectEnabled ? new Map() : null;
-  const opencodeState = normalizeOpencodeState(cursors?.opencode);
-  const opencodeSqliteState = normalizeOpencodeSqliteState(cursors?.opencodeSqlite);
-  const messageIndex = opencodeState.messages;
   const touchedBuckets = new Set();
-  const defaultSource = normalizeSourceInput(source) || "opencode";
-  let sqliteStatus = opencodeSqliteState.lastStatus || "never_checked";
-  let sqliteCheckedAt = opencodeSqliteState.lastCheckedAt || null;
-  let sqliteErrorCode = opencodeSqliteState.lastErrorCode || null;
+  const defaultSource = normalizeSourceInput(source) || "kimi";
 
   if (!cursors.files || typeof cursors.files !== "object") {
     cursors.files = {};
@@ -448,30 +463,8 @@ async function parseOpencodeIncremental({
     const key = filePath;
     const prev = cursors.files[key] || null;
     const inode = st.ino || 0;
-    const size = Number.isFinite(st.size) ? st.size : 0;
-    const mtimeMs = Number.isFinite(st.mtimeMs) ? st.mtimeMs : 0;
-    const unchanged =
-      prev && prev.inode === inode && prev.size === size && prev.mtimeMs === mtimeMs;
-    if (unchanged) {
-      filesProcessed += 1;
-      if (cb) {
-        cb({
-          index: idx + 1,
-          total: totalFiles,
-          filePath,
-          filesProcessed,
-          eventsAggregated,
-          bucketsQueued: touchedBuckets.size,
-        });
-      }
-      continue;
-    }
+    const startOffset = prev && prev.inode === inode ? prev.offset || 0 : 0;
 
-    const fallbackTotals = prev && typeof prev.lastTotals === "object" ? prev.lastTotals : null;
-    const fallbackMessageKey =
-      prev && typeof prev.messageKey === "string" && prev.messageKey.trim()
-        ? prev.messageKey.trim()
-        : null;
     const projectContext = projectEnabled
       ? await resolveProjectContextForFile({
           filePath,
@@ -484,11 +477,9 @@ async function parseOpencodeIncremental({
     const projectRef = projectContext?.projectRef || null;
     const projectKey = projectContext?.projectKey || null;
 
-    const result = await parseOpencodeMessageFile({
+    const result = await parseKimiFile({
       filePath,
-      messageIndex,
-      fallbackTotals,
-      fallbackMessageKey,
+      startOffset,
       hourlyState,
       touchedBuckets,
       source: fileSource,
@@ -500,23 +491,13 @@ async function parseOpencodeIncremental({
 
     cursors.files[key] = {
       inode,
-      size,
-      mtimeMs,
-      lastTotals: result.lastTotals,
-      messageKey: result.messageKey || null,
+      offset: result.endOffset,
       updatedAt: new Date().toISOString(),
     };
 
     filesProcessed += 1;
     eventsAggregated += result.eventsAggregated;
 
-    if (result.messageKey && result.shouldUpdate) {
-      messageIndex[result.messageKey] = {
-        lastTotals: result.lastTotals,
-        updatedAt: new Date().toISOString(),
-      };
-    }
-
     if (cb) {
       cb({
         index: idx + 1,
@@ -529,6 +510,54 @@ async function parseOpencodeIncremental({
     }
   }
 
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  const projectBucketsQueued = projectEnabled
+    ? await enqueueTouchedProjectBuckets({ projectQueuePath, projectState, projectTouchedBuckets })
+    : 0;
+  hourlyState.updatedAt = new Date().toISOString();
+  cursors.hourly = hourlyState;
+  if (projectState) {
+    projectState.updatedAt = new Date().toISOString();
+    cursors.projectHourly = projectState;
+  }
+
+  return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
+}
+
+async function parseOpencodeIncremental({
+  opencodeDbPath,
+  cursors,
+  queuePath,
+  projectQueuePath,
+  onProgress,
+  source = "opencode",
+  publicRepoResolver = null,
+  readSqliteRows,
+}) {
+  await ensureDir(path.dirname(queuePath));
+  let filesProcessed = 0;
+  let eventsAggregated = 0;
+
+  const cb = typeof onProgress === "function" ? onProgress : null;
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
+  const projectState = projectEnabled ? normalizeProjectState(cursors?.projectHourly) : null;
+  const projectTouchedBuckets = projectEnabled ? new Set() : null;
+  const projectMetaCache = projectEnabled ? new Map() : null;
+  const publicRepoCache = projectEnabled ? new Map() : null;
+  const opencodeState = normalizeOpencodeState(cursors?.opencode);
+  const opencodeSqliteState = normalizeOpencodeSqliteState(cursors?.opencodeSqlite);
+  const messageIndex = opencodeState.messages;
+  const touchedBuckets = new Set();
+  const defaultSource = normalizeSourceInput(source) || "opencode";
+  let sqliteStatus = opencodeSqliteState.lastStatus || "never_checked";
+  let sqliteCheckedAt = opencodeSqliteState.lastCheckedAt || null;
+  let sqliteErrorCode = opencodeSqliteState.lastErrorCode || null;
+
+  if (!cursors.files || typeof cursors.files !== "object") {
+    cursors.files = {};
+  }
+
   if (typeof opencodeDbPath === "string" && opencodeDbPath.length > 0) {
     const readRows =
       typeof readSqliteRows === "function" ? readSqliteRows : readOpencodeSqliteRows;
@@ -753,6 +782,8 @@ async function parseRolloutFile({
   return { endOffset, lastTotal: totals, lastModel: model, eventsAggregated };
 }
 
+const CLAUDE_SEEN_IDS_LIMIT = 500;
+
 async function parseClaudeFile({
   filePath,
   startOffset,
@@ -763,12 +794,18 @@ async function parseClaudeFile({
   projectTouchedBuckets,
   projectRef,
   projectKey,
+  priorSeenIds,
 }) {
+  const seenOrder = Array.isArray(priorSeenIds) ? priorSeenIds.slice() : [];
+  const seenSet = new Set(seenOrder);
+
   const st = await fs.stat(filePath).catch(() => null);
-  if (!st || !st.isFile()) return { endOffset: startOffset, eventsAggregated: 0 };
+  if (!st || !st.isFile()) {
+    return { endOffset: startOffset, eventsAggregated: 0, seenIds: seenOrder };
+  }
 
   const endOffset = st.size;
-  if (startOffset >= endOffset) return { endOffset, eventsAggregated: 0 };
+  if (startOffset >= endOffset) return { endOffset, eventsAggregated: 0, seenIds: seenOrder };
 
   const stream = fssync.createReadStream(filePath, { encoding: "utf8", start: startOffset });
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
@@ -786,6 +823,12 @@ async function parseClaudeFile({
     const usage = obj?.message?.usage || obj?.usage;
     if (!usage || typeof usage !== "object") continue;
 
+    // Claude Code writes the same assistant message multiple times in the session log
+    // (same `message.id` / `requestId`, different outer `uuid`). Aggregate once per
+    // upstream Anthropic response to avoid multi-counting token usage.
+    const dedupeId = obj?.message?.id || obj?.requestId || null;
+    if (dedupeId && seenSet.has(dedupeId)) continue;
+
     const model = normalizeModelInput(obj?.message?.model || obj?.model) || DEFAULT_MODEL;
     const tokenTimestamp = typeof obj?.timestamp === "string" ? obj.timestamp : null;
     if (!tokenTimestamp) continue;
@@ -796,6 +839,78 @@ async function parseClaudeFile({
     const bucketStart = toUtcHalfHourStart(tokenTimestamp);
     if (!bucketStart) continue;
 
+    const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
+    addTotals(bucket.totals, delta);
+    touchedBuckets.add(bucketKey(source, model, bucketStart));
+    if (projectKey && projectState && projectTouchedBuckets) {
+      const projectBucket = getProjectBucket(
+        projectState,
+        projectKey,
+        source,
+        bucketStart,
+        projectRef,
+      );
+      addTotals(projectBucket.totals, delta);
+      projectTouchedBuckets.add(projectBucketKey(projectKey, source, bucketStart));
+    }
+    if (dedupeId) {
+      seenSet.add(dedupeId);
+      seenOrder.push(dedupeId);
+    }
+    eventsAggregated += 1;
+  }
+
+  rl.close();
+  stream.close?.();
+  const trimmedSeenIds =
+    seenOrder.length > CLAUDE_SEEN_IDS_LIMIT
+      ? seenOrder.slice(seenOrder.length - CLAUDE_SEEN_IDS_LIMIT)
+      : seenOrder;
+  return { endOffset, eventsAggregated, seenIds: trimmedSeenIds };
+}
+
+async function parseKimiFile({
+  filePath,
+  startOffset,
+  hourlyState,
+  touchedBuckets,
+  source,
+  projectState,
+  projectTouchedBuckets,
+  projectRef,
+  projectKey,
+}) {
+  const st = await fs.stat(filePath).catch(() => null);
+  if (!st || !st.isFile()) return { endOffset: startOffset, eventsAggregated: 0 };
+
+  const endOffset = st.size;
+  if (startOffset >= endOffset) return { endOffset, eventsAggregated: 0 };
+
+  const stream = fssync.createReadStream(filePath, { encoding: "utf8", start: startOffset });
+  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+  let eventsAggregated = 0;
+  for await (const line of rl) {
+    if (!line || !line.includes("StatusUpdate")) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch (_e) {
+      continue;
+    }
+    if (!obj || !obj.message || obj.message.type !== "StatusUpdate") continue;
+
+    const payload = obj.message.payload;
+    const delta = normalizeKimiUsage(payload?.token_usage);
+    if (!delta || isAllZeroUsage(delta)) continue;
+
+    const tsIso = kimiTimestampToIso(obj.timestamp);
+    if (!tsIso) continue;
+
+    const bucketStart = toUtcHalfHourStart(tsIso);
+    if (!bucketStart) continue;
+
+    const model = normalizeModelInput(payload?.model) || DEFAULT_MODEL;
     const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
     addTotals(bucket.totals, delta);
     touchedBuckets.add(bucketKey(source, model, bucketStart));
@@ -2058,6 +2173,32 @@ function normalizeGeminiTokens(tokens) {
   };
 }
 
+function normalizeKimiUsage(usage) {
+  if (!usage || typeof usage !== "object") return null;
+  const inputOther = toNonNegativeInt(usage.input_other);
+  const cacheCreation = toNonNegativeInt(usage.input_cache_creation);
+  const cacheRead = toNonNegativeInt(usage.input_cache_read);
+  const output = toNonNegativeInt(usage.output);
+  const inputTokens = inputOther + cacheCreation;
+  const total = inputTokens + cacheRead + output;
+  return {
+    input_tokens: inputTokens,
+    cached_input_tokens: cacheRead,
+    output_tokens: output,
+    reasoning_output_tokens: 0,
+    total_tokens: total,
+  };
+}
+
+function kimiTimestampToIso(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const ms = n < 1e12 ? Math.floor(n * 1000) : Math.floor(n);
+  const date = new Date(ms);
+  const iso = date.toISOString();
+  return iso;
+}
+
 function normalizeOpencodeTokens(tokens) {
   if (!tokens || typeof tokens !== "object") return null;
   const input = toNonNegativeInt(tokens.input);
@@ -2066,7 +2207,10 @@ function normalizeOpencodeTokens(tokens) {
   const cached = toNonNegativeInt(tokens.cache?.read);
   const cacheWrite = toNonNegativeInt(tokens.cache?.write);
   const inputTokens = input + cacheWrite;
-  const total = inputTokens + output + reasoning;
+  // Include cache-read tokens in the total so OpenCode sessions do not
+  // under-count the way Claude did before the parallel fix; cache-read is
+  // real spend the user pays for on every turn.
+  const total = inputTokens + cached + output + reasoning;
 
   return {
     input_tokens: inputTokens,
@@ -2189,12 +2333,19 @@ function normalizeUsage(u) {
 function normalizeClaudeUsage(u) {
   const inputTokens =
     toNonNegativeInt(u?.input_tokens) + toNonNegativeInt(u?.cache_creation_input_tokens);
+  const cachedInputTokens = toNonNegativeInt(u?.cache_read_input_tokens);
   const outputTokens = toNonNegativeInt(u?.output_tokens);
   const hasTotal = u && Object.prototype.hasOwnProperty.call(u, "total_tokens");
-  const totalTokens = hasTotal ? toNonNegativeInt(u?.total_tokens) : inputTokens + outputTokens;
+  // Claude's Messages API does not emit `total_tokens`. When absent, compose it
+  // from all four channels (input / cache_creation / cache_read / output). The
+  // old formula omitted cache_read, which is ~99% of token spend on long
+  // Claude Opus sessions and was the main driver of user-visible under-counts.
+  const totalTokens = hasTotal
+    ? toNonNegativeInt(u?.total_tokens)
+    : inputTokens + cachedInputTokens + outputTokens;
   return {
     input_tokens: inputTokens,
-    cached_input_tokens: toNonNegativeInt(u?.cache_read_input_tokens),
+    cached_input_tokens: cachedInputTokens,
     output_tokens: outputTokens,
     reasoning_output_tokens: 0,
     total_tokens: totalTokens,
@@ -2293,10 +2444,12 @@ module.exports = {
   listRolloutFiles,
   listClaudeProjectFiles,
   listGeminiSessionFiles,
+  listKimiSessionFiles,
   listOpencodeMessageFiles,
   parseRolloutIncremental,
   parseClaudeIncremental,
   parseGeminiIncremental,
+  parseKimiIncremental,
   parseOpencodeIncremental,
   normalizeHourlyState,
   getHourlyBucket,