tokentracker-cli 1.3.3 → 1.3.5

package/src/commands/init.js

@@ -13,6 +13,7 @@ const {
   chmod600IfPossible,
 } = require("../lib/fs");
 const { resolveMimoNativeDbPath } = require("../lib/install-resolver");
+const { expandHome } = require("../lib/scan-roots");
 const { prompt, promptHidden } = require("../lib/prompt");
 const {
   upsertCodexNotify,
@@ -130,6 +131,7 @@ const SUPPORTED_PROVIDERS = [
   "Kimi Code",
   "CodeBuddy",
   "WorkBuddy",
+  "WorkBuddy AI",
   "Grok Build",
   "oh-my-pi",
   "OmO",
@@ -578,6 +580,10 @@ async function repairRuntimeIntegrations({
       settingsPath: context.workbuddySettingsPath,
       hookCommand: context.workbuddyHookCommand,
     })],
+    ["workbuddy-ai", context.workbuddyAiDir, () => upsertClaudeHook({
+      settingsPath: context.workbuddyAiSettingsPath,
+      hookCommand: context.workbuddyAiHookCommand,
+    })],
   ];
   for (const [key, configDir, repair] of hookRepairs) {
     if (await isDir(configDir)) await attempt(key, repair);
@@ -622,6 +628,12 @@ function buildIntegrationTargets({ home, trackerDir, notifyPath }) {
   const workbuddyDir = process.env.WORKBUDDY_HOME || path.join(home, ".workbuddy");
   const workbuddySettingsPath = path.join(workbuddyDir, "settings.json");
   const workbuddyHookCommand = buildHookCommand(notifyPath, "workbuddy");
+  // WorkBuddy AI is the international build of the very same CLI. It keeps its
+  // data in a sibling home (~/.workbuddy-ai), so it needs its own hook install
+  // and its own --source token to be attributed separately from the CN build.
+  const workbuddyAiDir = expandHome(process.env.WORKBUDDY_AI_HOME, home) || path.join(home, ".workbuddy-ai");
+  const workbuddyAiSettingsPath = path.join(workbuddyAiDir, "settings.json");
+  const workbuddyAiHookCommand = buildHookCommand(notifyPath, "workbuddy-ai");
   const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
   const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
   const geminiHookCommand = buildGeminiHookCommand(notifyPath);
@@ -647,6 +659,9 @@ function buildIntegrationTargets({ home, trackerDir, notifyPath }) {
     workbuddyDir,
     workbuddySettingsPath,
     workbuddyHookCommand,
+    workbuddyAiDir,
+    workbuddyAiSettingsPath,
+    workbuddyAiHookCommand,
     geminiConfigDir,
     geminiSettingsPath,
     geminiHookCommand,
@@ -1034,6 +1049,18 @@ async function applyIntegrationSetup({
     summary.push({ label: "WorkBuddy", status: "skipped", detail: "Config not found" });
   }
 
+  // WorkBuddy AI: international build, same hook schema, sibling home.
+  const workbuddyAiDirExists = await isDir(context.workbuddyAiDir);
+  if (workbuddyAiDirExists) {
+    await upsertClaudeHook({
+      settingsPath: context.workbuddyAiSettingsPath,
+      hookCommand: context.workbuddyAiHookCommand,
+    });
+    summary.push({ label: "WorkBuddy AI", status: "installed", detail: "Hooks installed" });
+  } else {
+    summary.push({ label: "WorkBuddy AI", status: "skipped", detail: "Config not found" });
+  }
+
   const openclawBefore = await probeOpenclawSessionPluginState({
     home,
     trackerDir,
@@ -1187,6 +1214,21 @@ async function previewIntegrations({ context }) {
     summary.push({ label: "WorkBuddy", status: "skipped", detail: "Config not found" });
   }
 
+  const workbuddyAiDirExists = await isDir(context.workbuddyAiDir);
+  if (workbuddyAiDirExists) {
+    const configured = await isClaudeHookConfigured({
+      settingsPath: context.workbuddyAiSettingsPath,
+      hookCommand: context.workbuddyAiHookCommand,
+    });
+    summary.push({
+      label: "WorkBuddy AI",
+      status: "installed",
+      detail: configured ? "Hooks already installed" : "Will install hooks",
+    });
+  } else {
+    summary.push({ label: "WorkBuddy AI", status: "skipped", detail: "Config not found" });
+  }
+
   const geminiConfigExists = await isDir(context.geminiConfigDir);
   if (geminiConfigExists) {
     const configured = await isGeminiHookConfigured({
@@ -1491,7 +1533,7 @@ try {
       ? codeOriginalPath
       : source === 'acode'
         ? acodeOriginalPath
-        : source === 'claude' || source === 'opencode' || source === 'gemini' || source === 'codebuddy' || source === 'workbuddy'
+        : source === 'claude' || source === 'opencode' || source === 'gemini' || source === 'codebuddy' || source === 'workbuddy' || source === 'workbuddy-ai'
           ? null
           : codexOriginalPath;
   if (originalPath) {

package/src/commands/status.js

@@ -221,6 +221,11 @@ async function cmdStatus(argv = []) {
     resolveWorkbuddyHome(process.env) || path.join(home, ".workbuddy"),
     "settings.json",
   );
+  // WorkBuddy AI — international build, sibling home (~/.workbuddy-ai).
+  const workbuddyAiSettingsPath = path.join(
+    resolveWorkbuddyHome(process.env, "workbuddy-ai") || path.join(home, ".workbuddy-ai"),
+    "settings.json",
+  );
   const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
   const geminiSettingsPath = resolveGeminiSettingsPath({
     configDir: geminiConfigDir,
@@ -235,6 +240,7 @@ async function cmdStatus(argv = []) {
   const claudeHookCommand = buildClaudeHookCommand(notifyPath);
   const codebuddyHookCommand = buildHookCommand(notifyPath, "codebuddy");
   const workbuddyHookCommand = buildHookCommand(notifyPath, "workbuddy");
+  const workbuddyAiHookCommand = buildHookCommand(notifyPath, "workbuddy-ai");
   const geminiHookCommand = buildGeminiHookCommand(notifyPath);
 
   const config = await readJson(configPath);
@@ -308,6 +314,10 @@ async function cmdStatus(argv = []) {
     settingsPath: workbuddySettingsPath,
     hookCommand: workbuddyHookCommand,
   });
+  const workbuddyAiHookConfigured = await isClaudeHookConfigured({
+    settingsPath: workbuddyAiSettingsPath,
+    hookCommand: workbuddyAiHookCommand,
+  });
   const geminiHookConfigured = await isGeminiHookConfigured({
     settingsPath: geminiSettingsPath,
     hookCommand: geminiHookCommand,
@@ -493,6 +503,15 @@ async function cmdStatus(argv = []) {
     ? fssync.existsSync(path.join(workbuddyHome, "workbuddy.db"))
     : false;
 
+  const workbuddyAiHome = resolveWorkbuddyHome(process.env, "workbuddy-ai");
+  const workbuddyAiInstalled = Boolean(workbuddyAiHome && fssync.existsSync(workbuddyAiHome));
+  const workbuddyAiFiles = workbuddyAiInstalled
+    ? resolveWorkbuddyProjectFiles(process.env, "workbuddy-ai")
+    : [];
+  const workbuddyAiDbExists = workbuddyAiInstalled
+    ? fssync.existsSync(path.join(workbuddyAiHome, "workbuddy.db"))
+    : false;
+
   // oh-my-pi — passive scan + optional notify extension.
   const ompAgentDir = resolveOmpAgentDir(process.env);
   const ompInstalled = Boolean(ompAgentDir) && fssync.existsSync(path.join(ompAgentDir, "sessions"));
@@ -1003,6 +1022,7 @@ async function cmdStatus(argv = []) {
       openclaw_session_plugin: Boolean(openclawSessionPluginState?.configured),
       codebuddy: Boolean(codebuddyHookConfigured),
       workbuddy: Boolean(workbuddyHookConfigured),
+      "workbuddy-ai": Boolean(workbuddyAiHookConfigured),
       grok: Boolean(grokHookState?.configured),
     },
   });
@@ -1046,6 +1066,7 @@ async function cmdStatus(argv = []) {
         openclaw_legacy: Boolean(openclawHookState?.configured),
         codebuddy: codebuddyInstalled ? Boolean(codebuddyHookConfigured) : null,
         workbuddy: workbuddyInstalled ? Boolean(workbuddyHookConfigured) : null,
+        "workbuddy-ai": workbuddyAiInstalled ? Boolean(workbuddyAiHookConfigured) : null,
         grok: grokInstalled ? Boolean(grokHookState?.configured) : null,
       },
       providers: {
@@ -1077,6 +1098,9 @@ async function cmdStatus(argv = []) {
         workbuddy: workbuddyInstalled
           ? { installed: true, files: workbuddyFiles.length }
           : { installed: false },
+        workbuddy_ai: workbuddyAiInstalled
+          ? { installed: true, files: workbuddyAiFiles.length }
+          : { installed: false },
         omp: ompInstalled || ompHookState.ompPresent
           ? {
               installed: true,
@@ -1275,6 +1299,9 @@ async function cmdStatus(argv = []) {
       workbuddyInstalled
         ? `- WorkBuddy hooks: ${workbuddyHookConfigured ? "set" : "unset"} (${workbuddyFiles.length} session jsonl file${workbuddyFiles.length !== 1 ? "s" : ""} found, SQLite DB ${workbuddyDbExists ? "found" : "not found"})`
         : null,
+      workbuddyAiInstalled
+        ? `- WorkBuddy AI hooks: ${workbuddyAiHookConfigured ? "set" : "unset"} (${workbuddyAiFiles.length} session jsonl file${workbuddyAiFiles.length !== 1 ? "s" : ""} found, SQLite DB ${workbuddyAiDbExists ? "found" : "not found"})`
+        : null,
       ompInstalled || ompHookState.ompPresent
         ? `- oh-my-pi: passive reader (${ompFiles.length} session jsonl file${ompFiles.length !== 1 ? "s" : ""} found${ompHookState.configured ? ", notify extension: yes" : ", notify extension: no"})`
         : null,

package/src/commands/sync.js

@@ -354,6 +354,7 @@ const AUTO_SYNC_SOURCES = new Set([
   "trae",
   "unsloth",
   "workbuddy",
+  "workbuddy-ai",
   "zcode",
   "zed",
 ]);
@@ -984,8 +985,9 @@ async function cmdSync(argv, context = {}) {
     // Plugin-triggered sync points at one specific session file; a normal full
     // sync also passively scans every on-disk OpenClaw transcript so usage is
     // captured even when the session plugin never fires (issue #264). The scan
-    // is gated to full syncs so a scoped `--from-openclaw` hook still only
-    // touches its own file and the 5-minute background tick stays cheap. The
+    // is gated to full syncs except for gateway lifecycle signals. A scoped
+    // agent_end reads only its transcript or its session in the agent database,
+    // and the ordinary background tick stays cheap. The
     // event-identity dedup makes the plugin and passive paths idempotent, so
     // overlap on the same file is safe.
     //
@@ -999,12 +1001,22 @@ async function cmdSync(argv, context = {}) {
         path: openclawSignal.sessionFile,
         source: "openclaw",
       });
+      for (const dbPath of [
+        path.join(openclawSignal.openclawHome, "agents", openclawSignal.agentId, "agent", "openclaw-agent.sqlite"),
+        path.join(openclawSignal.openclawHome, "agents", openclawSignal.agentId, "openclaw-agent.sqlite"),
+      ]) {
+        if (!(await fs.stat(dbPath).catch(() => null))?.isFile()) continue;
+        openclawSessionFiles.set(openclawCursorKey(dbPath), {
+          path: dbPath, source: "openclaw", sessionId: openclawSignal.sessionId,
+        });
+        break;
+      }
     }
-    if (isFullSourceScan && sourceAllowed("openclaw")) {
+    if ((isFullSourceScan || (opts.fromOpenclaw && !openclawSignal)) && sourceAllowed("openclaw")) {
       try {
         for (const f of await resolveOpenclawSessionFiles(process.env)) {
           const key = openclawCursorKey(f);
-          if (!openclawSessionFiles.has(key)) {
+          if (!openclawSessionFiles.has(key) || f.endsWith(".sqlite")) {
             openclawSessionFiles.set(key, { path: f, source: "openclaw" });
           }
         }
@@ -2597,6 +2609,42 @@ async function cmdSync(argv, context = {}) {
       }
     }
 
+    // ── WorkBuddy AI — international build (~/.workbuddy-ai/projects/**/*.jsonl) ──
+    // Same Claude-fork family and byte-identical JSONL as the CN build above;
+    // only the home directory differs, so it reuses the WorkBuddy parser and
+    // gets its own source key (and cursor namespace) so the two builds stay
+    // separable instead of merging into one provider row.
+    let workbuddyAiResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    const workbuddyAiFiles = sourceAllowed("workbuddy-ai")
+      ? mergeBothFileSources({
+          resolveFiles: (resolveEnv) => resolveWorkbuddyProjectFiles(resolveEnv, "workbuddy-ai"),
+          env: process.env,
+        })
+      : [];
+    if (sourceAllowed("workbuddy-ai")) {
+      if (progress?.enabled) {
+        progress.start(`Parsing WorkBuddy AI ${renderBar(0)} | buckets 0`);
+      }
+      try {
+        workbuddyAiResult = await parseWorkbuddyIncremental({
+          projectFiles: workbuddyAiFiles,
+          cursors,
+          queuePath,
+          env: process.env,
+          source: "workbuddy-ai",
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing WorkBuddy AI ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("WorkBuddy AI", err, opts);
+      }
+    }
+
     // ── oh-my-pi (passive ~/.omp/agent/sessions/**/*.jsonl reader) ──
     // Task-subagent transcripts (nested below the cwd level) are scanned too,
     // so their usage counts toward the omp totals.
@@ -3256,6 +3304,7 @@ async function cmdSync(argv, context = {}) {
       kimiCodeResult.recordsProcessed +
       codebuddyResult.recordsProcessed +
       workbuddyResult.recordsProcessed +
+      workbuddyAiResult.recordsProcessed +
       ompResult.recordsProcessed +
       omoResult.recordsProcessed +
       piResult.recordsProcessed +
@@ -3300,6 +3349,7 @@ async function cmdSync(argv, context = {}) {
       kimiCodeResult.bucketsQueued +
       codebuddyResult.bucketsQueued +
       workbuddyResult.bucketsQueued +
+      workbuddyAiResult.bucketsQueued +
       ompResult.bucketsQueued +
       omoResult.bucketsQueued +
       piResult.bucketsQueued +

package/src/commands/uninstall.js

@@ -1,6 +1,7 @@
 const os = require("node:os");
 const path = require("node:path");
 const fs = require("node:fs/promises");
+const { expandHome } = require("../lib/scan-roots");
 
 const {
   restoreCodexNotify,
@@ -44,6 +45,9 @@ async function cmdUninstall(argv) {
   const codebuddySettingsPath = path.join(codebuddyDir, "settings.json");
   const workbuddyDir = process.env.WORKBUDDY_HOME || path.join(home, ".workbuddy");
   const workbuddySettingsPath = path.join(workbuddyDir, "settings.json");
+  // WorkBuddy AI — international build, sibling home (~/.workbuddy-ai).
+  const workbuddyAiDir = expandHome(process.env.WORKBUDDY_AI_HOME, home) || path.join(home, ".workbuddy-ai");
+  const workbuddyAiSettingsPath = path.join(workbuddyAiDir, "settings.json");
   const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
   const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
   const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
@@ -57,6 +61,7 @@ async function cmdUninstall(argv) {
   const claudeHookCommand = buildClaudeHookCommand(notifyPath);
   const codebuddyHookCommand = buildHookCommand(notifyPath, "codebuddy");
   const workbuddyHookCommand = buildHookCommand(notifyPath, "workbuddy");
+  const workbuddyAiHookCommand = buildHookCommand(notifyPath, "workbuddy-ai");
   const geminiHookCommand = buildGeminiHookCommand(notifyPath);
 
   const codexConfigExists = await isFile(codexConfigPath);
@@ -65,6 +70,7 @@ async function cmdUninstall(argv) {
   const claudeConfigExists = await isFile(claudeSettingsPath);
   const codebuddyConfigExists = await isFile(codebuddySettingsPath);
   const workbuddyConfigExists = await isFile(workbuddySettingsPath);
+  const workbuddyAiConfigExists = await isFile(workbuddyAiSettingsPath);
   const geminiConfigExists = await isDir(geminiConfigDir);
   const opencodeConfigExists = await isDir(opencodeConfigDir);
   const codexRestore = codexConfigExists
@@ -106,6 +112,12 @@ async function cmdUninstall(argv) {
         hookCommand: workbuddyHookCommand,
       })
     : { removed: false, skippedReason: "config-missing" };
+  const workbuddyAiRemove = workbuddyAiConfigExists
+    ? await removeClaudeHook({
+        settingsPath: workbuddyAiSettingsPath,
+        hookCommand: workbuddyAiHookCommand,
+      })
+    : { removed: false, skippedReason: "config-missing" };
   const geminiRemove = geminiConfigExists
     ? await removeGeminiHook({ settingsPath: geminiSettingsPath, hookCommand: geminiHookCommand })
     : { removed: false, skippedReason: "config-missing" };
@@ -191,6 +203,13 @@ async function cmdUninstall(argv) {
             ? "- WorkBuddy hooks: no change"
             : "- WorkBuddy hooks: skipped"
         : "- WorkBuddy hooks: skipped (settings.json not found)",
+      workbuddyAiConfigExists
+        ? workbuddyAiRemove?.removed
+          ? `- WorkBuddy AI hooks removed: ${workbuddyAiSettingsPath}`
+          : workbuddyAiRemove?.skippedReason === "hook-missing"
+            ? "- WorkBuddy AI hooks: no change"
+            : "- WorkBuddy AI hooks: skipped"
+        : "- WorkBuddy AI hooks: skipped (settings.json not found)",
       geminiConfigExists
         ? geminiRemove?.removed
           ? `- Gemini hooks removed: ${geminiSettingsPath}`

package/src/lib/claude-config.js

@@ -2,6 +2,7 @@ const fs = require("node:fs/promises");
 const path = require("node:path");
 
 const { ensureDir, readJson, writeJson } = require("./fs");
+const { buildNotifyCommand, notifyIdentity } = require("./notify-command");
 
 const DEFAULT_EVENT = "SessionEnd";
 const CLAUDE_USAGE_EVENTS = ["Stop", DEFAULT_EVENT];
@@ -23,10 +24,10 @@ async function upsertClaudeHooks({ settingsPath, hookCommand, events }) {
 
   for (const event of normalizeEventList(events)) {
     const entries = normalizeEntries(hooks[event]);
-    const normalized = normalizeEntriesForCommand(entries, hookCommand);
+    const normalized = normalizeEntriesForCommand(entries, hookCommand, event);
     let nextEntries = normalized.entries;
     if (!hasHook(nextEntries, hookCommand)) {
-      nextEntries = nextEntries.concat([{ hooks: [{ type: "command", command: hookCommand }] }]);
+      nextEntries = nextEntries.concat([{ hooks: [{ type: "command", command: hookCommand, ...hookShell(hookCommand) }] }]);
       changed = true;
     }
     if (normalized.changed) changed = true;
@@ -106,14 +107,14 @@ async function areClaudeHooksConfigured({ settingsPath, hookCommand, events }) {
 // Generic Session-hook command builder. CodeBuddy CLI is a Claude-Code fork
 // and uses the exact same settings.json hook schema, so this function works
 // for any source that accepts the `node notify.cjs --source=<name>` contract.
-function buildHookCommand(notifyPath, source) {
+function buildHookCommand(notifyPath, source, options) {
   const cmd = typeof notifyPath === "string" ? notifyPath : "";
   const src = typeof source === "string" && source ? source : "claude";
-  return `/usr/bin/env node ${quoteArg(cmd)} --source=${src}`;
+  return buildNotifyCommand(cmd, src, options);
 }
 
-function buildClaudeHookCommand(notifyPath) {
-  return buildHookCommand(notifyPath, "claude");
+function buildClaudeHookCommand(notifyPath, options) {
+  return buildHookCommand(notifyPath, "claude", options);
 }
 
 function normalizeSettings(raw) {
@@ -140,12 +141,15 @@ function normalizeCommand(cmd) {
 }
 
 function hasHook(entries, hookCommand) {
+  const shell = hookShell(hookCommand).shell;
+  const configured = (hook) => normalizeCommand(hook?.command) === normalizeCommand(hookCommand) &&
+    (!shell || (hook.shell === shell && !Object.hasOwn(hook, "args")));
   for (const entry of entries) {
     if (!entry || typeof entry !== "object") continue;
-    if (entry.command && commandsEqual(entry.command, hookCommand)) return true;
+    if (entry.command && configured(entry)) return true;
     const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
     for (const hook of hooks) {
-      if (hook && commandsEqual(hook.command, hookCommand)) return true;
+      if (hook && configured(hook)) return true;
     }
   }
   return false;
@@ -169,14 +173,25 @@ function stripHookFromEntry(entry, hookCommand) {
   return { entry: { ...entry, hooks: nextHooks }, removed: true };
 }
 
-function normalizeEntriesForCommand(entries, hookCommand) {
+function hookShell(command) {
+  return typeof command === "string" && command.trimStart().startsWith("& '")
+    ? { shell: "powershell" } : {};
+}
+
+function normalizeEntriesForCommand(entries, hookCommand, event) {
+  const shell = hookShell(hookCommand);
+  const repair = (hook) => {
+    const next = { ...hook, type: "command", command: hookCommand, ...shell };
+    if (shell.shell) delete next.args;
+    return next;
+  };
   let changed = false;
   const nextEntries = entries.map((entry) => {
     if (!entry || typeof entry !== "object") return entry;
     if (entry.command && commandsEqual(entry.command, hookCommand)) {
-      if (entry.type !== "command") {
+      if (entry.type !== "command" || entry.command !== hookCommand || (shell.shell && (entry.shell !== shell.shell || Object.hasOwn(entry, "args")))) {
         changed = true;
-        return { ...entry, type: "command" };
+        return repair(entry);
       }
       return entry;
     }
@@ -184,9 +199,9 @@ function normalizeEntriesForCommand(entries, hookCommand) {
     let hooksChanged = false;
     const nextHooks = entry.hooks.map((hook) => {
       if (hook && commandsEqual(hook.command, hookCommand)) {
-        if (hook.type !== "command") {
+        if (hook.type !== "command" || hook.command !== hookCommand || (shell.shell && (hook.shell !== shell.shell || Object.hasOwn(hook, "args")))) {
           hooksChanged = true;
-          return { ...hook, type: "command" };
+          return repair(hook);
         }
       }
       return hook;
@@ -195,13 +210,30 @@ function normalizeEntriesForCommand(entries, hookCommand) {
     changed = true;
     return { ...entry, hooks: nextHooks };
   });
-  return { entries: nextEntries, changed };
+  const seen = new Set();
+  const deduplicated = nextEntries.map((entry) => {
+    const matcher = entry?.matcher;
+    const scope = JSON.stringify(event === "Stop" || matcher == null || ["", "*", ".*"].includes(matcher) ? null : matcher);
+    const keep = (hook) => {
+      if (!commandsEqual(hook?.command, hookCommand)) return true;
+      if (seen.has(scope)) { changed = true; return false; }
+      seen.add(scope);
+      return true;
+    };
+    if (entry?.command) return keep(entry) ? entry : null;
+    if (!Array.isArray(entry?.hooks)) return entry;
+    const hooks = entry.hooks.filter(keep);
+    if (!hooks.length) return null;
+    return hooks.length === entry.hooks.length ? entry : { ...entry, hooks };
+  }).filter(Boolean);
+  return { entries: deduplicated, changed };
 }
 
 function commandsEqual(a, b) {
   const left = normalizeCommand(a);
   const right = normalizeCommand(b);
-  return Boolean(left && right && left === right);
+  return Boolean(left && right && (left === right ||
+    (notifyIdentity(left) && notifyIdentity(left) === notifyIdentity(right))));
 }
 
 function quoteArg(value) {

package/src/lib/codex-rollout-parser.js

@@ -713,6 +713,8 @@ async function parseCodexRolloutFile(filePath, {
       };
       byModel.set(effectiveModel, row);
     }
+    const subsetKeys = Object.keys(row).filter((key) => /^(?:long_context_|priority_)|^(?:usage_events|rerouted_usage_events)$/.test(key));
+    const before = Object.fromEntries(subsetKeys.map((key) => [key, row[key]]));
     addInto(row, delta);
     row.usage_events += 1;
     if (attribution.selectedModel) {
@@ -758,6 +760,10 @@ async function parseCodexRolloutFile(filePath, {
         row.priority_long_context_reasoning_output_tokens += delta.reasoning_output_tokens;
       }
     }
+    return { ...delta, ...Object.fromEntries(subsetKeys.map((key) => [key, row[key] - before[key]])),
+      selected_models: attribution.selectedModel ? [attribution.selectedModel] : [],
+      reroute_reasons: attribution.rerouteReason ? [attribution.rerouteReason] : [],
+      model_attribution: attribution.rerouted ? "effective" : "selected" };
   }
 
   function ensureTool(name) {
@@ -927,7 +933,9 @@ async function parseCodexRolloutFile(filePath, {
     if (compactionResponseIds.has(record.responseId)) return;
     compactionResponseIds.add(record.responseId);
     if (!record.inRequestedRange) return;
-    recordModelUsage(record.delta, record.rawUsage, record.attribution);
+    const pricedDelta = recordModelUsage(record.delta, record.rawUsage, record.attribution);
+    if (typeof onUsage === "function") onUsage({ timestamp: record.timestamp,
+      delta: pricedDelta || record.delta, rawUsage: record.rawUsage, model: record.attribution.model, origin: "compaction" });
     attributeTurn(record.delta);
   }
 
@@ -1098,8 +1106,8 @@ async function parseCodexRolloutFile(filePath, {
           attributeTurn(null);
         } else {
           if (seenTokenEvents && delta?.total_tokens > 0) seenTokenEvents.add(eventKey);
-          recordModelUsage(delta, lastUsage || rawDelta);
-          if (typeof onUsage === "function") onUsage({ timestamp: ts, delta, rawUsage: lastUsage || rawDelta, model: attributedModel });
+          const pricedDelta = recordModelUsage(delta, lastUsage || rawDelta);
+          if (typeof onUsage === "function") onUsage({ timestamp: ts, delta: pricedDelta || delta, rawUsage: lastUsage || rawDelta, model: attributedModel });
           attributeTurn(delta);
         }
       } else {

package/src/lib/command-runner.js

@@ -15,6 +15,7 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 
+/** Run a command without a shell by default, optionally piping options.input to stdin. */
 function runCommand(commandRunner, command, args, options = {}) {
   const merged = {
     encoding: "utf8",
@@ -29,6 +30,7 @@ function runCommand(commandRunner, command, args, options = {}) {
   const {
     timeout,
     maxBuffer,
+    input,
     completeWhen,
     completionGraceMs = 250,
     killProcessGroup = false,
@@ -64,7 +66,7 @@ function runCommand(commandRunner, command, args, options = {}) {
         ...spawnOptions,
         detached: useProcessGroup || spawnOptions.detached,
         shell: useShell,
-        stdio: ["ignore", "pipe", "pipe"],
+        stdio: [input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
       });
     } catch (error) {
       resolve({ status: null, stdout: "", stderr: "", error });
@@ -168,6 +170,18 @@ function runCommand(commandRunner, command, args, options = {}) {
     if (Number.isFinite(timeout) && timeout > 0) {
       timer = setTimeout(() => stopChild({ timeoutExpired: true }), timeout);
     }
+    if (input !== undefined) {
+      child.stdin?.on("error", (error) => {
+        signalChild("SIGKILL");
+        settle({ error });
+      });
+      try {
+        child.stdin?.end(input);
+      } catch (error) {
+        signalChild("SIGKILL");
+        settle({ error });
+      }
+    }
   });
 }
 

package/src/lib/cursor-config.js

@@ -15,7 +15,8 @@ function resolveCursorPaths({ home, platform = process.platform, env = process.e
     appDir = pathForPlatform.join(h, "Library", "Application Support", "Cursor");
   } else if (platform === "win32") {
     const appData =
-      (typeof env.APPDATA === "string" && env.APPDATA.trim()) ||
+      ((!home || h === os.homedir() || env !== process.env) &&
+        typeof env.APPDATA === "string" && env.APPDATA.trim()) ||
       pathForPlatform.join(h, "AppData", "Roaming");
     appDir = pathForPlatform.join(appData, "Cursor");
   } else {

package/src/lib/gemini-config.js

@@ -3,6 +3,7 @@ const path = require("node:path");
 const fs = require("node:fs/promises");
 
 const { ensureDir, readJson, writeJson } = require("./fs");
+const { buildNotifyCommand } = require("./notify-command");
 
 const DEFAULT_EVENT = "SessionEnd";
 const DEFAULT_HOOK_NAME = "tokentracker";
@@ -99,9 +100,9 @@ async function isGeminiHookConfigured({
   return hasHook(entries, { hookCommand, hookName });
 }
 
-function buildGeminiHookCommand(notifyPath) {
+function buildGeminiHookCommand(notifyPath, options) {
   const cmd = typeof notifyPath === "string" ? notifyPath : "";
-  return `/usr/bin/env node ${quoteArg(cmd)} --source=gemini`;
+  return buildNotifyCommand(cmd, "gemini", options);
 }
 
 function buildHookEntry({ hookCommand, hookName, matcher }) {

package/src/lib/local-api.js

@@ -1056,7 +1056,17 @@ function scanClaudeProjects(projectMap) {
 // ---------------------------------------------------------------------------
 
 function json(res, data, status) {
-  res.writeHead(status || 200, { "Content-Type": "application/json" });
+  // Usage and cost payloads change on every sync, and cost is re-priced on
+  // every read (pricing is applied per request, never stored in the queue) —
+  // so a cached response can pin stale costs on screen indefinitely. WebView2
+  // caches responses that carry no freshness directive, and the dashboard's
+  // local fetch path omits `cache: "no-store"` (only the cloud path sets it).
+  // Endpoints that care already set this header by hand; do it once here so
+  // every JSON response is covered.
+  res.writeHead(status || 200, {
+    "Content-Type": "application/json",
+    "Cache-Control": "no-store",
+  });
   res.end(JSON.stringify(data));
 }
 
@@ -2610,7 +2620,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
         const sessions = await buildSessionAnalytics({ force: refresh });
         const wantsCsv = url.searchParams.get("format") === "csv";
         const includeSessions = wantsCsv || ["1", "true"].includes(url.searchParams.get("include_sessions"));
-        const result = summarizeSessions(sessions, { from, to, includeSessions });
+        const result = summarizeSessions(sessions, { from, to, includeSessions, ...getTimeZoneContext(url) });
         if (wantsCsv) {
           const content = sessionsToCsv(result.sessions);
           res.statusCode = 200;
@@ -2645,7 +2655,7 @@ function createLocalApiHandler({ queuePath, serverVersion = null, trackerDataDir
       try {
         const { buildSessionAnalytics, listSessionsForBrowser } = require("./session-analytics");
         const sessions = await buildSessionAnalytics({ force: refresh });
-        const result = listSessionsForBrowser(sessions, { from, to, limit });
+        const result = listSessionsForBrowser(sessions, { from, to, limit, ...getTimeZoneContext(url) });
         json(res, { from, to, ...result });
       } catch (error) {
         // Node fs errors embed the absolute path ("EACCES ... open '/Users/…'").