@vibe-cafe/vibe-usage 0.10.8 → 0.10.10

package/README.md

@@ -69,13 +69,14 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | MiMoCode | `$MIMOCODE_HOME/data/mimocode.db`, `$XDG_DATA_HOME/mimocode/mimocode.db`, or `~/.local/share/mimocode/mimocode.db` (SQLite; exact input, output, reasoning, and cache-read tokens from assistant messages; honors `MIMOCODE_DB`; cache-write tokens are included in input usage) |
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |
+| DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads multi-frame Zstandard `session.jsonl.zstd` logs (built-in `node:zlib` zstd on Node ≥ 22.15, `zstd` CLI fallback) and plain `session.jsonl` logs. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Seed replay before the last `session/end-seed` marker is skipped so resumed/forked history is not double-counted. |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
 | Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
 | Cline | Standalone `~/.cline/` plus `<host>/User/globalStorage/saoudrizwan.claude-dev/` across VSCode-fork hosts; migrated copies are deduplicated and empty leftover extension stores no longer count as installed |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
 | Trae CLI | macOS: `~/Library/Caches/trae-cli/sessions/`; Windows: `%LOCALAPPDATA%/trae-cli/cache/sessions/`; Linux: `~/.cache/trae-cli/sessions/` (CLI telemetry only; Trae IDE/Trae Work chats are not supported) |
 | Antigravity | App 2.0 `~/.gemini/antigravity/conversations/*.db` and `agy` CLI `~/.gemini/antigravity-cli/conversations/*.db` are parsed offline (tokens, real model display name, project, sessions); legacy App `.pb` history falls back to Connect RPC while the language server is running |
-| WorkBuddy | macOS WorkBuddy 5.3.11+: `~/.workbuddy/projects/**/*.jsonl` (fixture/relocation override: `VIBE_USAGE_WORKBUDDY_DIRS`). Uses completed assistant requests and their actual `providerData.requestModelId`, so Auto-routed requests can produce multiple model buckets. Splits cache reads and reasoning from inclusive input/output totals, deduplicates copied request IDs, and extracts local session timing without uploading message content. |
+| WorkBuddy | Current releases: `~/.workbuddy-ai/projects/**/*.jsonl`; legacy releases: `~/.workbuddy/projects/**/*.jsonl` (fixture/relocation override: `VIBE_USAGE_WORKBUDDY_DIRS`). Reads usage-bearing completed assistant and `function_call` records, using the routed model identifier exposed as `providerData.requestModelId`. Splits cache reads and reasoning from inclusive input/output totals, deduplicates copied record IDs, and extracts local session timing without uploading message content. |
 | ZCode | `~/.zcode/cli/db/db.sqlite` (SQLite; reads the `message` table for per-message tokens, model, and project `cwd`/`root`, joined to `session.directory`) |
 
 ## How It Works

package/package.json

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

package/src/parsers/dsh.js

@@ -0,0 +1,454 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import zlib from 'node:zlib';
+import { getDshSessionsDir } from '../tools.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+const SOURCE = 'dsh';
+
+// DeepSeek Harness session-log format version this parser understands. DeepSeek
+// Harness is currently in developer preview and is iterating rapidly — THERE
+// WILL BE COMPATIBILITY-BREAKING CHANGES. When the CLI bumps the header
+// `version` field, bump this constant (and the record-shape mapping below)
+// after re-checking the on-disk format instead of guessing against stale
+// assumptions.
+const SESSION_FORMAT_VERSION = 0;
+
+// Safety cap for a single session log. DSH stores many small zstd frames per
+// file; anything beyond this is either a runaway log or not a session file.
+const MAX_SESSION_FILE_BYTES = 256 * 1024 * 1024;
+
+// Maximum decompressed size for one session log, for both decoder paths.
+const MAX_DECOMPRESSED_SESSION_BYTES = 512 * 1024 * 1024;
+
+// Zstandard frame magic (0xFD2FB528 little-endian) and the skippable-frame
+// magic range (0x184D2A50–0x184D2A5F), per RFC 8878.
+const ZSTD_MAGIC = 0xfd2fb528;
+const SKIPPABLE_MAGIC_MIN = 0x184d2a50;
+const SKIPPABLE_MAGIC_MAX = 0x184d2a5f;
+
+const MAX_WARNINGS = 20;
+
+/**
+ * Split concatenated Zstandard input into independently decodable frame ranges.
+ *
+ * DSH writes one frame for the header and one per durable append batch. Node's
+ * one-shot zstd API decodes only one standard frame, so each standard frame is
+ * returned as an independent `{ start, end }` range. Complete skippable frames
+ * are omitted without joining the standard frames around them. An incomplete
+ * tail is ignored, matching DSH's append-recovery boundary.
+ *
+ * @param {Buffer} buffer
+ * @returns {{ start: number, end: number }[]}
+ */
+export function splitZstdFrames(buffer) {
+  const frames = [];
+  let pos = 0;
+  while (pos < buffer.length) {
+    if (pos + 4 > buffer.length) break;
+    const magic = buffer.readUInt32LE(pos);
+    if (magic >= SKIPPABLE_MAGIC_MIN && magic <= SKIPPABLE_MAGIC_MAX) {
+      if (pos + 8 > buffer.length) break;
+      const end = pos + 8 + buffer.readUInt32LE(pos + 4);
+      if (end > buffer.length) break;
+      pos = end;
+      continue;
+    }
+    if (magic !== ZSTD_MAGIC) {
+      throw new Error('invalid Zstandard frame magic at byte ' + pos);
+    }
+
+    const start = pos;
+    pos += 4;
+    if (pos >= buffer.length) break;
+    const descriptor = buffer[pos++];
+    if ((descriptor & 0x18) !== 0) {
+      throw new Error('reserved Zstandard frame-header bit at byte ' + (pos - 1));
+    }
+    const singleSegment = (descriptor & 0x20) !== 0;
+    const checksum = (descriptor & 0x04) !== 0;
+    const dictionaryFlag = descriptor & 0x03;
+    const contentSizeFlag = descriptor >>> 6;
+
+    const dictionaryBytes = dictionaryFlag === 3 ? 4 : dictionaryFlag;
+    const contentSizeBytes = contentSizeFlag === 0
+      ? (singleSegment ? 1 : 0)
+      : 1 << contentSizeFlag;
+    const remainingHeaderBytes = (singleSegment ? 0 : 1) + dictionaryBytes + contentSizeBytes;
+    if (pos + remainingHeaderBytes > buffer.length) break;
+    pos += remainingHeaderBytes;
+
+    for (;;) {
+      if (pos + 3 > buffer.length) return frames;
+      const blockHeader = buffer.readUIntLE(pos, 3);
+      pos += 3;
+      const lastBlock = (blockHeader & 1) !== 0;
+      const blockType = (blockHeader >>> 1) & 0x03;
+      const blockSize = blockHeader >>> 3;
+      if (blockType === 0x03) {
+        throw new Error('reserved Zstandard block type at byte ' + (pos - 3));
+      }
+      // An RLE block stores one encoded byte; blockSize is its decoded size.
+      const payloadBytes = blockType === 0x01 ? 1 : blockSize;
+      if (pos + payloadBytes > buffer.length) return frames;
+      pos += payloadBytes;
+      if (lastBlock) break;
+    }
+
+    if (checksum) {
+      if (pos + 4 > buffer.length) return frames;
+      pos += 4;
+    }
+    frames.push({ start, end: pos });
+  }
+  return frames;
+}
+
+const hasBuiltinZstd = typeof zlib.zstdDecompressSync === 'function';
+let zstdCliProbe = null;
+function hasZstdCli() {
+  if (zstdCliProbe !== null) return zstdCliProbe;
+  try {
+    execFileSync('zstd', ['--version'], { stdio: 'ignore', timeout: 5000 });
+    zstdCliProbe = true;
+  } catch {
+    zstdCliProbe = false;
+  }
+  return zstdCliProbe;
+}
+
+const ZSTD_HINT =
+  'decompress with node:zlib zstd (Node >= 22.15) or install the zstd CLI';
+
+/** Decompress the complete frames captured from one DSH session log. */
+function decompressSessionLog(buffer, file) {
+  const frames = splitZstdFrames(buffer);
+  if (frames.length === 0) {
+    throw new Error('no complete zstd frames found in ' + relative(process.cwd(), file));
+  }
+
+  if (hasBuiltinZstd) {
+    const parts = [];
+    let remaining = MAX_DECOMPRESSED_SESSION_BYTES;
+    for (const { start, end } of frames) {
+      if (remaining <= 0) throw new Error('decompressed session log is too large');
+      const part = zlib.zstdDecompressSync(buffer.subarray(start, end), {
+        maxOutputLength: remaining,
+      });
+      parts.push(part);
+      remaining -= part.length;
+    }
+    return Buffer.concat(parts).toString('utf8');
+  }
+
+  if (!hasZstdCli()) {
+    const error = new Error('zstd unavailable for ' + file + ': ' + ZSTD_HINT);
+    error.code = 'ENOENT';
+    throw error;
+  }
+
+  const first = frames[0];
+  const last = frames.at(-1);
+  const contiguous = frames.every((frame, index) =>
+    index === 0 || frame.start === frames[index - 1].end
+  );
+  const completeInput = contiguous
+    ? buffer.subarray(first.start, last.end)
+    : Buffer.concat(frames.map(({ start, end }) => buffer.subarray(start, end)));
+  return execFileSync('zstd', ['-d', '-c'], {
+    input: completeInput,
+    maxBuffer: MAX_DECOMPRESSED_SESSION_BYTES,
+    stdio: ['pipe', 'pipe', 'ignore'],
+  }).toString('utf8');
+}
+
+function projectFromCwd(cwd) {
+  if (typeof cwd !== 'string') return 'unknown';
+  const trimmed = cwd.trim().replace(/[\\/]+$/, '');
+  if (!trimmed) return 'unknown';
+  const name = basename(trimmed.replace(/\\/g, '/'));
+  return name || 'unknown';
+}
+
+function toCount(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+function isUsageRecord(rec) {
+  return rec.type === 'assistant/message' && rec.data && typeof rec.data === 'object';
+}
+
+function isUserMessageRecord(rec) {
+  return (
+    rec.type === 'user/message' &&
+    rec.data &&
+    typeof rec.data === 'object' &&
+    rec.data.source?.kind === 'user'
+  );
+}
+
+/**
+ * Parse one decompressed session log into flat entries/events.
+ *
+ * Layout (DeepSeek Harness session-persistence-jsonl):
+ *   line 0: {"type":"session","version":0,"id":...,"createdAt":...,"cwd":...,...}
+ *   ... possibly a resumed/forked seed replay, then ...
+ *   {"type":"session/end-seed",...}          (absent in fresh sessions)
+ *   {"type":"assistant/message","data":{"turn","step","message":{"source":
+ *     {"kind":"model","provider","model"},...},"usage":{"inputTokens",
+ *     "outputTokens","cacheReadTokens","cacheWriteTokens",
+ *     "reasoningTokens"}},...}
+ *
+ * When a session is resumed (or forked) the stored log begins with a replay of
+ * the seed history. Everything before the LAST session/end-seed marker is a
+ * replay of records that were already counted from their original file, so it
+ * must be skipped or the same usage would be counted twice.
+ *
+ * usage.outputTokens includes reasoningTokens (verified against the
+ * session_projcache totals DSH itself maintains), so reasoning is split out of
+ * output before aggregation, like the Pi-family parsers.
+ */
+function parseSessionText(text) {
+  const entries = [];
+  const events = [];
+  const lines = text.split('\n');
+
+  let header = null;
+  let endSeedIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].length === 0) continue;
+    let rec;
+    try {
+      rec = JSON.parse(lines[i]);
+    } catch {
+      continue; // torn final line: keep the complete records
+    }
+    if (rec && typeof rec === 'object') {
+      if (header === null && rec.type === 'session') header = rec;
+      if (rec.type === 'session/end-seed') endSeedIndex = i;
+    }
+  }
+
+  if (!header || typeof header.id !== 'string' || header.id.length === 0) {
+    throw new Error('missing session header record');
+  }
+  if (header.version !== SESSION_FORMAT_VERSION) {
+    const error = new Error(
+      'session ' + header.id + ' uses format version ' + header.version +
+      ' (parser supports ' + SESSION_FORMAT_VERSION + ')',
+    );
+    error.code = 'UNSUPPORTED_FORMAT_VERSION';
+    throw error;
+  }
+
+  const sessionId = header.id;
+  const project = projectFromCwd(header.cwd);
+
+  for (let i = 0; i < lines.length; i++) {
+    if (i <= endSeedIndex) continue;
+    if (lines[i].length === 0) continue;
+    let rec;
+    try {
+      rec = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    if (!rec || typeof rec !== 'object') continue;
+    const timestamp = new Date(rec.time);
+    if (Number.isNaN(timestamp.getTime())) continue;
+
+    if (isUserMessageRecord(rec)) {
+      events.push({ sessionId, source: SOURCE, project, timestamp, role: 'user' });
+      continue;
+    }
+    if (!isUsageRecord(rec)) continue;
+
+    // Every assistant/message marks the end of a billable step, even when its
+    // usage block is missing.
+    events.push({ sessionId, source: SOURCE, project, timestamp, role: 'assistant' });
+
+    const usage = rec.data.usage;
+    if (!usage || typeof usage !== 'object') continue;
+    // Harness counts are disjoint. The common bucket model has no cache-write
+    // column, so cache writes join uncached input, matching the other parsers.
+    const inputTokens = toCount(usage.inputTokens) + toCount(usage.cacheWriteTokens);
+    const cachedInputTokens = toCount(usage.cacheReadTokens);
+    const totalOutputTokens = toCount(usage.outputTokens);
+    const reasoningOutputTokens = Math.min(
+      totalOutputTokens,
+      toCount(usage.reasoningTokens),
+    );
+    const outputTokens = totalOutputTokens - reasoningOutputTokens;
+    if (inputTokens + cachedInputTokens + reasoningOutputTokens + outputTokens === 0) continue;
+
+    const model =
+      typeof rec.data.message?.source?.model === 'string' && rec.data.message.source.model
+        ? rec.data.message.source.model
+        : 'unknown';
+
+    entries.push({
+      source: SOURCE,
+      model,
+      project,
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+    });
+  }
+
+  return { sessionId, entries, events };
+}
+
+/** List session log files under a DSH sessions root (session.jsonl[.zstd]). */
+function listSessionFiles(sessionsDir, onFailure) {
+  const files = [];
+  const projectKeys = readdirSync(sessionsDir, { withFileTypes: true })
+    .sort((a, b) => a.name.localeCompare(b.name));
+  for (const projectKey of projectKeys) {
+    if (!projectKey.isDirectory()) continue;
+    const projectDir = join(sessionsDir, projectKey.name);
+    let sessionDirs;
+    try {
+      sessionDirs = readdirSync(projectDir, { withFileTypes: true })
+        .sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error) {
+      onFailure(
+        'dsh: cannot read project directory ' + projectKey.name +
+        ' (' + (error?.code || error?.message || 'read failed') + ')',
+      );
+      continue;
+    }
+    for (const sessionDir of sessionDirs) {
+      if (!sessionDir.isDirectory()) continue;
+      const sessionPath = join(projectDir, sessionDir.name);
+      for (const name of ['session.jsonl.zstd', 'session.jsonl']) {
+        const file = join(sessionPath, name);
+        try {
+          if (statSync(file).isFile()) {
+            files.push({ file, compressed: name.endsWith('.zstd') });
+            break;
+          }
+        } catch (error) {
+          if (error?.code !== 'ENOENT') {
+            onFailure(
+              'dsh: cannot inspect ' + relative(sessionsDir, file) +
+              ' (' + (error?.code || error?.message || 'stat failed') + ')',
+            );
+            break;
+          }
+        }
+      }
+    }
+  }
+  return files;
+}
+
+/**
+ * DeepSeek Harness (dsh) parser.
+ *
+ * Reads $DSH_HOME/sessions/<project-key>/session-<id>/session.jsonl.zstd
+ * (default ~/.dsh, fixture/relocation override VIBE_USAGE_DSH_SESSIONS).
+ * Zstandard session logs are multi-frame; node:zlib zstd (Node >= 22.15)
+ * decodes one frame per call, so the buffer is walked frame-by-frame, with a
+ * `zstd` CLI fallback for older Node.
+ */
+export async function parse() {
+  const sessionsDir = getDshSessionsDir();
+  if (!existsSync(sessionsDir)) return { buckets: [], sessions: [] };
+
+  const warnings = [];
+  let anyFailure = false;
+  const recordFailure = (message) => {
+    anyFailure = true;
+    if (warnings.length < MAX_WARNINGS && !warnings.includes(message)) {
+      warnings.push(message);
+    }
+  };
+
+  let files;
+  try {
+    files = listSessionFiles(sessionsDir, recordFailure);
+  } catch (error) {
+    recordFailure(
+      'dsh: cannot read sessions directory ' + sessionsDir +
+      ' (' + (error?.code || error?.message || 'read failed') + ')',
+    );
+    return { buckets: [], sessions: [], skipped: true, warnings };
+  }
+  if (files.length === 0) {
+    const result = { buckets: [], sessions: [] };
+    if (anyFailure) Object.assign(result, { skipped: true, warnings });
+    return result;
+  }
+
+  const perSession = new Map(); // sessionId -> parsed view (largest complete log wins)
+  for (const { file, compressed } of files) {
+    let text;
+    try {
+      const stat = statSync(file);
+      if (!stat.isFile()) throw new Error('session log is no longer a file');
+      if (stat.size > MAX_SESSION_FILE_BYTES) {
+        throw new Error('session log too large (' + stat.size + ' bytes)');
+      }
+      const buffer = readFileSync(file);
+      if (buffer.length < stat.size) throw new Error('session log changed while reading');
+      const snapshot = buffer.length === stat.size ? buffer : buffer.subarray(0, stat.size);
+      text = compressed ? decompressSessionLog(snapshot, file) : snapshot.toString('utf8');
+    } catch (error) {
+      const reason = error?.code === 'ENOENT' && !hasBuiltinZstd && compressed
+        ? ZSTD_HINT
+        : error?.message || String(error);
+      recordFailure('dsh: skipping ' + relative(process.cwd(), file) + ' (' + reason + ')');
+      continue;
+    }
+
+    let parsed;
+    try {
+      parsed = parseSessionText(text);
+    } catch (error) {
+      recordFailure(
+        'dsh: skipping ' + relative(process.cwd(), file) + ' (' + error.message + ')',
+      );
+      continue;
+    }
+
+    const weight = text.length;
+    const previous = perSession.get(parsed.sessionId);
+    if (!previous || weight > previous.weight) {
+      perSession.set(parsed.sessionId, { ...parsed, weight });
+    }
+  }
+
+  const entries = [];
+  const eventsBySession = new Map();
+  for (const parsed of perSession.values()) {
+    entries.push(...parsed.entries);
+    for (const event of parsed.events) {
+      if (!eventsBySession.has(event.sessionId)) eventsBySession.set(event.sessionId, []);
+      eventsBySession.get(event.sessionId).push(event);
+    }
+  }
+
+  // Only sessions with at least one real user prompt are meaningful timing
+  // data; assistant-only logs (e.g. plugin-driven sessions) are skipped.
+  const events = [];
+  for (const sessionEvents of eventsBySession.values()) {
+    if (sessionEvents.some((event) => event.role === 'user')) {
+      events.push(...sessionEvents);
+    }
+  }
+
+  const result = {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(events),
+  };
+  if (warnings.length > 0 || anyFailure) {
+    result.skipped = anyFailure;
+    result.warnings = warnings;
+  }
+  return result;
+}

package/src/parsers/index.js

@@ -17,6 +17,7 @@ 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';
@@ -44,6 +45,7 @@ export const parsers = {
   'amp': parseAmp,
   'alma': parseAlma,
   'droid': parseDroid,
+  'dsh': parseDsh,
   'antigravity': parseAntigravity,
   'trae-cli': parseTraeCli,
   'hermes': parseHermes,

package/src/parsers/workbuddy.js

@@ -40,7 +40,12 @@ function projectFromFile(filePath, projectsDir) {
 function projectFromRecord(record) {
   const cwd = typeof record.cwd === 'string' ? record.cwd.trim() : '';
   if (!cwd) return null;
-  return basename(cwd.replace(/[\\/]+$/, '')) || null;
+  const parts = cwd
+    .replace(/[\\/]+$/, '')
+    .split(/[\\/]/)
+    .filter(Boolean)
+    .filter(part => !/^[a-zA-Z]:$/.test(part));
+  return parts.at(-1) || null;
 }
 
 function findJsonlFiles(dir, ctx) {
@@ -115,6 +120,13 @@ function isCompletedAssistant(record) {
   return status === 'completed' || status === 'complete' || status === 'success';
 }
 
+function isUsageRecord(record) {
+  return isCompletedAssistant(record)
+    || (record.type === 'function_call'
+      && record.providerData
+      && typeof record.providerData === 'object');
+}
+
 function modelFor(record) {
   const providerData = record.providerData && typeof record.providerData === 'object'
     ? record.providerData
@@ -156,20 +168,24 @@ function usageFor(record) {
 
   const inputDetails = primary?.input_details
     ?? primary?.inputDetails
-    ?? primary?.inputTokensDetails;
+    ?? primary?.inputTokensDetails
+    ?? raw?.prompt_tokens_details;
   const outputDetails = primary?.output_details
     ?? primary?.outputDetails
-    ?? primary?.outputTokensDetails;
+    ?? primary?.outputTokensDetails
+    ?? raw?.completion_tokens_details;
   const cachedInputTokens = firstDetailValue(inputDetails, 'cached_tokens', 'cachedTokens')
     || finite(
-      primary?.cache_read_input_tokens
+      primary?.cachedInputTokens
+      ?? primary?.cache_read_input_tokens
       ?? primary?.cacheReadInputTokens
       ?? raw?.prompt_cache_hit_tokens
       ?? raw?.cache_read_input_tokens
     );
   const reasoningOutputTokens = firstDetailValue(outputDetails, 'reasoning_tokens', 'reasoningTokens')
     || finite(
-      primary?.completion_thinking_tokens
+      primary?.reasoningOutputTokens
+      ?? primary?.completion_thinking_tokens
       ?? primary?.reasoning_tokens
       ?? primary?.reasoningTokens
       ?? raw?.completion_thinking_tokens
@@ -207,10 +223,16 @@ function timestampFor(record) {
   );
 }
 
+function sessionEventsWithPrompts(events) {
+  const sessionsWithUsers = new Set(
+    events.filter(event => event.role === 'user').map(event => event.sessionId)
+  );
+  return events.filter(event => sessionsWithUsers.has(event.sessionId));
+}
+
 export async function parse() {
   const entriesById = new Map();
-  const eventsById = new Map();
-  const anonymousEvents = [];
+  const eventsByKey = new Map();
   const ctx = { skipped: false, warnings: [] };
   const projectDirs = [...new Set(findWorkbuddyDataDirs().map(root => (
     basename(root) === 'projects' ? root : join(root, 'projects')
@@ -226,7 +248,7 @@ export async function parse() {
         continue;
       }
 
-      const sessionId = basename(filePath, '.jsonl');
+      const fallbackSessionId = basename(filePath, '.jsonl');
       let project = projectFromFile(filePath, projectsDir);
       const fileEntries = [];
       const fileEvents = [];
@@ -236,14 +258,22 @@ export async function parse() {
         const timestamp = timestampFor(record);
         const id = recordId(record);
         const role = roleFor(record);
+        const explicitSessionId = record.sessionId ?? record.session_id;
+        const sessionId = explicitSessionId == null || String(explicitSessionId).trim() === ''
+          ? fallbackSessionId
+          : String(explicitSessionId);
 
-        if (timestamp && (role === 'user' || isCompletedAssistant(record))) {
-          fileEvents.push({ id, sessionId, timestamp, role });
+        const usage = isUsageRecord(record) ? usageFor(record) : null;
+        const eventRole = role === 'user'
+          ? 'user'
+          : isCompletedAssistant(record) || (record.type === 'function_call' && usage)
+            ? 'assistant'
+            : null;
+        if (timestamp && eventRole) {
+          fileEvents.push({ id, sessionId, timestamp, role: eventRole });
         }
 
-        if (!id || !timestamp || !isCompletedAssistant(record)) return;
-        const usage = usageFor(record);
-        if (!usage) return;
+        if (!id || !timestamp || !usage) return;
         fileEntries.push({
           id,
           score: usage.score,
@@ -272,15 +302,17 @@ export async function parse() {
           timestamp: candidate.timestamp,
           role: candidate.role,
         };
-        if (candidate.id) eventsById.set(candidate.id, event);
-        else anonymousEvents.push(event);
+        const key = candidate.id
+          ? `id:${candidate.sessionId}:${candidate.id}:${candidate.role}`
+          : `fallback:${candidate.sessionId}:${candidate.role}:${candidate.timestamp.toISOString()}`;
+        eventsByKey.set(key, event);
       }
     }
   }
 
   return {
     buckets: aggregateToBuckets([...entriesById.values()].map(({ entry }) => entry)),
-    sessions: extractSessions([...eventsById.values(), ...anonymousEvents]),
+    sessions: extractSessions(sessionEventsWithPrompts([...eventsByKey.values()])),
     ...(ctx.skipped ? { skipped: true } : {}),
     ...(ctx.warnings.length > 0 ? { warnings: ctx.warnings } : {}),
   };

package/src/tools.js

@@ -120,6 +120,28 @@ function findKimiCodeDataDirs() {
   ].filter(existsSync);
 }
 
+/** DeepSeek Harness home: DSH_HOME env (same as the dsh CLI) or ~/.dsh. */
+export function getDshHome(env = process.env) {
+  const explicit = env.DSH_HOME?.trim();
+  if (!explicit) return join(homedir(), '.dsh');
+  if (explicit === '~') return homedir();
+  if (explicit.startsWith('~/') || explicit.startsWith('~\\')) {
+    return resolve(homedir(), explicit.slice(2));
+  }
+  return resolve(explicit);
+}
+
+export function getDshSessionsDir() {
+  const testDir = process.env.VIBE_USAGE_DSH_SESSIONS?.trim();
+  if (testDir) return testDir;
+  return join(getDshHome(), 'sessions');
+}
+
+// Detect DeepSeek Harness when its sessions tree exists (or the test override).
+export function findDshDataDirs() {
+  return [getDshSessionsDir()].filter(existsSync);
+}
+
 export function getMimocodeDbPath(env = process.env) {
   if (env.MIMOCODE_HOME && !isAbsolute(env.MIMOCODE_HOME)) {
     throw new Error(`MIMOCODE_HOME must be an absolute path, got: ${JSON.stringify(env.MIMOCODE_HOME)}`);
@@ -298,6 +320,12 @@ export const TOOLS = [
     id: 'droid',
     dataDir: join(homedir(), '.factory', 'sessions'),
   },
+  {
+    name: 'DeepSeek Harness',
+    id: 'dsh',
+    dataDir: getDshSessionsDir(),
+    detectDataDirs: findDshDataDirs,
+  },
   {
     name: 'Antigravity',
     id: 'antigravity',
@@ -335,7 +363,7 @@ export const TOOLS = [
   {
     name: 'WorkBuddy',
     id: 'workbuddy',
-    dataDir: join(homedir(), '.workbuddy', 'projects'),
+    dataDir: join(homedir(), '.workbuddy-ai', 'projects'),
     detectDataDirs: () => findWorkbuddyDataDirs().filter(existsSync),
   },
   {

package/src/workbuddy-roots.js

@@ -1,15 +1,18 @@
 import { delimiter, join } from 'node:path';
 import { homedir } from 'node:os';
 
-export function getDefaultWorkbuddyProjectsDir() {
-  return join(homedir(), '.workbuddy', 'projects');
+export function getDefaultWorkbuddyProjectsDirs(home = homedir()) {
+  return [
+    join(home, '.workbuddy-ai', 'projects'),
+    join(home, '.workbuddy', 'projects'),
+  ];
 }
 
 // Fixture/relocation hook. Entries may name either the WorkBuddy home or its
 // projects/ directory; the parser normalizes both forms.
 export function findWorkbuddyDataDirs() {
   const override = process.env.VIBE_USAGE_WORKBUDDY_DIRS?.trim();
-  if (!override) return [getDefaultWorkbuddyProjectsDir()];
+  if (!override) return getDefaultWorkbuddyProjectsDirs();
   return [...new Set(
     override
       .split(delimiter)