tokentracker-cli 0.54.0 → 0.56.0

package/src/commands/sync.js

@@ -45,6 +45,8 @@ const {
   parseAntigravityIncremental,
   resolveCodebuddyProjectFiles,
   parseCodebuddyIncremental,
+  resolveWorkbuddyProjectFiles,
+  parseWorkbuddyIncremental,
   resolveKiroCliSessionFiles,
   resolveKiroCliDbPath,
   parseKiroCliIncremental,
@@ -58,7 +60,10 @@ const {
   parseGooseIncremental,
   listDroidSettingsFiles,
   parseDroidIncremental,
+  droidSessionIdFromPath,
+  resolveDroidModel,
   bucketKey,
+  toUtcHalfHourStart,
   totalsKey,
   claudeMessageDedupKey,
 } = require("../lib/rollout");
@@ -144,6 +149,7 @@ const CLOUD_CONVERSATIONS_BACKFILL_KEY = "cloudConversationsBackfill_2026_06";
 // ~/.codex/archived_sessions/ which sync does not scan) — clearing its bucket
 // would lose that history (ref the v6 ground-truth-repair data-loss incident).
 const CODEX_RESCAN_DEDUP_REPAIR_KEY = "codexRescanDedupRepair_2026_06";
+const DROID_DUP_SESSION_REPAIR_KEY = "droidDupSessionInflationRepair_2026_06";
 
 function warnProviderParseFailure(label, err, opts) {
   if (opts?.auto) return;
@@ -237,6 +243,7 @@ async function cmdSync(argv) {
 
     await migrateRolloutCumulativeDeltaBuckets({ cursors, queuePath, rolloutFiles });
     await repairCodexRescanInflation({ cursors, queuePath, queueStatePath, rolloutFiles });
+    await repairDroidDuplicateSessionInflation({ cursors, queuePath, queueStatePath });
 
     const openclawFiles = openclawSignal?.sessionFile
       ? [{ path: openclawSignal.sessionFile, source: "openclaw" }]
@@ -859,6 +866,36 @@ async function cmdSync(argv) {
       }
     }
 
+    // ── WorkBuddy (passive ~/.workbuddy/projects/**/*.jsonl reader) ──
+    // Tencent's WorkBuddy is a Claude Code fork in the same family as CodeBuddy;
+    // usage rides on function_call records too (not only assistant messages) and
+    // sub-agent logs nest one level deeper, so the resolver recurses. See the
+    // parser comment in rollout.js for the cache-aware token math.
+    let workbuddyResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    const workbuddyFiles = resolveWorkbuddyProjectFiles(process.env);
+    if (workbuddyFiles.length > 0) {
+      if (progress?.enabled) {
+        progress.start(`Parsing WorkBuddy ${renderBar(0)} | buckets 0`);
+      }
+      try {
+        workbuddyResult = await parseWorkbuddyIncremental({
+          projectFiles: workbuddyFiles,
+          cursors,
+          queuePath,
+          env: process.env,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing WorkBuddy ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("WorkBuddy", err, opts);
+      }
+    }
+
     // ── oh-my-pi (passive ~/.omp/agent/sessions/**/*.jsonl reader) ──
     let ompResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     const ompFiles = resolveOmpSessionFiles(process.env);
@@ -1155,6 +1192,7 @@ async function cmdSync(argv) {
         kimiResult.recordsProcessed +
         kimiCodeResult.recordsProcessed +
         codebuddyResult.recordsProcessed +
+        workbuddyResult.recordsProcessed +
         ompResult.recordsProcessed +
         piResult.recordsProcessed +
         craftResult.recordsProcessed +
@@ -1180,6 +1218,7 @@ async function cmdSync(argv) {
         kimiResult.bucketsQueued +
         kimiCodeResult.bucketsQueued +
         codebuddyResult.bucketsQueued +
+        workbuddyResult.bucketsQueued +
         ompResult.bucketsQueued +
         piResult.bucketsQueued +
         craftResult.bucketsQueued +
@@ -1242,12 +1281,14 @@ module.exports = {
   migrateCursorUnknownBuckets,
   migrateRolloutCumulativeDeltaBuckets,
   repairCodexRescanInflation,
+  repairDroidDuplicateSessionInflation,
   reincludeClaudeMemObserverFiles,
   repairGrokQueueFromSessionSnapshots,
   applyCloudConversationsBackfill,
   CURSOR_UNKNOWN_MIGRATION_KEY,
   ROLLOUT_CUMULATIVE_DELTA_MIGRATION_KEY,
   CODEX_RESCAN_DEDUP_REPAIR_KEY,
+  DROID_DUP_SESSION_REPAIR_KEY,
   CLAUDE_MEM_OBSERVER_REINCLUDE_KEY,
   GROK_APPEND_ONLY_REPAIR_MIGRATION_KEY,
   CLOUD_CONVERSATIONS_BACKFILL_KEY,
@@ -2300,6 +2341,249 @@ async function repairCodexRescanInflation({ cursors, queuePath, queueStatePath,
   return true;
 }
 
+// One-time repair (#204): when the SAME Droid session id existed in two folders
+// under ~/.factory/sessions, parseDroidIncremental's cumulative-delta loop made the
+// lower-count file look like a reset and re-emitted each duplicate's full total on
+// EVERY sync, inflating one (droid, model, hour) bucket without bound (a real ~10M
+// session showed as 40.06B). The forward fix is dedupeDroidSettingsFilesBySession
+// inside the parser; this migration repairs already-polluted installs.
+//
+// SCOPE — strictly the duplicate sessions' buckets, and ONLY when duplicate files
+// still exist on disk:
+//   * A from-zero rebuild cannot reconstruct Droid's historical per-sync bucket
+//     distribution — settings.json carries only the CURRENT mtime, not per-turn
+//     timestamps like Codex's jsonl. So we rebuild over the DUPLICATE files only,
+//     and overwrite only the bucket keys those files map to (pollutedKeys) plus
+//     the duplicate sessions' cursor entries. Every other droid bucket and cursor
+//     — clean sessions AND deleted-session history — is left byte-for-byte intact,
+//     so healthy history is never collapsed into the current half-hour.
+//   * No session id has >1 file on disk → this bug never fired here: set the
+//     sentinel, touch nothing.
+//   * Fire only when live > rebuilt over pollutedKeys (actual inflation), so a
+//     fresh install (live empty) is left to the normal same-sync parse.
+// Droid has no project dimension, so project.queue.jsonl is never involved.
+async function repairDroidDuplicateSessionInflation({ cursors, queuePath, queueStatePath } = {}) {
+  if (!cursors || typeof cursors !== "object") return false;
+  const migrations = (cursors.migrations ||= {});
+  // Completed run → truthy non-skip sentinel (final). A {skipped:true} object would
+  // retry (codex skip-retry semantics; this repair only ever writes done/none).
+  const prior = migrations[DROID_DUP_SESSION_REPAIR_KEY];
+  if (prior && !(typeof prior === "object" && prior.skipped)) return false;
+
+  // Group current on-disk settings files by session id; collect duplicates.
+  let onDisk;
+  try {
+    onDisk = listDroidSettingsFiles(process.env);
+  } catch {
+    onDisk = [];
+  }
+  const bySession = new Map();
+  for (const fp of onDisk) {
+    const sid = droidSessionIdFromPath(fp);
+    if (!sid) continue;
+    if (!bySession.has(sid)) bySession.set(sid, []);
+    bySession.get(sid).push(fp);
+  }
+  const dupFiles = [];
+  const cleanFiles = [];
+  for (const group of bySession.values()) {
+    if (group.length > 1) dupFiles.push(...group);
+    else cleanFiles.push(...group);
+  }
+  if (dupFiles.length === 0) {
+    migrations[DROID_DUP_SESSION_REPAIR_KEY] = new Date().toISOString();
+    return false;
+  }
+
+  // Map on-disk settings files to the (droid, model, half-hour) bucket keys they
+  // emit under the parser's own keying (mirrors parseDroidIncremental).
+  const bucketKeysForFiles = (files) => {
+    const keys = new Set();
+    for (const fp of files) {
+      let mtimeMs = 0;
+      try {
+        mtimeMs = fssync.statSync(fp).mtimeMs;
+      } catch {
+        continue;
+      }
+      let settings;
+      try {
+        settings = JSON.parse(fssync.readFileSync(fp, "utf8"));
+      } catch {
+        continue;
+      }
+      if (!settings || typeof settings !== "object" || !settings.tokenUsage) continue;
+      const bucketStart = toUtcHalfHourStart(
+        new Date(mtimeMs || Date.now()).toISOString(),
+      );
+      if (!bucketStart) continue;
+      keys.add(bucketKey("droid", resolveDroidModel(settings, fp), bucketStart));
+    }
+    return keys;
+  };
+
+  // A bucket key is (source, model, half-hour) — it carries NO session identity.
+  // pollutedKeys are the buckets the duplicate files emit to; cleanKeys are buckets
+  // a NON-duplicate on-disk session emits to. When a clean session resolves to the
+  // same (model, half-hour) as a duplicate file, they collide on one key. We must
+  // NOT delete-and-replace such a shared bucket: the rebuild runs over duplicate
+  // files only, so replacing the bucket would erase the clean session's tokens
+  // (silent data loss). So repair ONLY buckets owned exclusively by duplicate
+  // sessions; leave shared buckets intact. Residual inflation in a rare shared
+  // bucket is visible and recoverable; destroying real data is not (this is the
+  // dedup-needs-identity-proof rule).
+  const pollutedKeys = bucketKeysForFiles(dupFiles);
+  const cleanKeys = bucketKeysForFiles(cleanFiles);
+  const repairKeys = new Set();
+  for (const k of pollutedKeys) if (!cleanKeys.has(k)) repairKeys.add(k);
+  if (repairKeys.size === 0) {
+    migrations[DROID_DUP_SESSION_REPAIR_KEY] = new Date().toISOString();
+    return false;
+  }
+
+  // Ground-truth rebuild into throwaway state over the DUPLICATE files only
+  // (parseDroidIncremental de-dupes its own input → canonical per session). On any
+  // throw, leave all state untouched and do NOT set the sentinel (retry next sync).
+  let rebuilt;
+  const tmpQueue = `${queuePath}.droidrebuild.${process.pid}.${Date.now()}`;
+  try {
+    const tmpCursors = { hourly: { buckets: {}, groupQueued: {} }, droid: {} };
+    await parseDroidIncremental({
+      settingsFiles: dupFiles,
+      cursors: tmpCursors,
+      queuePath: tmpQueue,
+      env: process.env,
+      prune: true,
+    });
+    let tmpRaw = "";
+    try {
+      tmpRaw = await fs.readFile(tmpQueue, "utf8");
+    } catch (e) {
+      if (e?.code !== "ENOENT") throw e;
+    }
+    rebuilt = {
+      buckets: tmpCursors.hourly.buckets || {},
+      sessionTotals: (tmpCursors.droid && tmpCursors.droid.sessionTotals) || {},
+      queueRows: tmpRaw.split("\n").filter((l) => l.trim()),
+    };
+  } catch (e) {
+    console.error(
+      "[sync] droid dup-session repair: rebuild failed, leaving all data untouched:",
+      e?.message || e,
+    );
+    return false;
+  } finally {
+    await fs.rm(tmpQueue, { force: true }).catch(() => {});
+  }
+
+  // Inflation present? Compare live vs rebuilt totals over the repair-scoped keys
+  // only. Fire only on live > rebuilt (real inflation) — never on a fresh install
+  // (live 0).
+  const liveBuckets = (cursors.hourly && cursors.hourly.buckets) || {};
+  let liveScoped = 0;
+  let rebuiltScoped = 0;
+  for (const key of repairKeys) {
+    liveScoped += Number(liveBuckets[key]?.totals?.total_tokens || 0);
+    rebuiltScoped += Number(rebuilt.buckets[key]?.totals?.total_tokens || 0);
+  }
+  if (liveScoped <= rebuiltScoped) {
+    migrations[DROID_DUP_SESSION_REPAIR_KEY] = new Date().toISOString();
+    return false;
+  }
+
+  // ── COMMIT (atomic) ──
+  await ensureDir(path.dirname(queuePath));
+  await backupExistingFile(queuePath);
+
+  // 1. queue.jsonl: keep every non-droid line verbatim (incl. unparseable) and
+  //    every droid row whose bucket key is NOT in repairKeys (clean + shared +
+  //    deleted-session history). Drop droid rows in repairKeys; append rebuilt rows.
+  let raw = "";
+  try {
+    raw = await fs.readFile(queuePath, "utf8");
+  } catch (e) {
+    if (e?.code !== "ENOENT") throw e;
+  }
+  // A queue line is in scope if it's a droid row whose bucket is in repairKeys.
+  // Unparseable / non-droid / clean / shared droid rows are kept verbatim.
+  const isRepairDroidRow = (line) => {
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      return false;
+    }
+    return (
+      row?.source === "droid" &&
+      repairKeys.has(bucketKey("droid", row.model, row.hour_start))
+    );
+  };
+  const kept = raw
+    .split("\n")
+    .filter((line) => line.trim() && !isRepairDroidRow(line));
+  const rebuiltRepairRows = rebuilt.queueRows.filter(isRepairDroidRow);
+  const tmp = `${queuePath}.tmp.${process.pid}.${Date.now()}`;
+  await fs.writeFile(
+    tmp,
+    kept.concat(rebuiltRepairRows).join("\n") + "\n",
+    "utf8",
+  );
+  await fs.rename(tmp, queuePath);
+
+  // 2. live hourly buckets: delete repair-scoped droid keys, install the rebuilt
+  //    buckets for those keys. Other droid buckets untouched.
+  const hourly = (cursors.hourly ||= { version: 3, buckets: {}, groupQueued: {} });
+  hourly.buckets ||= {};
+  hourly.groupQueued ||= {};
+  for (const key of repairKeys) {
+    delete hourly.buckets[key];
+    if (rebuilt.buckets[key]) hourly.buckets[key] = rebuilt.buckets[key];
+  }
+  // Defensive: droid never uses the legacy aggregate path, but drop any stale droid
+  // group markers so a repaired hour can't re-emit as model=unknown.
+  for (const gk of Object.keys(hourly.groupQueued)) {
+    if (gk.startsWith("droid|")) delete hourly.groupQueued[gk];
+  }
+
+  // 3. session cursor: overwrite ONLY the duplicate sessions with the ground-truth
+  //    rebuild so the later same-sync droid parse short-circuits (mtime match) and
+  //    emits nothing. Clean sessions' cursor entries are correct already — leave
+  //    them, or the later parse would re-emit them from zero.
+  const droidState = (cursors.droid ||= {});
+  if (!droidState.sessionTotals || typeof droidState.sessionTotals !== "object") {
+    droidState.sessionTotals = {};
+  }
+  for (const sid of Object.keys(rebuilt.sessionTotals)) {
+    droidState.sessionTotals[sid] = rebuilt.sessionTotals[sid];
+  }
+  droidState.updatedAt = new Date().toISOString();
+
+  // 4. reset the cloud upload offset so corrected rows re-upload (idempotent upsert).
+  if (typeof queueStatePath === "string" && queueStatePath) {
+    let uploadState = {};
+    try {
+      uploadState = JSON.parse(await fs.readFile(queueStatePath, "utf8"));
+    } catch {
+      uploadState = {};
+    }
+    uploadState.offset = 0;
+    uploadState.updatedAt = new Date().toISOString();
+    uploadState.note = "reset_after_droid_dup_session_2026_06";
+    await fs.writeFile(queueStatePath, JSON.stringify(uploadState));
+  }
+
+  migrations[DROID_DUP_SESSION_REPAIR_KEY] = {
+    status: "done",
+    at: new Date().toISOString(),
+    keysRepaired: repairKeys.size,
+    keysSkippedSharedWithCleanSession: pollutedKeys.size - repairKeys.size,
+    liveBefore: liveScoped,
+    rebuiltAfter: rebuiltScoped,
+    deltaReclaimed: liveScoped - rebuiltScoped,
+  };
+  return true;
+}
+
 // One-time repair migration: rebuild source=claude rows in queue.jsonl from
 // the actual jsonl files using ccusage's algorithm (msgId+reqId global
 // dedup). Earlier `reincludeClaudeMemObserverFiles` versions (v1/v2/v3) each

package/src/commands/uninstall.js

@@ -27,6 +27,8 @@ async function cmdUninstall(argv) {
   const claudeSettingsPath = path.join(home, ".claude", "settings.json");
   const codebuddyDir = process.env.CODEBUDDY_HOME || path.join(home, ".codebuddy");
   const codebuddySettingsPath = path.join(codebuddyDir, "settings.json");
+  const workbuddyDir = process.env.WORKBUDDY_HOME || path.join(home, ".workbuddy");
+  const workbuddySettingsPath = path.join(workbuddyDir, "settings.json");
   const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
   const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
   const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
@@ -37,12 +39,14 @@ async function cmdUninstall(argv) {
   const codeNotifyCmd = ["/usr/bin/env", "node", notifyPath, "--source=every-code"];
   const claudeHookCommand = buildClaudeHookCommand(notifyPath);
   const codebuddyHookCommand = buildHookCommand(notifyPath, "codebuddy");
+  const workbuddyHookCommand = buildHookCommand(notifyPath, "workbuddy");
   const geminiHookCommand = buildGeminiHookCommand(notifyPath);
 
   const codexConfigExists = await isFile(codexConfigPath);
   const codeConfigExists = await isFile(codeConfigPath);
   const claudeConfigExists = await isFile(claudeSettingsPath);
   const codebuddyConfigExists = await isFile(codebuddySettingsPath);
+  const workbuddyConfigExists = await isFile(workbuddySettingsPath);
   const geminiConfigExists = await isDir(geminiConfigDir);
   const opencodeConfigExists = await isDir(opencodeConfigDir);
   const codexRestore = codexConfigExists
@@ -68,6 +72,12 @@ async function cmdUninstall(argv) {
         hookCommand: codebuddyHookCommand,
       })
     : { removed: false, skippedReason: "config-missing" };
+  const workbuddyRemove = workbuddyConfigExists
+    ? await removeClaudeHook({
+        settingsPath: workbuddySettingsPath,
+        hookCommand: workbuddyHookCommand,
+      })
+    : { removed: false, skippedReason: "config-missing" };
   const geminiRemove = geminiConfigExists
     ? await removeGeminiHook({ settingsPath: geminiSettingsPath, hookCommand: geminiHookCommand })
     : { removed: false, skippedReason: "config-missing" };
@@ -132,6 +142,13 @@ async function cmdUninstall(argv) {
             ? "- CodeBuddy hooks: no change"
             : "- CodeBuddy hooks: skipped"
         : "- CodeBuddy hooks: skipped (settings.json not found)",
+      workbuddyConfigExists
+        ? workbuddyRemove?.removed
+          ? `- WorkBuddy hooks removed: ${workbuddySettingsPath}`
+          : workbuddyRemove?.skippedReason === "hook-missing"
+            ? "- WorkBuddy hooks: no change"
+            : "- WorkBuddy hooks: skipped"
+        : "- WorkBuddy hooks: skipped (settings.json not found)",
       geminiConfigExists
         ? geminiRemove?.removed
           ? `- Gemini hooks removed: ${geminiSettingsPath}`

package/src/lib/passive-mode.js

@@ -86,7 +86,7 @@ function classifyWritableFailure(filePath) {
  * @param {string} opts.home  - user home directory
  * @param {Object} opts.hookStatus - per-provider hook-installed booleans
  *   (already collected by status.js); shape: { claude, gemini, codex,
- *   every_code, opencode, openclaw, codebuddy, grok }
+ *   every_code, opencode, openclaw, codebuddy, workbuddy, grok }
  * @returns {PassiveProvider[]}
  */
 function detectPassiveProviders({ home, hookStatus }) {
@@ -149,6 +149,16 @@ function detectPassiveProviders({ home, hookStatus }) {
     settingsPath: path.join(home, ".codebuddy", "settings.json"),
   }));
 
+  // WorkBuddy — sibling Claude-fork; hook in ~/.workbuddy/settings.json
+  out.push(buildEntry({
+    name: "workbuddy",
+    hookExpected: true,
+    hookInstalled: Boolean(hookStatus?.workbuddy),
+    logsDir: path.join(home, ".workbuddy"),
+    logsPredicate: (_full, name) => name === "projects" || name.endsWith(".jsonl"),
+    settingsPath: path.join(home, ".workbuddy", "settings.json"),
+  }));
+
   return out;
 }
 

package/src/lib/pricing/curated-overrides.json

@@ -9,8 +9,8 @@
     "claude-opus-4-8":  { "input": 5,    "output": 25,   "cache_read": 0.5,   "cache_write": 6.25, "note": "Opus 4.8 not yet in LiteLLM. Pin to the standard Opus tier (same as 4.6/4.7); remove once LiteLLM carries it." },
     "kiro-agent":       { "input": 3,    "output": 15,   "cache_read": 0.3,   "cache_write": 3.75 },
     "kiro-cli-agent":   { "input": 3,    "output": 15,   "cache_read": 0.3,   "cache_write": 3.75 },
-    "hy3-preview-agent":{ "input": 0,    "output": 0,    "cache_read": 0 },
-    "hy3-preview":      { "input": 0,    "output": 0,    "cache_read": 0 },
+    "hy3-preview-agent":{ "input": 0.167, "output": 0.556, "cache_read": 0.056, "cache_write": 0.167, "note": "Tencent Hunyuan Hy3 preview (CodeBuddy/WorkBuddy backend). Official TokenHub rate: 1.2 / 0.4 (cache hit) / 4.0 RMB per MTok in/read/out, converted at ~7.2 RMB/USD. DeepSeek-style cache: no write surcharge, so cache_write = input." },
+    "hy3-preview":      { "input": 0.167, "output": 0.556, "cache_read": 0.056, "cache_write": 0.167, "note": "See hy3-preview-agent." },
     "composer-1":       { "input": 1.25, "output": 10,   "cache_read": 0.125 },
     "composer-1.5":     { "input": 3.5,  "output": 17.5, "cache_read": 0.35 },
     "composer-2":       { "input": 0.5,  "output": 2.5,  "cache_read": 0.2 },

package/src/lib/pricing/matcher.js

@@ -104,6 +104,22 @@ function normalizeClaudeModel(model) {
   return m;
 }
 
+// WorkBuddy's auto-router records the model as the literal "auto" and never
+// exposes the underlying model it picked. That collides with Cursor's curated
+// alias ("auto" -> "composer-1"), which would misprice WorkBuddy usage as
+// Cursor's Composer. Map it instead to hy3-preview-agent — WorkBuddy's default
+// Tencent Hunyuan model — mirroring how Cursor's "auto" maps to its own default
+// (composer-1). The auto-router can pick pricier models, so this can slightly
+// under-count, but it tracks the token cost of WorkBuddy's representative model
+// rather than an unrelated vendor's. (The raw "auto" string is still
+// stored/displayed; only the pricing lookup is remapped.)
+function normalizeWorkbuddyModel(model) {
+  if (typeof model === "string" && model.trim().toLowerCase() === "auto") {
+    return "hy3-preview-agent";
+  }
+  return model;
+}
+
 // Per-source model-name normalizers, applied at pricing-lookup time only (the
 // raw model name is preserved for storage/display). Add a source here when its
 // model strings don't match the LiteLLM/curated keys verbatim.
@@ -111,6 +127,7 @@ const SOURCE_MODEL_NORMALIZERS = {
   antigravity: normalizeAntigravityModel,
   claude: normalizeClaudeModel,
   zed: normalizeZedModel,
+  workbuddy: normalizeWorkbuddyModel,
 };
 
 // Memoise the sorted-by-length LiteLLM key list. Reverse-substring scan walks