@vibe-cafe/vibe-usage 0.5.1 → 0.6.0

package/README.md

@@ -29,23 +29,37 @@ npx vibe-usage status       # Show config & detected tools
 
 | Tool | Data Location |
 |------|---------------|
-| Claude Code | `~/.claude/projects/` |
+| Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only) |
 | Codex CLI | `~/.codex/sessions/` |
 | Gemini CLI | `~/.gemini/tmp/` |
-| OpenCode | `~/.local/share/opencode/opencode.db` (SQLite) |
+| OpenCode | `~/.local/share/opencode/opencode.db` (SQLite, `json_extract` query) |
 | OpenClaw | `~/.openclaw/agents/` |
+| Qwen Code | `~/.qwen/tmp/` |
+| Kimi Code | `~/.kimi/sessions/` |
 
 ## How It Works
 
 - Parses local session logs from each AI coding tool
 - Aggregates token usage into 30-minute buckets
-- Uploads to your vibecafe.ai dashboard
+- Extracts session metadata from all 7 parsers: active time (sum of turn durations), total duration, message counts
+- Uploads buckets + sessions to your vibecafe.ai dashboard
 - Stateless: computes full totals from local logs each sync (idempotent, no state files)
 - For continuous syncing, use `npx vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 
+## Development
+
+Test against a local vibe-cafe dev server without publishing:
+
+```bash
+VIBE_USAGE_DEV=1 VIBE_USAGE_API_URL=http://localhost:3000 npx vibe-usage init
+VIBE_USAGE_DEV=1 npx vibe-usage sync
+```
+
+`VIBE_USAGE_DEV=1` uses a separate config file (`~/.vibe-usage/config.dev.json`).
+
 ## Config
 
-Config stored at `~/.vibe-usage/config.json`. Contains your API key and server URL.
+Config stored at `~/.vibe-usage/config.json` (dev: `config.dev.json`). Contains your API key and server URL.
 
 ## Daemon Mode
 

package/package.json

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

package/src/api.js

@@ -5,21 +5,11 @@ import { URL } from 'node:url';
 const MAX_RETRIES = 3;
 const INITIAL_DELAY = 1000;
 
-/**
- * POST buckets to the vibecafe ingest API.
- * Uses native http/https — zero dependencies.
- * Retries up to 3 times with exponential backoff on transient failures.
- * @param {string} apiUrl - Base URL (e.g. "https://vibecafe.ai")
- * @param {string} apiKey - Bearer token (vbu_xxx)
- * @param {Array} buckets - Array of usage bucket objects
- * @param {{onProgress?: (sent: number, total: number) => void}} [opts]
- * @returns {Promise<{ingested: number}>}
- */
-export async function ingest(apiUrl, apiKey, buckets, opts) {
+export async function ingest(apiUrl, apiKey, buckets, opts, sessions) {
   let lastError;
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     try {
-      return await _send(apiUrl, apiKey, buckets, opts?.onProgress);
+      return await _send(apiUrl, apiKey, buckets, opts?.onProgress, sessions);
     } catch (err) {
       lastError = err;
       // Don't retry auth errors or client errors
@@ -35,10 +25,12 @@ export async function ingest(apiUrl, apiKey, buckets, opts) {
   throw lastError;
 }
 
-function _send(apiUrl, apiKey, buckets, onProgress) {
+function _send(apiUrl, apiKey, buckets, onProgress, sessions) {
   return new Promise((resolve, reject) => {
     const url = new URL('/api/usage/ingest', apiUrl);
-    const body = Buffer.from(JSON.stringify({ buckets }));
+    const payload = { buckets };
+    if (sessions && sessions.length > 0) payload.sessions = sessions;
+    const body = Buffer.from(JSON.stringify(payload));
     const totalBytes = body.length;
     const mod = url.protocol === 'https:' ? https : http;
 

package/src/index.js

@@ -1,5 +1,5 @@
 import { loadConfig, saveConfig, getConfigPath } from './config.js';
-import { detectInstalledTools, TOOLS } from './hooks.js';
+import { detectInstalledTools, TOOLS } from './tools.js';
 import { existsSync } from 'node:fs';
 
 async function showStatus() {

package/src/init.js

@@ -4,7 +4,7 @@ import { platform } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
 import { ingest } from './api.js';
 import { runSync } from './sync.js';
-import { detectInstalledTools } from './hooks.js';
+import { detectInstalledTools } from './tools.js';
 
 function prompt(question) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });

package/src/parsers/claude-code.js

@@ -1,7 +1,7 @@
 import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, basename, sep } from 'node:path';
 import { homedir } from 'node:os';
-import { aggregateToBuckets } from './index.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
 
 /**
  * Stateless Claude Code parser.
@@ -11,7 +11,8 @@ import { aggregateToBuckets } from './index.js';
  * ON CONFLICT ... DO UPDATE SET idempotent.
  */
 
-const CLAUDE_DIR = join(homedir(), '.claude', 'projects');
+const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');
+const CLAUDE_TRANSCRIPTS_DIR = join(homedir(), '.claude', 'transcripts');
 
 /**
  * Recursively find all .jsonl files under a directory.
@@ -44,29 +45,29 @@ function findJsonlFiles(dir) {
  * We extract the last path segment as the project name.
  */
 function extractProject(filePath) {
-  // Get relative path from the projects dir
-  const projectsPrefix = CLAUDE_DIR + sep;
+  const projectsPrefix = CLAUDE_PROJECTS_DIR + sep;
   if (!filePath.startsWith(projectsPrefix)) return 'unknown';
   const relative = filePath.slice(projectsPrefix.length);
-  // First segment is the encoded project path
   const firstSeg = relative.split(sep)[0];
   if (!firstSeg) return 'unknown';
-  // The encoded path uses dashes: -Users-kalasoo-Projects-myproject
-  // Take the last segment after splitting by dash
   const parts = firstSeg.split('-').filter(Boolean);
   return parts.length > 0 ? parts[parts.length - 1] : 'unknown';
 }
 
-export async function parse() {
-  if (!existsSync(CLAUDE_DIR)) return [];
-
-  const files = findJsonlFiles(CLAUDE_DIR);
-  if (files.length === 0) return [];
+function extractSessionId(filePath) {
+  return basename(filePath, '.jsonl');
+}
 
+export async function parse() {
   const entries = [];
+  const sessionEvents = [];
   const seenUuids = new Set();
+  const seenSessionIds = new Set();
+
+  // --- projects/ directory: extract BOTH token buckets AND session events ---
+  const projectFiles = findJsonlFiles(CLAUDE_PROJECTS_DIR);
 
-  for (const filePath of files) {
+  for (const filePath of projectFiles) {
     let content;
     try {
       content = readFileSync(filePath, 'utf-8');
@@ -75,13 +76,29 @@ export async function parse() {
     }
 
     const project = extractProject(filePath);
+    const sessionId = extractSessionId(filePath);
+    seenSessionIds.add(sessionId);
 
     for (const line of content.split('\n')) {
       if (!line.trim()) continue;
       try {
         const obj = JSON.parse(line);
 
-        // Only process assistant messages with usage data
+        const timestamp = obj.timestamp;
+        if (!timestamp) continue;
+        const ts = new Date(timestamp);
+        if (isNaN(ts.getTime())) continue;
+
+        if (obj.type === 'user' || obj.type === 'assistant' || obj.type === 'tool_use' || obj.type === 'tool_result') {
+          sessionEvents.push({
+            sessionId,
+            source: 'claude-code',
+            project,
+            timestamp: ts,
+            role: obj.type === 'user' ? 'user' : 'assistant',
+          });
+        }
+
         if (obj.type !== 'assistant') continue;
         const msg = obj.message;
         if (!msg || !msg.usage) continue;
@@ -89,18 +106,12 @@ export async function parse() {
         const usage = msg.usage;
         if (usage.input_tokens == null && usage.output_tokens == null) continue;
 
-        // Deduplicate by UUID across all files
         const uuid = obj.uuid;
         if (uuid) {
           if (seenUuids.has(uuid)) continue;
           seenUuids.add(uuid);
         }
 
-        const timestamp = obj.timestamp;
-        if (!timestamp) continue;
-        const ts = new Date(timestamp);
-        if (isNaN(ts.getTime())) continue;
-
         entries.push({
           source: 'claude-code',
           model: msg.model || 'unknown',
@@ -117,5 +128,44 @@ export async function parse() {
     }
   }
 
-  return aggregateToBuckets(entries);
+  // --- transcripts/ directory: extract session events ONLY (no token data) ---
+  const transcriptFiles = findJsonlFiles(CLAUDE_TRANSCRIPTS_DIR);
+
+  for (const filePath of transcriptFiles) {
+    const sessionId = extractSessionId(filePath);
+    if (seenSessionIds.has(sessionId)) continue;
+
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+
+        const timestamp = obj.timestamp;
+        if (!timestamp) continue;
+        const ts = new Date(timestamp);
+        if (isNaN(ts.getTime())) continue;
+
+        if (obj.type === 'user' || obj.type === 'assistant' || obj.type === 'tool_use' || obj.type === 'tool_result') {
+          sessionEvents.push({
+            sessionId,
+            source: 'claude-code',
+            project: 'unknown',
+            timestamp: ts,
+            role: obj.type === 'user' ? 'user' : 'assistant',
+          });
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }

package/src/parsers/codex.js

@@ -1,7 +1,7 @@
 import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { aggregateToBuckets } from './index.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
 
 const SESSIONS_DIR = join(homedir(), '.codex', 'sessions');
 
@@ -28,11 +28,12 @@ function findJsonlFiles(dir) {
 }
 
 export async function parse() {
-  if (!existsSync(SESSIONS_DIR)) return [];
+  if (!existsSync(SESSIONS_DIR)) return { buckets: [], sessions: [] };
 
   const entries = [];
+  const sessionEvents = [];
   const files = findJsonlFiles(SESSIONS_DIR);
-  if (files.length === 0) return [];
+  if (files.length === 0) return { buckets: [], sessions: [] };
   for (const filePath of files) {
 
     let content;
@@ -64,16 +65,27 @@ export async function parse() {
       } catch { break; }
     }
 
-    // Track model from turn_context events (fallback when token_count lacks model)
     let turnContextModel = 'unknown';
-    // Track previous cumulative totals per model to compute deltas when only total_token_usage is available
     const prevTotal = new Map();
     for (const line of content.split('\n')) {
       if (!line.trim()) continue;
       try {
         const obj = JSON.parse(line);
 
-        // Capture model from top-level turn_context entries
+        if (obj.timestamp) {
+          const evTs = new Date(obj.timestamp);
+          if (!isNaN(evTs.getTime())) {
+            const isUserTurn = obj.type === 'turn_context' || obj.type === 'session_meta';
+            sessionEvents.push({
+              sessionId: filePath,
+              source: 'codex',
+              project: sessionProject,
+              timestamp: evTs,
+              role: isUserTurn ? 'user' : 'assistant',
+            });
+          }
+        }
+
         if (obj.type === 'turn_context' && obj.payload?.model) {
           turnContextModel = obj.payload.model;
           continue;
@@ -135,5 +147,5 @@ export async function parse() {
     }
   }
 
-  return aggregateToBuckets(entries);
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }

package/src/parsers/gemini-cli.js

@@ -1,7 +1,7 @@
 import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { aggregateToBuckets } from './index.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
 
 const TMP_DIR = join(homedir(), '.gemini', 'tmp');
 
@@ -32,9 +32,10 @@ function findSessionFiles(baseDir) {
 
 export async function parse() {
   const sessionFiles = findSessionFiles(TMP_DIR);
-  if (sessionFiles.length === 0) return [];
+  if (sessionFiles.length === 0) return { buckets: [], sessions: [] };
 
   const entries = [];
+  const sessionEvents = [];
 
   for (const filePath of sessionFiles) {
 
@@ -47,19 +48,25 @@ export async function parse() {
 
     const messages = data.messages || data.history || [];
     for (const msg of messages) {
-      // New format: tokens on type=gemini messages (ChatRecordingService)
-      // Old format: usage/usageMetadata on any message
-      const tokens = msg.tokens;
-      const usage = msg.usage || msg.usageMetadata || msg.token_count;
-      if (!tokens && !usage) continue;
-
       const timestamp = msg.timestamp || msg.createTime || data.createTime;
       if (!timestamp) continue;
       const ts = new Date(timestamp);
       if (isNaN(ts.getTime())) continue;
 
+      const role = (msg.role === 'user') ? 'user' : 'assistant';
+      sessionEvents.push({
+        sessionId: filePath,
+        source: 'gemini-cli',
+        project: 'unknown',
+        timestamp: ts,
+        role,
+      });
+
+      const tokens = msg.tokens;
+      const usage = msg.usage || msg.usageMetadata || msg.token_count;
+      if (!tokens && !usage) continue;
+
       if (tokens) {
-        // Gemini API: input INCLUDES cached, output INCLUDES thoughts. Normalize to non-overlapping.
         const cached = tokens.cached || 0;
         const thoughts = tokens.thoughts || 0;
         entries.push({
@@ -73,7 +80,6 @@ export async function parse() {
           reasoningOutputTokens: thoughts,
         });
       } else {
-        // Gemini API: promptTokenCount INCLUDES cachedContentTokenCount. Normalize to non-overlapping.
         const cached = usage.cachedContentTokenCount || 0;
         const thoughts = usage.thoughtsTokenCount || 0;
         entries.push({
@@ -90,5 +96,5 @@ export async function parse() {
     }
   }
 
-  return aggregateToBuckets(entries);
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }

package/src/parsers/index.js

@@ -1,8 +1,11 @@
+import { createHash } from 'node:crypto';
 import { parse as parseClaudeCode } from './claude-code.js';
 import { parse as parseCodex } from './codex.js';
 import { parse as parseGeminiCli } from './gemini-cli.js';
 import { parse as parseOpencode } from './opencode.js';
 import { parse as parseOpenclaw } from './openclaw.js';
+import { parse as parseQwenCode } from './qwen-code.js';
+import { parse as parseKimiCode } from './kimi-code.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
@@ -10,6 +13,8 @@ export const parsers = {
   'gemini-cli': parseGeminiCli,
   'opencode': parseOpencode,
   'openclaw': parseOpenclaw,
+  'qwen-code': parseQwenCode,
+  'kimi-code': parseKimiCode,
 };
 
 
@@ -50,3 +55,72 @@ export function aggregateToBuckets(entries) {
 
   return Array.from(map.values());
 }
+
+/**
+ * Extract session metadata from timing events.
+ * Each event: { sessionId, source, project, timestamp: Date, role: 'user'|'assistant' }
+ *
+ * Turn = user prompt → last agent message before next user prompt.
+ * activeSeconds = sum(turn durations). durationSeconds = wall clock.
+ */
+export function extractSessions(events) {
+  const groups = new Map();
+  for (const e of events) {
+    if (!groups.has(e.sessionId)) groups.set(e.sessionId, []);
+    groups.get(e.sessionId).push(e);
+  }
+
+  const sessions = [];
+  for (const [sessionId, sessionEvents] of groups) {
+    sessionEvents.sort((a, b) => a.timestamp - b.timestamp);
+
+    const first = sessionEvents[0];
+    const last = sessionEvents[sessionEvents.length - 1];
+    const durationSeconds = Math.round((last.timestamp - first.timestamp) / 1000);
+
+    let activeSeconds = 0;
+    let turnStart = null;
+    let turnEnd = null;
+
+    for (const event of sessionEvents) {
+      if (event.role === 'user') {
+        if (turnStart !== null && turnEnd !== null && turnEnd > turnStart) {
+          activeSeconds += Math.round((turnEnd - turnStart) / 1000);
+        }
+        turnStart = event.timestamp;
+        turnEnd = event.timestamp;
+      } else if (turnStart !== null) {
+        turnEnd = event.timestamp;
+      }
+    }
+    if (turnStart !== null && turnEnd !== null && turnEnd > turnStart) {
+      activeSeconds += Math.round((turnEnd - turnStart) / 1000);
+    }
+
+    const userPromptHours = new Array(24).fill(0);
+    let userMessageCount = 0;
+    for (const event of sessionEvents) {
+      if (event.role === 'user') {
+        userMessageCount++;
+        userPromptHours[event.timestamp.getUTCHours()]++;
+      }
+    }
+
+    const sessionHash = createHash('sha256').update(sessionId).digest('hex').slice(0, 16);
+
+    sessions.push({
+      source: first.source,
+      project: first.project || 'unknown',
+      sessionHash,
+      firstMessageAt: first.timestamp.toISOString(),
+      lastMessageAt: last.timestamp.toISOString(),
+      durationSeconds,
+      activeSeconds,
+      messageCount: sessionEvents.length,
+      userMessageCount,
+      userPromptHours,
+    });
+  }
+
+  return sessions;
+}

package/src/parsers/kimi-code.js

@@ -0,0 +1,140 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+/**
+ * Kimi Code CLI parser.
+ * Wire protocol JSONL at ~/.kimi/sessions/<work-dir-hash>/<session-id>/wire.jsonl
+ * Token data from StatusUpdate events: payload.token_usage.{input_other, output,
+ *   input_cache_read, input_cache_creation}
+ */
+
+const KIMI_SESSIONS_DIR = join(homedir(), '.kimi', 'sessions');
+const KIMI_CONFIG = join(homedir(), '.kimi', 'kimi.json');
+
+function findWireFiles(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 loadProjectMap() {
+  const map = new Map();
+  if (!existsSync(KIMI_CONFIG)) return map;
+
+  try {
+    const config = JSON.parse(readFileSync(KIMI_CONFIG, 'utf-8'));
+    const workspaces = config.workspaces || config.projects || {};
+    for (const [hash, info] of Object.entries(workspaces)) {
+      const path = typeof info === 'string' ? info : (info?.path || info?.dir);
+      if (path) {
+        const parts = path.split('/').filter(Boolean);
+        map.set(hash, parts[parts.length - 1] || hash);
+      }
+    }
+  } catch {
+    // config unreadable
+  }
+  return map;
+}
+
+export async function parse() {
+  const wireFiles = findWireFiles(KIMI_SESSIONS_DIR);
+  if (wireFiles.length === 0) return { buckets: [], sessions: [] };
+
+  const projectMap = loadProjectMap();
+  const entries = [];
+  const sessionEvents = [];
+  const seenMessageIds = new Set();
+
+  for (const { filePath, workDirHash } of wireFiles) {
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const project = projectMap.get(workDirHash) || workDirHash;
+    let currentModel = 'unknown';
+    let lastTimestamp = null;
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        const type = obj.type;
+        const payload = obj.payload;
+        if (!payload) continue;
+
+        if (payload.timestamp) lastTimestamp = payload.timestamp;
+        if (payload.model) currentModel = payload.model;
+
+        if (lastTimestamp) {
+          const evTs = new Date(lastTimestamp);
+          if (!isNaN(evTs.getTime())) {
+            const isUser = type === 'UserMessage' || type === 'user_message' || type === 'Input';
+            sessionEvents.push({
+              sessionId: filePath,
+              source: 'kimi-code',
+              project,
+              timestamp: evTs,
+              role: isUser ? 'user' : 'assistant',
+            });
+          }
+        }
+
+        if (type !== 'StatusUpdate') continue;
+
+        const tokenUsage = payload.token_usage;
+        if (!tokenUsage) continue;
+        if (!tokenUsage.input_other && !tokenUsage.output) continue;
+
+        const messageId = payload.message_id;
+        if (messageId) {
+          if (seenMessageIds.has(messageId)) continue;
+          seenMessageIds.add(messageId);
+        }
+
+        const ts = lastTimestamp ? new Date(lastTimestamp) : new Date();
+
+        entries.push({
+          source: 'kimi-code',
+          model: currentModel,
+          project,
+          timestamp: ts,
+          inputTokens: tokenUsage.input_other || 0,
+          outputTokens: tokenUsage.output || 0,
+          cachedInputTokens: tokenUsage.input_cache_read || 0,
+          reasoningOutputTokens: 0,
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}

package/src/parsers/openclaw.js

@@ -1,7 +1,7 @@
 import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { aggregateToBuckets } from './index.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
 
 // OpenClaw stores data at ~/.openclaw/agents/<agentId>/sessions/*.jsonl
 // Legacy paths: ~/.clawdbot, ~/.moltbot, ~/.moldbot
@@ -22,6 +22,7 @@ function getTokens(usage, ...keys) {
 
 export async function parse() {
   const entries = [];
+  const sessionEvents = [];
 
   for (const root of POSSIBLE_ROOTS) {
     const agentsDir = join(root, 'agents');
@@ -62,19 +63,27 @@ export async function parse() {
           try {
             const obj = JSON.parse(line);
 
-            // Only process message entries with assistant role
             if (obj.type !== 'message') continue;
             const msg = obj.message;
-            if (!msg || msg.role !== 'assistant') continue;
-
-            const usage = msg.usage;
-            if (!usage) continue;
+            if (!msg) continue;
 
             const timestamp = obj.timestamp || msg.timestamp;
             if (!timestamp) continue;
             const ts = new Date(typeof timestamp === 'number' ? timestamp : timestamp);
             if (isNaN(ts.getTime())) continue;
 
+            sessionEvents.push({
+              sessionId: filePath,
+              source: 'openclaw',
+              project,
+              timestamp: ts,
+              role: msg.role === 'user' ? 'user' : 'assistant',
+            });
+
+            if (msg.role !== 'assistant') continue;
+            const usage = msg.usage;
+            if (!usage) continue;
+
             entries.push({
               source: 'openclaw',
               model: msg.model || obj.model || 'unknown',
@@ -93,5 +102,5 @@ export async function parse() {
     }
   }
 
-  return aggregateToBuckets(entries);
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }

package/src/parsers/opencode.js

@@ -2,7 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
-import { aggregateToBuckets } from './index.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
 
 const DATA_DIR = join(homedir(), '.local', 'share', 'opencode');
 const DB_PATH = join(DATA_DIR, 'opencode.db');
@@ -24,12 +24,14 @@ export async function parse() {
 }
 
 function parseFromSqlite() {
-  // Build WHERE clause: only messages with token data
-  const conditions = [
-    "(json_extract(data, '$.tokens.input') > 0 OR json_extract(data, '$.tokens.output') > 0)",
-  ];
-
-  const query = `SELECT data FROM message WHERE ${conditions.join(' AND ')}`;
+  const query = `SELECT
+    session_id as sessionID,
+    json_extract(data, '$.role') as role,
+    json_extract(data, '$.time.created') as created,
+    json_extract(data, '$.modelID') as modelID,
+    json_extract(data, '$.tokens') as tokens,
+    json_extract(data, '$.path.root') as rootPath
+    FROM message`;
 
   let output;
   try {
@@ -46,7 +48,7 @@ function parseFromSqlite() {
   }
 
   output = output.trim();
-  if (!output || output === '[]') return [];
+  if (!output || output === '[]') return { buckets: [], sessions: [] };
 
   let rows;
   try {
@@ -56,29 +58,34 @@ function parseFromSqlite() {
   }
 
   const entries = [];
+  const sessionEvents = [];
   for (const row of rows) {
-    let data;
+    const timestamp = new Date(row.created);
+    if (isNaN(timestamp.getTime())) continue;
+
+    const project = row.rootPath ? basename(row.rootPath) : 'unknown';
+    const sessionId = row.sessionID || 'unknown';
+
+    sessionEvents.push({
+      sessionId,
+      source: 'opencode',
+      project,
+      timestamp,
+      role: row.role === 'user' ? 'user' : 'assistant',
+    });
+
+    if (!row.modelID) continue;
+    let tokens;
     try {
-      data = JSON.parse(row.data);
+      tokens = typeof row.tokens === 'string' ? JSON.parse(row.tokens) : row.tokens;
     } catch {
       continue;
     }
-
-    if (!data.modelID) continue;
-
-    const tokens = data.tokens;
-    if (!tokens) continue;
-    if (!tokens.input && !tokens.output) continue;
-
-    const timestamp = new Date(data.time?.created);
-    if (isNaN(timestamp.getTime())) continue;
-
-    const rootPath = data.path?.root;
-    const project = rootPath ? basename(rootPath) : 'unknown';
+    if (!tokens || (!tokens.input && !tokens.output)) continue;
 
     entries.push({
       source: 'opencode',
-      model: data.modelID || 'unknown',
+      model: row.modelID || 'unknown',
       project,
       timestamp,
       inputTokens: tokens.input || 0,
@@ -88,20 +95,20 @@ function parseFromSqlite() {
     });
   }
 
-  return aggregateToBuckets(entries);
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }
 
-/** Legacy parser: reads JSON files from storage/message directories. */
 function parseFromJson() {
-  if (!existsSync(MESSAGES_DIR)) return [];
+  if (!existsSync(MESSAGES_DIR)) return { buckets: [], sessions: [] };
 
   const entries = [];
+  const sessionEvents = [];
   let sessionDirs;
   try {
     sessionDirs = readdirSync(MESSAGES_DIR, { withFileTypes: true })
       .filter(d => d.isDirectory() && d.name.startsWith('ses_'));
   } catch {
-    return [];
+    return { buckets: [], sessions: [] };
   }
 
   for (const sessionDir of sessionDirs) {
@@ -123,18 +130,25 @@ function parseFromJson() {
         continue;
       }
 
-      if (!data.modelID) continue;
-
-      const tokens = data.tokens;
-      if (!tokens) continue;
-      if (!tokens.input && !tokens.output) continue;
-
       const timestamp = new Date(data.time?.created);
       if (isNaN(timestamp.getTime())) continue;
 
       const rootPath = data.path?.root;
       const project = rootPath ? basename(rootPath) : 'unknown';
 
+      sessionEvents.push({
+        sessionId: sessionDir.name,
+        source: 'opencode',
+        project,
+        timestamp,
+        role: data.role === 'user' ? 'user' : 'assistant',
+      });
+
+      if (!data.modelID) continue;
+      const tokens = data.tokens;
+      if (!tokens) continue;
+      if (!tokens.input && !tokens.output) continue;
+
       entries.push({
         source: 'opencode',
         model: data.modelID || 'unknown',
@@ -148,5 +162,5 @@ function parseFromJson() {
     }
   }
 
-  return aggregateToBuckets(entries);
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }

package/src/parsers/qwen-code.js

@@ -0,0 +1,122 @@
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
+import { join, basename, sep } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+/**
+ * Qwen Code parser (Gemini CLI fork).
+ * JSONL at ~/.qwen/tmp/<project_id>/chats/<sessionId>.jsonl
+ * Token fields: usageMetadata.{promptTokenCount, candidatesTokenCount,
+ *   cachedContentTokenCount, thoughtsTokenCount}
+ * Note: promptTokenCount INCLUDES cachedContentTokenCount (needs normalization).
+ */
+
+const QWEN_TMP_DIR = join(homedir(), '.qwen', 'tmp');
+
+function findSessionFiles(baseDir) {
+  const results = [];
+  if (!existsSync(baseDir)) return results;
+
+  try {
+    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const chatsDir = join(baseDir, entry.name, 'chats');
+      if (!existsSync(chatsDir)) continue;
+      try {
+        for (const f of readdirSync(chatsDir)) {
+          if (f.endsWith('.jsonl')) {
+            results.push(join(chatsDir, f));
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+
+function extractProject(cwd, filePath) {
+  if (cwd) {
+    const parts = cwd.split('/').filter(Boolean);
+    if (parts.length > 0) return parts[parts.length - 1];
+  }
+  const tmpPrefix = QWEN_TMP_DIR + sep;
+  if (filePath.startsWith(tmpPrefix)) {
+    const relative = filePath.slice(tmpPrefix.length);
+    const projectId = relative.split(sep)[0];
+    if (projectId) return projectId;
+  }
+  return 'unknown';
+}
+
+export async function parse() {
+  const sessionFiles = findSessionFiles(QWEN_TMP_DIR);
+  if (sessionFiles.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const sessionEvents = [];
+  const seenUuids = new Set();
+
+  for (const filePath of sessionFiles) {
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+
+        const timestamp = obj.timestamp;
+        if (!timestamp) continue;
+        const ts = new Date(timestamp);
+        if (isNaN(ts.getTime())) continue;
+
+        if (obj.type === 'user' || obj.type === 'assistant') {
+          sessionEvents.push({
+            sessionId: filePath,
+            source: 'qwen-code',
+            project: extractProject(obj.cwd, filePath),
+            timestamp: ts,
+            role: obj.type === 'user' ? 'user' : 'assistant',
+          });
+        }
+
+        if (obj.type !== 'assistant') continue;
+        const usage = obj.usageMetadata;
+        if (!usage) continue;
+        if (usage.promptTokenCount == null && usage.candidatesTokenCount == null) continue;
+
+        const uuid = obj.uuid;
+        if (uuid) {
+          if (seenUuids.has(uuid)) continue;
+          seenUuids.add(uuid);
+        }
+
+        const cached = usage.cachedContentTokenCount || 0;
+        const thoughts = usage.thoughtsTokenCount || 0;
+
+        entries.push({
+          source: 'qwen-code',
+          model: obj.model || 'unknown',
+          project: extractProject(obj.cwd, filePath),
+          timestamp: ts,
+          inputTokens: (usage.promptTokenCount || 0) - cached,
+          outputTokens: (usage.candidatesTokenCount || 0) - thoughts,
+          cachedInputTokens: cached,
+          reasoningOutputTokens: thoughts,
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
+}

package/src/sync.js

@@ -26,28 +26,45 @@ export async function runSync({ throws = false, quiet = false } = {}) {
   }
 
   const allBuckets = [];
+  const allSessions = [];
+  const parserResults = [];
 
   for (const [source, parse] of Object.entries(parsers)) {
     try {
-      const buckets = await parse();
-      if (buckets.length > 0) {
-        allBuckets.push(...buckets);
+      const result = await parse();
+      const buckets = Array.isArray(result) ? result : result.buckets;
+      const sessions = Array.isArray(result) ? [] : (result.sessions || []);
+      if (buckets.length > 0) allBuckets.push(...buckets);
+      if (sessions.length > 0) allSessions.push(...sessions);
+      if (buckets.length > 0 || sessions.length > 0) {
+        parserResults.push({ source, buckets: buckets.length, sessions: sessions.length });
       }
     } catch (err) {
       process.stderr.write(`warn: ${source} parser failed: ${err.message}\n`);
     }
   }
 
-  if (allBuckets.length === 0) {
+  if (allBuckets.length === 0 && allSessions.length === 0) {
     if (!quiet) console.log('No new usage data found.');
     return 0;
   }
 
-  // Tag every bucket with this machine's hostname
+  if (!quiet && parserResults.length > 0) {
+    for (const p of parserResults) {
+      const parts = [];
+      if (p.buckets > 0) parts.push(`${p.buckets} buckets`);
+      if (p.sessions > 0) parts.push(`${p.sessions} sessions`);
+      console.log(`  ${p.source}: ${parts.join(', ')}`);
+    }
+  }
+
   const host = osHostname().replace(/\.local$/, '');
   for (const b of allBuckets) {
     b.hostname = host;
   }
+  for (const s of allSessions) {
+    s.hostname = host;
+  }
 
   // Privacy: check if user allows project name upload
   const apiUrl = config.apiUrl || 'https://vibecafe.ai';
@@ -61,32 +78,57 @@ export async function runSync({ throws = false, quiet = false } = {}) {
     for (const b of allBuckets) {
       b.project = 'unknown';
     }
+    for (const s of allSessions) {
+      s.project = 'unknown';
+    }
   }
 
   let totalIngested = 0;
-  const totalBatches = Math.ceil(allBuckets.length / BATCH_SIZE);
+  let totalSessionsSynced = 0;
+  const totalBatches = Math.ceil(Math.max(allBuckets.length, 1) / BATCH_SIZE);
 
-  console.log(`Uploading ${allBuckets.length} buckets (${totalBatches} batch${totalBatches > 1 ? 'es' : ''})...`);
+  const parts = [];
+  if (allBuckets.length > 0) parts.push(`${allBuckets.length} buckets`);
+  if (allSessions.length > 0) parts.push(`${allSessions.length} sessions`);
+  console.log(`Uploading ${parts.join(' + ')} (${totalBatches} batch${totalBatches > 1 ? 'es' : ''})...`);
 
   try {
-    for (let i = 0; i < allBuckets.length; i += BATCH_SIZE) {
+    for (let i = 0; i < Math.max(allBuckets.length, 1); i += BATCH_SIZE) {
       const batch = allBuckets.slice(i, i + BATCH_SIZE);
       const batchNum = Math.floor(i / BATCH_SIZE) + 1;
       const prefix = totalBatches > 1 ? `  [${batchNum}/${totalBatches}] ` : '  ';
+      const batchSessions = i === 0 ? allSessions : undefined;
 
       const result = await ingest(apiUrl, config.apiKey, batch, {
         onProgress(sent, total) {
           const pct = Math.round((sent / total) * 100);
           process.stdout.write(`\r${prefix}${formatBytes(sent)}/${formatBytes(total)} (${pct}%)\x1b[K`);
         },
-      });
+      }, batchSessions);
       totalIngested += result.ingested ?? batch.length;
+      totalSessionsSynced += result.sessions ?? 0;
     }
 
     if (totalBatches > 1 || allBuckets.length > 0) {
       process.stdout.write('\n');
     }
-    console.log(`Synced ${totalIngested} buckets.`);
+    const syncParts = [`${totalIngested} buckets`];
+    if (totalSessionsSynced > 0) syncParts.push(`${totalSessionsSynced} sessions`);
+    console.log(`Synced ${syncParts.join(' + ')}.`);
+
+    if (!quiet && totalSessionsSynced > 0) {
+      const totalActive = allSessions.reduce((s, x) => s + x.activeSeconds, 0);
+      const totalDuration = allSessions.reduce((s, x) => s + x.durationSeconds, 0);
+      const totalMsgs = allSessions.reduce((s, x) => s + x.messageCount, 0);
+      const fmtTime = (secs) => {
+        if (secs < 60) return `${secs}s`;
+        const h = Math.floor(secs / 3600);
+        const m = Math.floor((secs % 3600) / 60);
+        return h > 0 ? (m > 0 ? `${h}h ${m}m` : `${h}h`) : `${m}m`;
+      };
+      console.log(`  active: ${fmtTime(totalActive)} / total: ${fmtTime(totalDuration)}, ${totalMsgs} messages`);
+    }
+
     return totalIngested;
   } catch (err) {
     if (err.message === 'UNAUTHORIZED') {

package/src/{hooks.js → tools.js}

@@ -28,6 +28,16 @@ export const TOOLS = [
     id: 'openclaw',
     dataDir: join(homedir(), '.openclaw', 'agents'),
   },
+  {
+    name: 'Qwen Code',
+    id: 'qwen-code',
+    dataDir: join(homedir(), '.qwen', 'tmp'),
+  },
+  {
+    name: 'Kimi Code',
+    id: 'kimi-code',
+    dataDir: join(homedir(), '.kimi', 'sessions'),
+  },
 ];
 
 export function detectInstalledTools() {