@vibe-cafe/vibe-usage 0.10.26 → 0.10.28

package/README.md

@@ -80,7 +80,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | 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. Fork/subagent history is de-duplicated from the immutable header: `parentSession` identifies the source and `seedLength` gives the exact leading event boundary. Inherited messages are skipped only when matching source seqs remain in the parent file; missing parents fail open. `session/end-seed` positions are not used because resumes can append the marker after real history. |
+| DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads V0–V3 logs, including `session.v3.jsonl.zstd` from DSH `0.1.5-alpha.2`, with multi-frame Zstandard support (Node ≥ 22.15 built-in, `zstd` CLI fallback) and plain JSONL support. Each session uses its highest `session[.vN].jsonl[.zstd]` generation once, so frozen pre-migration logs are not double-counted. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork history uses V0/V1 `seedLength` or V2/V3's last `session/end-seed` tagged `inherited: true`, and is skipped only when the parent copy confirms it; missing parents retain the sole local history. Unknown versions warn and protect sync state. |
 | Hermes | `$HERMES_HOME/state.db` (default `~/.hermes/state.db`) + `profiles/<name>/state.db` (SQLite, multi-profile). Cache writes join input; reasoning is separated from inclusive output. Usage is currently a cumulative session total attributed to session start: a session spanning several days does **not** yet provide an accurate daily breakdown. |
 | Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
 | Cline | 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 |

package/package.json

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

package/src/parsers/dsh.js

@@ -7,13 +7,14 @@ import { aggregateToBuckets, extractSessions } from './aggregate.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;
+// Verified against deepseek-ai/deepseek-harness tag dsh-v0.1.5-alpha.2:
+// packages/session/session-format/src/filename.ts, session-format-v0-to-v1,
+// session-format-v1-to-v2, session-format-v2-to-v3, and core/session/src/types.ts.
+// V0/V1 use header.seedLength; V2/V3 use a tagged inherited end-seed marker.
+// Re-check the format before accepting another version; never silently read a
+// frozen predecessor when a newer generation is present.
+const MAX_SESSION_FORMAT_VERSION = 3;
+const SESSION_FILENAME = /^session(?:\.v([1-9][0-9]*))?\.jsonl(\.zstd)?$/;
 
 // 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.
@@ -198,18 +199,10 @@ function isUserMessageRecord(rec) {
  *   ... possibly a resumed/forked seed replay, then ...
  *   {"type":"user/message"|"assistant/message","time":...,"data":{...}}
  *
- * DSH (developer preview) writes session/end-seed records in three situations:
- * right after session creation (empty seed), at each resume boundary, and
- * appended at the END of a file when that session becomes the seed for a
- * further resume. The marker's position is therefore NOT a replay boundary —
- * a trailing marker would make "skip everything before the last marker"
- * discard the session's entire real history.
- *
- * Fork/subagent lineage is encoded separately in the immutable header.
- * `parentSession` identifies the source and `seedLength` is the exact number
- * of leading event seqs inherited from it. Only those seqs are skipped, and
- * only while the parent file is also present, so a missing/corrupt source
- * fails open instead of dropping the sole local copy of its usage.
+ * V0/V1 use header.seedLength. Their untagged end-seed markers can appear
+ * after real history and must never be treated as a replay boundary. V2/V3
+ * instead require isSeeded and use the LAST end-seed with data.inherited=true.
+ * Only a proven inherited prefix also present in the parent is skipped.
  *
  * Only user/message (source.kind === 'user') and assistant/message records
  * are kept in the model — they are the only records that produce usage
@@ -220,7 +213,7 @@ function isUserMessageRecord(rec) {
  * session_projcache totals DSH itself maintains), so reasoning is split out of
  * output before aggregation, like the Pi-family parsers.
  */
-function buildSessionModel(text) {
+function buildSessionModel(text, fileVersion) {
   const lines = text.split('\n');
 
   let header = null;
@@ -240,16 +233,23 @@ function buildSessionModel(text) {
   if (!header || typeof header.id !== 'string' || header.id.length === 0) {
     throw new Error('missing session header record');
   }
-  if (header.version !== SESSION_FORMAT_VERSION) {
+  if (!Number.isInteger(header.version) || header.version < 0 || header.version > MAX_SESSION_FORMAT_VERSION) {
     const error = new Error(
       'session ' + header.id + ' uses format version ' + header.version +
-      ' (parser supports ' + SESSION_FORMAT_VERSION + ')',
+      ' (parser supports 0–' + MAX_SESSION_FORMAT_VERSION + ')',
     );
     error.code = 'UNSUPPORTED_FORMAT_VERSION';
     throw error;
   }
+  if (header.version !== fileVersion) {
+    throw new Error('session header format version ' + header.version + ' disagrees with filename version ' + fileVersion);
+  }
+  if (header.version >= 2 && typeof header.isSeeded !== 'boolean') {
+    throw new Error('format v' + header.version + ' session header lacks isSeeded');
+  }
 
   const messages = [];
+  let inheritedSeq = null;
   for (let i = 0; i < lines.length; i++) {
     if (lines[i].length === 0) continue;
     let rec;
@@ -263,8 +263,13 @@ function buildSessionModel(text) {
     if (timeMs == null) continue;
     const seq = Number.isSafeInteger(rec.seq) && rec.seq >= 0 ? rec.seq : null;
 
+    if (header.version >= 2 && rec.type === 'session/end-seed' && rec.data?.inherited === true) {
+      if (seq == null) throw new Error('inherited end-seed marker lacks a valid seq');
+      inheritedSeq = seq;
+    }
+
     if (isUserMessageRecord(rec)) {
-      messages.push({ seq, role: 'user', timeMs, usage: null, model: null });
+      messages.push({ seq, messageId: messageId(rec.data.id), role: 'user', timeMs, usage: null, model: null });
       continue;
     }
     if (!isUsageRecord(rec)) continue;
@@ -273,6 +278,7 @@ function buildSessionModel(text) {
     // usage block is missing; the model keeps it so timing survives.
     messages.push({
       seq,
+      messageId: messageId(rec.data.message?.id),
       role: 'assistant',
       timeMs,
       usage: parseUsage(rec.data.usage),
@@ -283,13 +289,18 @@ function buildSessionModel(text) {
     });
   }
 
+  if (header.version >= 2 && header.isSeeded !== (inheritedSeq !== null)) {
+    throw new Error('isSeeded disagrees with the inherited end-seed marker');
+  }
+
   return {
+    formatVersion: header.version,
     sessionId: header.id,
     parentSessionId:
       typeof header.parentSession === 'string' && header.parentSession
         ? header.parentSession
         : null,
-    seedLength:
+    seedLength: header.version >= 2 ? (inheritedSeq ?? 0) :
       Number.isSafeInteger(header.seedLength) && header.seedLength > 0
         ? header.seedLength
         : 0,
@@ -298,6 +309,10 @@ function buildSessionModel(text) {
   };
 }
 
+function messageId(value) {
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
 /** Record wall-clock time in epoch ms; null when absent/invalid. */
 function recordTimeMs(rec) {
   const t = rec.time;
@@ -337,9 +352,10 @@ function sameUsage(left, right) {
 /**
  * Number of leading child messages inherited from a parent seed.
  *
- * `header.seedLength` is DSH's durable fork-lineage boundary: event seqs below
- * it came from the parent, while later seqs belong to the child. Each skipped
- * message must still exist at the same seq in the selected parent copy.
+ * seedLength is normalized from the version's durable inheritance boundary.
+ * Each skipped message must still exist in the selected parent copy. Format
+ * migrations renumber events, but preserve existing message ids; mixed-format
+ * parents therefore need matching ids in order, never a token-count heuristic.
  * Missing, invalid, or divergent records fail open so usage is not lost.
  */
 function replaySkipCount(child, parent) {
@@ -347,21 +363,30 @@ function replaySkipCount(child, parent) {
   let parentIndex = 0;
   let previousSeq = -1;
   let count = 0;
+  const mixedVersions = child.formatVersion !== parent.formatVersion;
   for (const message of child.messages) {
     if (message.seq == null || message.seq <= previousSeq) return 0;
     previousSeq = message.seq;
     if (message.seq >= child.seedLength) break;
 
-    while (
-      parentIndex < parent.messages.length &&
-      parent.messages[parentIndex].seq != null &&
-      parent.messages[parentIndex].seq < message.seq
-    ) {
-      parentIndex++;
+    if (mixedVersions) {
+      if (!message.messageId) return 0;
+      while (parentIndex < parent.messages.length && parent.messages[parentIndex].messageId !== message.messageId) {
+        parentIndex++;
+      }
+    } else {
+      while (
+        parentIndex < parent.messages.length &&
+        parent.messages[parentIndex].seq != null &&
+        parent.messages[parentIndex].seq < message.seq
+      ) {
+        parentIndex++;
+      }
     }
     const source = parent.messages[parentIndex];
     if (
-      source?.seq !== message.seq ||
+      !source ||
+      (!mixedVersions && source.seq !== message.seq) ||
       source.role !== message.role ||
       source.model !== message.model ||
       !sameUsage(source.usage, message.usage)
@@ -397,7 +422,27 @@ function modelToResult(model, skipCount) {
   return { entries, events };
 }
 
-/** List session log files under a DSH sessions root (session.jsonl[.zstd]). */
+/** Pick the highest canonical generation per session, like DSH persistence. */
+function selectSessionFile(sessionPath) {
+  let selected = null;
+  for (const entry of readdirSync(sessionPath, { withFileTypes: true })) {
+    if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+    const match = SESSION_FILENAME.exec(entry.name);
+    if (!match) continue;
+    const version = Number(match[1] || 0);
+    if (!Number.isSafeInteger(version)) throw new Error('invalid format version in ' + entry.name);
+    const compressed = Boolean(match[2]);
+    if (!selected || version > selected.version || (version === selected.version && compressed)) {
+      selected = { file: join(sessionPath, entry.name), version, compressed };
+    }
+  }
+  if (selected && selected.version > MAX_SESSION_FORMAT_VERSION) {
+    throw new Error('format version ' + selected.version + ' is not supported; update Vibe Usage');
+  }
+  return selected;
+}
+
+/** List session.jsonl[.zstd] (V0) and session.vN.jsonl[.zstd] (V1+). */
 function listSessionFiles(sessionsDir, onFailure) {
   const files = [];
   const projectKeys = readdirSync(sessionsDir, { withFileTypes: true })
@@ -419,22 +464,14 @@ function listSessionFiles(sessionsDir, onFailure) {
     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;
-          }
-        }
+      try {
+        const selected = selectSessionFile(sessionPath);
+        if (selected) files.push(selected);
+      } catch (error) {
+        onFailure(
+          'dsh: cannot read session directory ' + relative(sessionsDir, sessionPath) +
+          ' (' + (error?.message || error?.code || 'read failed') + ')',
+        );
       }
     }
   }
@@ -444,17 +481,15 @@ function listSessionFiles(sessionsDir, onFailure) {
 /**
  * DeepSeek Harness (dsh) parser.
  *
- * Reads $DSH_HOME/sessions/<project-key>/session-<id>/session.jsonl.zstd
+ * Reads $DSH_HOME/sessions/<project-key>/<id>/session[.vN].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.
  *
  * Replay handling: `header.parentSession` identifies a fork/subagent source,
- * and `header.seedLength` is the exact count of leading event seqs inherited
- * from it. Those records are skipped only when the parent file is also
- * present. Files without either field, and children whose parent is missing,
- * are counted in full. `session/end-seed` positions are never used.
+ * with a version-specific inheritance boundary (see buildSessionModel).
+ * Children whose parent is missing are counted in full.
  */
 export async function parse() {
   const sessionsDir = getDshSessionsDir();
@@ -485,10 +520,10 @@ export async function parse() {
     return result;
   }
 
-  // sessionId -> most complete model (largest decompressed log wins, so a
-  // session copied between project dirs is counted once).
+  // sessionId -> newest generation, then largest copy within that generation.
+  // Migrations can shrink a log by embedding chunks, so size alone is unsafe.
   const perSession = new Map();
-  for (const { file, compressed } of files) {
+  for (const { file, compressed, version } of files) {
     let text;
     try {
       const stat = statSync(file);
@@ -510,7 +545,7 @@ export async function parse() {
 
     let model;
     try {
-      model = buildSessionModel(text);
+      model = buildSessionModel(text, version);
     } catch (error) {
       recordFailure(
         'dsh: skipping ' + relative(process.cwd(), file) + ' (' + error.message + ')',
@@ -520,7 +555,8 @@ export async function parse() {
 
     const weight = text.length;
     const previous = perSession.get(model.sessionId);
-    if (!previous || weight > previous.weight) {
+    if (!previous || model.formatVersion > previous.model.formatVersion ||
+      (model.formatVersion === previous.model.formatVersion && weight > previous.weight)) {
       perSession.set(model.sessionId, { model, weight });
     }
   }

package/src/sync.js

@@ -15,6 +15,28 @@ import { success, failure, warn, arrow, link, dim } from './output.js';
 const BATCH_SIZE = 100;
 const SESSION_BATCH_SIZE = 500;
 
+/** Coarse human duration: "45s" / "2m10s" / "1h 20m". */
+export function formatDuration(seconds) {
+  const secs = Math.max(0, Math.round(seconds));
+  if (secs < 60) return `${secs}s`;
+  const h = Math.floor(secs / 3600);
+  const m = Math.floor((secs % 3600) / 60);
+  const s = secs % 60;
+  if (h > 0) return m > 0 ? `${h}h ${m}m` : `${h}h`;
+  return s > 0 ? `${m}m${s}s` : `${m}m`;
+}
+
+/**
+ * Remaining upload time from batches already finished. Measured, never guessed:
+ * returns null until at least one batch has completed, because a first-sync
+ * backlog and a steady-state trickle differ by three orders of magnitude and
+ * any a-priori rate would be wrong for one of them.
+ */
+export function estimateRemainingSeconds({ elapsedMs, doneBatches, totalBatches }) {
+  if (!(elapsedMs > 0) || doneBatches < 1 || totalBatches <= doneBatches) return null;
+  return ((elapsedMs / doneBatches) * (totalBatches - doneBatches)) / 1000;
+}
+
 function formatBytes(bytes) {
   if (bytes < 1024) return `${bytes}B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
@@ -321,6 +343,20 @@ export async function runSync({
   const totalBatches = Math.max(bucketBatches, sessionBatches, 1);
   const syncClient = createSyncClient({ defaultSurface: surface, hostname: host });
 
+  // Say up front how much is about to go up. A first sync (or one that
+  // backfills after a parser was broken) can be thousands of batches, and with
+  // only a per-batch progress line the user cannot tell a long upload from a
+  // hung one -- which is exactly how a silently failing parser stayed hidden.
+  if (!quiet) {
+    const pending = [`${allBucketsToSend.length} buckets`];
+    if (allSessionsToSend.length > 0) pending.push(`${allSessionsToSend.length} sessions`);
+    const batchNote = totalBatches > 1 ? `，分 ${totalBatches} 批` : '';
+    console.log(dim(`  待上传 ${pending.join(' · ')}${batchNote}`));
+  }
+
+  let uploadedBytes = 0;
+  const uploadStartedAt = Date.now();
+
   try {
     for (let batchIdx = 0; batchIdx < totalBatches; batchIdx++) {
       const batch = allBucketsToSend.slice(batchIdx * BATCH_SIZE, (batchIdx + 1) * BATCH_SIZE);
@@ -328,13 +364,25 @@ export async function runSync({
       const batchNum = batchIdx + 1;
       const prefix = totalBatches > 1 ? `  ${dim(`[${batchNum}/${totalBatches}]`)} 上传中 ` : '  上传中 ';
 
+      // Only measured batches feed the estimate, so the first batch shows no
+      // ETA rather than a made-up one.
+      const remaining = estimateRemainingSeconds({
+        elapsedMs: Date.now() - uploadStartedAt,
+        doneBatches: batchIdx,
+        totalBatches,
+      });
+      const etaNote = remaining === null ? '' : ` · 预计还需 ${formatDuration(remaining)}`;
+
+      let batchBytes = 0;
       const result = await ingest(apiUrl, config.apiKey, batch, {
         client: forBatch(syncClient, batchIdx, totalBatches),
         onProgress(sent, total) {
+          batchBytes = total;
           const pct = Math.round((sent / total) * 100);
-          process.stdout.write(`\r${prefix}${dim(`${formatBytes(sent)}/${formatBytes(total)} (${pct}%)`)}\x1b[K`);
+          process.stdout.write(`\r${prefix}${dim(`${formatBytes(sent)}/${formatBytes(total)} (${pct}%)${etaNote}`)}\x1b[K`);
         },
       }, batchSessions.length > 0 ? batchSessions : undefined);
+      uploadedBytes += batchBytes;
       totalIngested += result.ingested ?? batch.length;
       totalSessionsSynced += result.sessions ?? 0;
       const batchUnknownSources = new Set(result.dropped?.unknownSources || []);
@@ -379,6 +427,10 @@ export async function runSync({
     const syncParts = [`${totalIngested} buckets`];
     if (totalSessionsSynced > 0) syncParts.push(`${totalSessionsSynced} sessions`);
     console.log(success(`已同步 ${syncParts.join(' · ')}`));
+    if (!quiet && uploadedBytes > 0) {
+      const elapsed = (Date.now() - uploadStartedAt) / 1000;
+      console.log(dim(`  上传 ${formatBytes(uploadedBytes)}（已压缩），用时 ${formatDuration(elapsed)}`));
+    }
 
     if (totalDroppedBuckets > 0) {
       const reasons = [];
@@ -399,13 +451,7 @@ export async function runSync({
       const totalActive = allSessionsToSend.reduce((s, x) => s + x.activeSeconds, 0);
       const totalDuration = allSessionsToSend.reduce((s, x) => s + x.durationSeconds, 0);
       const totalMsgs = allSessionsToSend.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(dim(`  活跃 ${fmtTime(totalActive)} / 总时长 ${fmtTime(totalDuration)} · ${totalMsgs} 条消息`));
+      console.log(dim(`  活跃 ${formatDuration(totalActive)} / 总时长 ${formatDuration(totalDuration)} · ${totalMsgs} 条消息`));
     }
 
     if (!quiet) {