tokentracker-cli 0.84.9 → 0.86.0

package/src/commands/status.js

@@ -48,6 +48,9 @@ const {
   resolveKimiCodeWireFiles,
   resolveKiroCliDbPath,
   resolveKiroCliSessionFiles,
+  resolveKiroBasePath,
+  resolveKiroDbPath,
+  resolveKiroJsonlPath,
   resolveCodebuddyHome,
   resolveCodebuddyProjectFiles,
   resolveWorkbuddyHome,
@@ -63,6 +66,7 @@ const {
   resolveRoocodeTaskFiles,
   resolveZedDbPath,
   resolveQoderDbPaths,
+  resolveClaudeScienceDbPaths,
   resolveAnythingllmDbPath,
   resolveGooseDbPath,
   listDroidSettingsFiles,
@@ -235,10 +239,100 @@ async function cmdStatus(argv = []) {
   // event sessions. End-user dashboards show them merged under "Kiro"; this
   // status line surfaces which passive sources are actually present.
   const kiroCliDbPath = resolveKiroCliDbPath(process.env);
-  const kiroCliDbExists = fssync.existsSync(kiroCliDbPath);
   const kiroCliSessionFiles = resolveKiroCliSessionFiles(process.env);
-  const kiroCliInstalled =
-    kiroCliDbExists || kiroCliSessionFiles.length > 0;
+  const kiroCliNativePresent =
+    fssync.existsSync(kiroCliDbPath) || kiroCliSessionFiles.length > 0;
+  // WSL install discovery mirrors sync: overrides pin a single install.
+  let kiroCliWsl = null; // { db, sessionFiles }
+  if (
+    process.platform === "win32" &&
+    !process.env.KIRO_CLI_DB_PATH && !process.env.KIRO_HOME &&
+    wsl.shouldProbeWsl(process.env)
+  ) {
+    const wslKiroHomeDir = wsl.discoverWslHome(".kiro");
+    const wslCliDataDir = wsl.discoverWslHome(".local/share/kiro-cli");
+    const wslHomeRoot = wslKiroHomeDir
+      ? path.dirname(wslKiroHomeDir)
+      : (wslCliDataDir ? path.dirname(path.dirname(path.dirname(wslCliDataDir))) : null);
+    if (wslHomeRoot) {
+      const wslDb = path.join(wslHomeRoot, ".local", "share", "kiro-cli", "data.sqlite3");
+      const wslFiles = resolveKiroCliSessionFiles({
+        ...process.env,
+        KIRO_CLI_DB_PATH: wslDb,
+        KIRO_HOME: path.join(wslHomeRoot, ".kiro"),
+      });
+      if (fssync.existsSync(wslDb) || wslFiles.length > 0) {
+        kiroCliWsl = { db: wslDb, sessionFiles: wslFiles };
+      }
+    }
+  }
+  const kiroCliPaths = process.platform === "win32"
+    ? wsl.resolveAllWin32Paths({
+      nativeValue: kiroCliNativePresent ? kiroCliDbPath : null,
+      wslValue: kiroCliWsl ? kiroCliWsl.db : null,
+      env: process.env,
+      platform: "win32",
+    })
+    : { native: kiroCliNativePresent ? kiroCliDbPath : null, wsl: null };
+  // Non-both modes park the picked value in the native slot — label by
+  // marker identity, not slot name. A session-files-only install has no DB
+  // on disk; show the sessions dir instead of a nonexistent DB path.
+  const kiroCliMarkers = [kiroCliPaths.native, kiroCliPaths.wsl].filter(Boolean);
+  const kiroCliActive = kiroCliMarkers.map((m) => {
+    if (kiroCliWsl && m === kiroCliWsl.db) {
+      const shown = fssync.existsSync(m) || kiroCliWsl.sessionFiles.length === 0
+        ? m
+        : path.dirname(kiroCliWsl.sessionFiles[0]);
+      return `WSL: ${shown}`;
+    }
+    const shown = fssync.existsSync(m) || kiroCliSessionFiles.length === 0
+      ? m
+      : path.dirname(kiroCliSessionFiles[0]);
+    return `native: ${shown}`;
+  });
+  const kiroCliFileCount =
+    (kiroCliMarkers.includes(kiroCliDbPath) ? kiroCliSessionFiles.length : 0) +
+    (kiroCliWsl && kiroCliMarkers.includes(kiroCliWsl.db) ? kiroCliWsl.sessionFiles.length : 0);
+  const kiroCliDbFound = kiroCliMarkers.some((m) => {
+    try { return fssync.existsSync(m); } catch (_e) { return false; }
+  });
+  const kiroCliInstalled = kiroCliMarkers.length > 0;
+
+  // Kiro IDE — passive scan of globalStorage dev_data (SQLite or JSONL).
+  const kiroIdeNativeBase = resolveKiroBasePath(process.env);
+  const wslKiroIdeBase = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+    ? wsl.discoverWslHome(".config/Kiro/User/globalStorage/kiro.kiroagent")
+    : null;
+  const kiroIdePaths = resolveInstallPaths({ nativeValue: kiroIdeNativeBase, wslValue: wslKiroIdeBase });
+  const kiroIdeHasData = (base) => Boolean(base)
+    && (fssync.existsSync(resolveKiroDbPath(base)) || fssync.existsSync(resolveKiroJsonlPath(base)));
+  const kiroIdeActive = [kiroIdePaths.native, kiroIdePaths.wsl]
+    .filter((base) => kiroIdeHasData(base))
+    .map((base) => (wslKiroIdeBase && base === wslKiroIdeBase ? `WSL: ${base}` : `native: ${base}`));
+  const kiroIdeInstalled = kiroIdeActive.length > 0;
+
+  // Claude Code — dual-install aware projects scan (#307). Mirrors sync:
+  // installs are UNIONED (not single-picked by mode) so a WSL ~/.claude
+  // never hides the native one from view, and labels come from install
+  // identity rather than resolveAllWin32Paths' slot names.
+  const claudeCodeActive = [];
+  {
+    const claudeHomesStatus = [];
+    if (process.platform !== "win32" || wsl.shouldProbeNative(process.env)) {
+      claudeHomesStatus.push({ dir: path.join(home, ".claude"), label: "native" });
+    }
+    const wslClaudeHomeStatus = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+      ? wsl.discoverWslHome(".claude")
+      : null;
+    if (wslClaudeHomeStatus) claudeHomesStatus.push({ dir: wslClaudeHomeStatus, label: "WSL" });
+    for (const { dir, label } of claudeHomesStatus) {
+      const projects = path.join(dir, "projects");
+      try {
+        if (fssync.existsSync(projects)) claudeCodeActive.push(`${label}: ${projects}`);
+      } catch (_e) {}
+    }
+  }
+  const claudeCodeInstalled = claudeCodeActive.length > 0;
 
   // AnythingLLM Desktop — per-message token metrics in workspace_chats.
   const anythingllmDbPath = resolveAnythingllmDbPath(process.env);
@@ -332,6 +426,14 @@ async function cmdStatus(argv = []) {
   const qoderInstalled = qoderActive.length > 0;
   const qoderDbPath = qoderActive.join(" | ");
 
+  // Claude Science — token usage lives on the `frames` table of operon-cli.db.
+  // Unlike the native/WSL pair other providers resolve to, this is an open-ended
+  // list: multi-org installs keep one DB per org (and on Windows they all sit
+  // inside WSL), so the resolver already returns only paths that exist.
+  const claudeScienceActive = resolveClaudeScienceDbPaths({ home, env: process.env });
+  const claudeScienceInstalled = claudeScienceActive.length > 0;
+  const claudeScienceDbPath = claudeScienceActive.join(" | ");
+
   // OpenCode (JSON files + SQLite DB) — passive scan of storage/message/ and opencode.db.
   const opencodeStorageNativeValue = process.env.OPENCODE_HOME || path.join(xdgDataHome, "opencode");
   const wslOpencodeStorageDir = process.platform === "win32" && shouldProbeWsl(process.env)
@@ -650,13 +752,19 @@ async function cmdStatus(argv = []) {
         kiro_cli: kiroCliInstalled
           ? {
               installed: true,
-              detail: kiroCliDbExists
-                ? kiroCliDbPath
-                : path.dirname(kiroCliSessionFiles[0]),
-              database: kiroCliDbExists ? kiroCliDbPath : null,
-              files: kiroCliSessionFiles.length,
+              detail: kiroCliActive.join(" | "),
+              database: kiroCliMarkers.find((m) => {
+                try { return fssync.existsSync(m); } catch (_e) { return false; }
+              }) || null,
+              files: kiroCliFileCount,
             }
           : { installed: false },
+        kiro_ide: kiroIdeInstalled
+          ? { installed: true, detail: kiroIdeActive.join(" | ") }
+          : { installed: false },
+        claude_code: claudeCodeInstalled
+          ? { installed: true, detail: claudeCodeActive.join(" | ") }
+          : { installed: false },
         codebuddy: codebuddyInstalled
           ? { installed: true, files: codebuddyFiles.length }
           : { installed: false },
@@ -687,6 +795,9 @@ async function cmdStatus(argv = []) {
         qoder: qoderInstalled
           ? { installed: true, detail: qoderDbPath }
           : { installed: false },
+        "claude-science": claudeScienceInstalled
+          ? { installed: true, detail: claudeScienceDbPath }
+          : { installed: false },
         kilocode: kilocodeInstalled
           ? { installed: true, files: kilocodeTaskFiles.length }
           : { installed: false },
@@ -761,6 +872,9 @@ async function cmdStatus(argv = []) {
       `- Codex notify: ${notifyConfigured ? JSON.stringify(codexNotify) : "unset"}`,
       `- Every Code notify: ${everyCodeConfigured ? JSON.stringify(everyCodeNotify) : "unset"}`,
       `- Claude hooks: ${claudeHookConfigured ? "set" : "unset"}`,
+      claudeCodeInstalled
+        ? `- Claude Code: projects found (${claudeCodeActive.join(" | ")})`
+        : null,
       `- Gemini hooks: ${geminiHookConfigured ? "set" : "unset"}`,
       `- Opencode plugin: ${opencodePluginConfigured ? "set" : "unset"}`,
       `- OpenClaw session plugin: ${openclawSessionPluginState?.configured ? "set" : "unset"}`,
@@ -770,7 +884,10 @@ async function cmdStatus(argv = []) {
         ? `- Kimi Code: passive reader (${kimiWireFiles.length + kimiCodeWireFiles.length} wire.jsonl file${(kimiWireFiles.length + kimiCodeWireFiles.length) !== 1 ? "s" : ""} found, directories: ${kimiActive.join(" | ") || "none"})`
         : null,
       kiroCliInstalled
-        ? `- Kiro CLI: passive reader (${kiroCliSessionFiles.length} session file${kiroCliSessionFiles.length !== 1 ? "s" : ""} found, SQLite ${kiroCliDbExists ? "found" : "not found"}; tokens approximated from char lengths and merged under 'kiro')`
+        ? `- Kiro CLI: passive reader (${kiroCliFileCount} session file${kiroCliFileCount !== 1 ? "s" : ""} found, SQLite ${kiroCliDbFound ? "found" : "not found"}, installs: ${kiroCliActive.join(" | ")}; tokens approximated from char lengths and merged under 'kiro')`
+        : null,
+      kiroIdeInstalled
+        ? `- Kiro IDE: passive reader (${kiroIdeActive.join(" | ")})`
         : null,
       codebuddyInstalled
         ? `- CodeBuddy hooks: ${codebuddyHookConfigured ? "set" : "unset"} (${codebuddyFiles.length} usage file${codebuddyFiles.length !== 1 ? "s" : ""} found)`
@@ -802,6 +919,9 @@ async function cmdStatus(argv = []) {
       qoderInstalled
         ? `- Qoder: passive reader (${qoderDbPath})`
         : null,
+      claudeScienceInstalled
+        ? `- Claude Science: passive reader (${claudeScienceDbPath})`
+        : null,
       opencodeInstalled
         ? `- OpenCode: passive reader (storage: ${opencodeStorageActive.join(" | ") || "not found"}, DB: ${opencodeDbActive.join(" | ") || "not found"})`
         : null,

package/src/commands/sync.js

@@ -24,6 +24,7 @@ const {
   readQoderDbMessages,
   resolveKiroDbPath,
   resolveKiroJsonlPath,
+  resolveKiroBasePath,
   resolveHermesPath,
   resolveCopilotOtelPaths,
   normalizeCopilotDbPath,
@@ -39,12 +40,20 @@ const {
   parseOpencodeDbIncremental,
   parseQoderDbIncremental,
   parseOpenclawIncremental,
+  resolveOpenclawSessionFiles,
+  resolveOpenclawHome,
+  openclawCursorKey,
+  resolveClaudeScienceDbPaths,
+  readClaudeScienceFrames,
+  parseClaudeScienceIncremental,
   parseCursorApiIncremental,
   parseKiroIncremental,
   parseHermesIncremental,
   gooseInstallOwnsCursor,
   zedInstallOwnsCursor,
   hermesInstallOwnsCursor,
+  kiroInstallOwnsCursor,
+  kiroCliInstallOwnsCursor,
   copilotOtelCursorHasLegacyCliUsage,
   pruneCopilotUsageClaims,
   parseCopilotIncremental,
@@ -234,6 +243,7 @@ const AUTO_SYNC_SOURCES = new Set([
   "antigravity",
   "anythingllm",
   "claude",
+  "claude-science",
   "codebuddy",
   "codex",
   "copilot",
@@ -443,7 +453,25 @@ async function cmdSync(argv, context = {}) {
     }
     let grokHookSignalConsumed = false;
 
-    const claudeProjectsDir = path.join(home, ".claude", "projects");
+    // Claude Code home — dual-install aware (#307): a Windows host may carry
+    // a native ~/.claude plus a WSL install reachable over \\wsl$. Unlike the
+    // SQLite providers, Claude UNIONS every allowed install instead of taking
+    // resolveAllWin32Paths' single pick: under the default wsl-first mode a
+    // WSL ~/.claude would otherwise silently evict the native one from
+    // collection — and from the "disk is truth" ground-truth repair below,
+    // which would then erase the native history. The file-hash and
+    // message-hash dedup layers make the union safe. Native is listed first
+    // so the cross-environment file dedup keeps the native copy as primary.
+    const claudeNativeHome = path.join(home, ".claude");
+    const wslClaudeHome = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+      ? wsl.discoverWslHome(".claude")
+      : null;
+    const claudeInstallHomes = [];
+    if (process.platform !== "win32" || wsl.shouldProbeNative(process.env)) {
+      claudeInstallHomes.push(claudeNativeHome);
+    }
+    if (wslClaudeHome) claudeInstallHomes.push(wslClaudeHome);
+    const claudeProjectsDirs = claudeInstallHomes.map((h) => path.join(h, "projects"));
     const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
     const kiloHome = process.env.KILO_HOME || path.join(xdgDataHome, "kilo");
     const mimoHome = process.env.MIMO_HOME || path.join(xdgDataHome, "mimocode");
@@ -452,7 +480,7 @@ async function cmdSync(argv, context = {}) {
     // OpenClaw session plugin integration: lifecycle hooks request an
     // OpenClaw-only auto sync so unrelated providers do not get walked.
     const openclawSignal = opts.fromOpenclaw
-      ? resolveOpenclawSignal({ home, env: process.env })
+      ? resolveOpenclawSignal({ env: process.env })
       : null;
 
     const autoSourceScope = resolveAutoSourceScope(opts);
@@ -647,9 +675,38 @@ async function cmdSync(argv, context = {}) {
       codexCursorLoadRestarted = Boolean(loadResult?.restarted);
     }
 
-    const openclawFiles = openclawSignal?.sessionFile
-      ? [{ path: openclawSignal.sessionFile, source: "openclaw" }]
-      : [];
+    // 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
+    // event-identity dedup makes the plugin and passive paths idempotent, so
+    // overlap on the same file is safe.
+    //
+    // Keyed by openclawCursorKey, not the raw path: that is the same identity
+    // the parser assigns cursors by, so a plugin-supplied path and a scanned
+    // path that differ only in Windows casing collapse to one entry instead of
+    // being parsed twice.
+    const openclawSessionFiles = new Map();
+    if (openclawSignal?.sessionFile) {
+      openclawSessionFiles.set(openclawCursorKey(openclawSignal.sessionFile), {
+        path: openclawSignal.sessionFile,
+        source: "openclaw",
+      });
+    }
+    if (isFullSourceScan && sourceAllowed("openclaw")) {
+      try {
+        for (const f of await resolveOpenclawSessionFiles(process.env)) {
+          const key = openclawCursorKey(f);
+          if (!openclawSessionFiles.has(key)) {
+            openclawSessionFiles.set(key, { path: f, source: "openclaw" });
+          }
+        }
+      } catch (err) {
+        warnProviderParseFailure("OpenClaw", err, opts);
+      }
+    }
+    const openclawFiles = Array.from(openclawSessionFiles.values());
 
     if (progress?.enabled) {
       progress.start(
@@ -719,7 +776,7 @@ async function cmdSync(argv, context = {}) {
 
     let openclawResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (sourceAllowed("openclaw") && openclawFiles.length > 0) {
-      // Only runs when explicitly triggered by the OpenClaw session plugin.
+      // Parses plugin-triggered and/or passively discovered session files.
       try {
         openclawResult = await parseOpenclawIncremental({
           sessionFiles: openclawFiles,
@@ -751,7 +808,18 @@ async function cmdSync(argv, context = {}) {
     openclawResult.eventsAggregated += openclawFallback.eventsAggregated;
     openclawResult.bucketsQueued += openclawFallback.bucketsQueued;
 
-    const claudeFiles = sourceAllowed("claude") ? await listClaudeProjectFiles(claudeProjectsDir) : [];
+    let claudeFiles = [];
+    if (sourceAllowed("claude")) {
+      const seenClaudeFiles = new Set();
+      for (const dir of claudeProjectsDirs) {
+        for (const f of await listClaudeProjectFiles(dir)) {
+          if (!seenClaudeFiles.has(f)) {
+            seenClaudeFiles.add(f);
+            claudeFiles.push(f);
+          }
+        }
+      }
+    }
     if (isFullSourceScan) {
       await reincludeClaudeMemObserverFiles({ cursors, claudeFiles, queuePath, queueStatePath });
       await repairClaudeQueueFromGroundTruth({
@@ -760,6 +828,7 @@ async function cmdSync(argv, context = {}) {
         queueStatePath,
         projectQueuePath,
         projectQueueStatePath,
+        rootDirs: claudeProjectsDirs,
       });
     }
     let claudeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
@@ -1022,6 +1091,45 @@ async function cmdSync(argv, context = {}) {
       }
     }
 
+    // ── Claude Science (Anthropic's local research workbench, issue #246) ──
+    // Per-frame token usage lives on the `frames` table of operon-cli.db.
+    // Passive, incremental, subtract-on-change. There can be more than one DB:
+    // multi-org installs keep one per org, and on Windows the app runs inside
+    // WSL so the DB is on the distro home.
+    let claudeScienceResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (sourceAllowed("claude-science")) {
+      // Resolution is inside the error isolation too: it touches the filesystem
+      // and (on Windows) probes WSL, and a throw here would abort cmdSync before
+      // any provider's buckets are written, not just this one's.
+      let claudeScienceDbPaths = [];
+      try {
+        claudeScienceDbPaths = resolveClaudeScienceDbPaths({ home, env: process.env });
+      } catch (err) {
+        warnProviderParseFailure("Claude Science", err, opts);
+      }
+      if (claudeScienceDbPaths.length > 0 && progress?.enabled) {
+        progress.start(`Parsing Claude Science ${renderBar(0)} | buckets 0`);
+      }
+      for (const claudeScienceDbPath of claudeScienceDbPaths) {
+        try {
+          const dbRows = await readClaudeScienceFrames(claudeScienceDbPath);
+          const parsed = await parseClaudeScienceIncremental({
+            dbRows,
+            cursors,
+            queuePath,
+            onProgress: makeProviderProgress("Claude Science"),
+          });
+          claudeScienceResult = mergeParseResult(claudeScienceResult, {
+            recordsProcessed: parsed.recordsProcessed || 0,
+            eventsAggregated: parsed.eventsAggregated || 0,
+            bucketsQueued: parsed.bucketsQueued || 0,
+          });
+        } catch (err) {
+          warnProviderParseFailure("Claude Science", err, opts);
+        }
+      }
+    }
+
     async function parseOpencodeDbForInstall({ dbPath, readFn, source, cursorKey, ...rest }) {
       if (!dbPath || !fssync.existsSync(dbPath)) {
         return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
@@ -1344,30 +1452,44 @@ async function cmdSync(argv, context = {}) {
       }
     }
 
-    // ── Kiro (SQLite-based, with JSONL fallback) ──
+    // ── Kiro (SQLite-based, with JSONL fallback; dual-install aware) ──
     let kiroResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    const kiroDbPath = resolveKiroDbPath();
-    const kiroJsonlPath = resolveKiroJsonlPath();
-    if (sourceAllowed("kiro") && (fssync.existsSync(kiroDbPath) || fssync.existsSync(kiroJsonlPath))) {
-      if (progress?.enabled) {
-        progress.start(`Parsing Kiro ${renderBar(0)} | buckets 0`);
-      }
-      try {
-        kiroResult = await parseKiroIncremental({
-          dbPath: kiroDbPath,
-          jsonlPath: kiroJsonlPath,
-          cursors,
-          queuePath,
-          onProgress: (p) => {
-            if (!progress?.enabled) return;
-            const pct = p.total > 0 ? p.index / p.total : 1;
-            progress.update(
-              `Parsing Kiro ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} records | buckets ${formatNumber(p.bucketsQueued)}`,
-            );
-          },
-        });
-      } catch (err) {
-        warnProviderParseFailure("Kiro", err, opts);
+    if (sourceAllowed("kiro")) {
+      const kiroNativeBase = resolveKiroBasePath(process.env);
+      const wslKiroBase = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+        ? wsl.discoverWslHome(".config/Kiro/User/globalStorage/kiro.kiroagent")
+        : null;
+      const kiroPaths = resolveInstallPaths({ nativeValue: kiroNativeBase, wslValue: wslKiroBase });
+      // resolveInstallPaths only checks the base dir (and skips the check off
+      // win32); keep the original per-install db/jsonl presence gate so empty
+      // installs never spin up a parse or seed a cursor namespace.
+      const kiroHasData = (base) => Boolean(base)
+        && (fssync.existsSync(resolveKiroDbPath(base)) || fssync.existsSync(resolveKiroJsonlPath(base)));
+      if (!kiroHasData(kiroPaths.native)) kiroPaths.native = null;
+      if (!kiroHasData(kiroPaths.wsl)) kiroPaths.wsl = null;
+      if (kiroPaths.native || kiroPaths.wsl) {
+        if (progress?.enabled) {
+          progress.start(`Parsing Kiro ${renderBar(0)} | buckets 0`);
+        }
+        try {
+          kiroResult = await multiInstallParse({
+            paths: kiroPaths,
+            parserFn: parseKiroIncremental,
+            providerName: "kiro",
+            cursors,
+            getParams: (base) => ({
+              basePath: base,
+              dbPath: resolveKiroDbPath(base),
+              jsonlPath: resolveKiroJsonlPath(base),
+            }),
+            queuePath,
+            onProgress: makeProviderProgress("Kiro"),
+            detectInstall: (base, flatState) =>
+              kiroInstallOwnsCursor(resolveKiroDbPath(base), flatState),
+          });
+        } catch (err) {
+          warnProviderParseFailure("Kiro", err, opts);
+        }
       }
     }
 
@@ -1454,28 +1576,79 @@ async function cmdSync(argv, context = {}) {
     // token counts (billing is credit-based on Bedrock); we approximate at
     // 4 chars/token from user prompt chars and assistant response chars.
     let kiroCliResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    const kiroCliDb = resolveKiroCliDbPath(process.env);
-    const kiroCliSessionFiles = sourceAllowed("kiro") ? resolveKiroCliSessionFiles(process.env) : [];
-    if (sourceAllowed("kiro") && (fssync.existsSync(kiroCliDb) || kiroCliSessionFiles.length > 0)) {
-      if (progress?.enabled) {
-        progress.start(`Parsing Kiro CLI ${renderBar(0)} | buckets 0`);
+    if (sourceAllowed("kiro")) {
+      const kiroCliDb = resolveKiroCliDbPath(process.env);
+      const kiroCliSessionFiles = resolveKiroCliSessionFiles(process.env);
+      const nativeCliPresent = fssync.existsSync(kiroCliDb) || kiroCliSessionFiles.length > 0;
+
+      // Explicit overrides pin a single install — never mix them with WSL
+      // auto-discovery (mirrors the Hermes TOKENTRACKER_HERMES_HOME branch).
+      const kiroCliOverride = Boolean(process.env.KIRO_CLI_DB_PATH || process.env.KIRO_HOME);
+      let wslKiroCliEnv = null;
+      let wslKiroCliMarker = null;
+      if (!kiroCliOverride && process.platform === "win32" && wsl.shouldProbeWsl(process.env)) {
+        // A WSL install owns BOTH a data dir (~/.local/share/kiro-cli) and a
+        // sessions home (~/.kiro). Derive both from whichever probe hits so
+        // the per-install env never falls back to native paths.
+        const wslKiroHomeDir = wsl.discoverWslHome(".kiro");
+        const wslCliDataDir = wsl.discoverWslHome(".local/share/kiro-cli");
+        const wslHomeRoot = wslKiroHomeDir
+          ? path.dirname(wslKiroHomeDir)
+          : (wslCliDataDir ? path.dirname(path.dirname(path.dirname(wslCliDataDir))) : null);
+        if (wslHomeRoot) {
+          const wslCliDb = path.join(wslHomeRoot, ".local", "share", "kiro-cli", "data.sqlite3");
+          wslKiroCliEnv = {
+            ...process.env,
+            KIRO_CLI_DB_PATH: wslCliDb,
+            KIRO_HOME: path.join(wslHomeRoot, ".kiro"),
+          };
+          const wslCliPresent = fssync.existsSync(wslCliDb)
+            || resolveKiroCliSessionFiles(wslKiroCliEnv).length > 0;
+          if (wslCliPresent) wslKiroCliMarker = wslCliDb;
+        }
       }
-      try {
-        kiroCliResult = await parseKiroCliIncremental({
-          cursors,
-          queuePath,
+
+      // Paths here are install markers only — the parser resolves its DB and
+      // session files from the per-install env (KIRO_CLI_DB_PATH/KIRO_HOME).
+      const kiroCliPaths = process.platform === "win32"
+        ? wsl.resolveAllWin32Paths({
+          nativeValue: nativeCliPresent ? kiroCliDb : null,
+          wslValue: wslKiroCliMarker,
           env: process.env,
-          onProgress: (p) => {
-            if (!progress?.enabled) return;
-            const pct = p.total > 0 ? p.index / p.total : 1;
-            progress.update(
-              `Parsing Kiro CLI ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
-            );
-          },
-        });
-      } catch (err) {
-        if (!opts.auto) {
-          process.stderr.write(`Kiro CLI sync: ${err.message}\n`);
+          platform: "win32",
+        })
+        : { native: nativeCliPresent ? kiroCliDb : null, wsl: null };
+      const kiroCliEnvFor = (p) =>
+        wslKiroCliEnv && p === wslKiroCliMarker ? wslKiroCliEnv : process.env;
+      if (kiroCliPaths.native || kiroCliPaths.wsl) {
+        if (progress?.enabled) {
+          progress.start(`Parsing Kiro CLI ${renderBar(0)} | buckets 0`);
+        }
+        try {
+          kiroCliResult = await multiInstallParse({
+            paths: kiroCliPaths,
+            parserFn: parseKiroCliIncremental,
+            providerName: "kiroCli",
+            cursors,
+            // Per-install env MUST come from getParams: multiInstallParse
+            // spreads shared params over it, so a top-level env would clobber
+            // the per-install one.
+            getParams: (p) => ({ env: kiroCliEnvFor(p) }),
+            queuePath,
+            onProgress: (p) => {
+              if (!progress?.enabled) return;
+              const pct = p.total > 0 ? p.index / p.total : 1;
+              progress.update(
+                `Parsing Kiro CLI ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
+              );
+            },
+            detectInstall: (p, flatState) =>
+              kiroCliInstallOwnsCursor(kiroCliEnvFor(p).KIRO_CLI_DB_PATH || kiroCliDb, flatState),
+          });
+        } catch (err) {
+          if (!opts.auto) {
+            process.stderr.write(`Kiro CLI sync: ${err.message}\n`);
+          }
         }
       }
     }
@@ -2117,6 +2290,7 @@ async function cmdSync(argv, context = {}) {
       antigravityResult.filesProcessed +
       opencodeResult.filesProcessed +
       qoderResult.recordsProcessed +
+      claudeScienceResult.recordsProcessed +
       cursorResult.recordsProcessed +
       kiroResult.recordsProcessed +
       kiroCliResult.recordsProcessed +
@@ -2147,6 +2321,7 @@ async function cmdSync(argv, context = {}) {
       antigravityResult.bucketsQueued +
       opencodeResult.bucketsQueued +
       qoderResult.bucketsQueued +
+      claudeScienceResult.bucketsQueued +
       cursorResult.bucketsQueued +
       kiroResult.bucketsQueued +
       kiroCliResult.bucketsQueued +
@@ -2488,15 +2663,18 @@ function normalizeString(value) {
   return trimmed.length > 0 ? trimmed : null;
 }
 
-function resolveOpenclawSignal({ home, env } = {}) {
+function resolveOpenclawSignal({ env } = {}) {
   if (!env) return null;
 
   const agentId = normalizeString(env.TOKENTRACKER_OPENCLAW_AGENT_ID);
   const sessionId = normalizeString(env.TOKENTRACKER_OPENCLAW_PREV_SESSION_ID);
   if (!agentId || !sessionId) return null;
 
-  const openclawHome =
-    normalizeString(env.TOKENTRACKER_OPENCLAW_HOME) || path.join(home || os.homedir(), ".openclaw");
+  // Resolve the OpenClaw home identically to the passive scanner so the
+  // plugin-triggered file and passively discovered files share one path
+  // spelling — otherwise the same transcript could get two cursors and be
+  // counted twice (issue #264 review).
+  const openclawHome = resolveOpenclawHome(env);
   const sessionFile = path.join(openclawHome, "agents", agentId, "sessions", `${sessionId}.jsonl`);
 
   const prevTotals = {
@@ -2529,6 +2707,16 @@ async function applyOpenclawTotalsFallback({
     return { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
   }
 
+  // The passive/plugin transcript parse is authoritative: if this session's
+  // transcript has ever yielded real per-event usage, synthesizing sessions.json
+  // totals on top would count the same tokens twice (issue #264 review). Defer
+  // to the real events and advance the fallback baseline so no stale delta lingers.
+  const transcriptCursor =
+    signal.sessionFile && cursors?.files
+      ? cursors.files[openclawCursorKey(signal.sessionFile)]
+      : null;
+  const transcriptHasRealUsage = Boolean(transcriptCursor?.hasRealUsage);
+
   const sessionKey = `${signal.agentId}:${signal.sessionId}`;
   const statePath = path.join(trackerDir, "openclaw.fallback.state.json");
   const fallbackFilePath = path.join(trackerDir, "openclaw.fallback.jsonl");
@@ -2537,6 +2725,22 @@ async function applyOpenclawTotalsFallback({
   const prev =
     sessions[sessionKey] && typeof sessions[sessionKey] === "object" ? sessions[sessionKey] : null;
 
+  if (transcriptHasRealUsage) {
+    sessions[sessionKey] = {
+      totalTokens: normalizeNonNegativeInt(signal?.prevTotals?.totalTokens) || 0,
+      inputTokens: normalizeNonNegativeInt(signal?.prevTotals?.inputTokens) || 0,
+      outputTokens: normalizeNonNegativeInt(signal?.prevTotals?.outputTokens) || 0,
+      model: normalizeString(signal?.prevTotals?.model) || "unknown",
+      updatedAt: normalizeIsoOrEpoch(signal?.prevTotals?.updatedAt) || new Date().toISOString(),
+      seenAt: new Date().toISOString(),
+      coveredByEvents: true,
+    };
+    state.version = 1;
+    state.sessions = sessions;
+    await writeJson(statePath, state);
+    return { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+  }
+
   const current = {
     totalTokens: normalizeNonNegativeInt(signal?.prevTotals?.totalTokens) || 0,
     inputTokens: normalizeNonNegativeInt(signal?.prevTotals?.inputTokens) || 0,
@@ -4688,6 +4892,7 @@ async function repairClaudeQueueFromGroundTruth({
   queueStatePath = null,
   projectQueuePath = null,
   projectQueueStatePath = null,
+  rootDirs = null,
 }) {
   if (!cursors || typeof cursors !== "object") return false;
   const migrations = (cursors.migrations ||= {});
@@ -4695,7 +4900,13 @@ async function repairClaudeQueueFromGroundTruth({
 
   let result;
   try {
-    result = await computeClaudeGroundTruthBuckets();
+    // rootDirs must cover every install the incremental parser scans (native
+    // AND WSL): this repair's semantics are "disk is truth" — it clears all
+    // claude buckets and replaces claudeHashes wholesale, so scanning fewer
+    // roots than sync would silently drop the missing install's history.
+    result = await computeClaudeGroundTruthBuckets(
+      Array.isArray(rootDirs) && rootDirs.length > 0 ? { rootDirs } : {},
+    );
   } catch (e) {
     console.error("[sync] claude ground-truth repair: scan failed:", e?.message || e);
     return false;