tokentracker-cli 0.84.9 → 0.86.0

package/src/lib/rollout.js

@@ -714,6 +714,30 @@ function formatLocalDate(value) {
   return `${year}-${month}-${day}`;
 }
 
+// Identity hash for cross-environment duplicate session files (native and
+// \\wsl$ views of a synced ~/.claude). sha256 of the first 64KB plus the
+// file size: Claude session headers carry sessionId/cwd so the prefix is
+// discriminating, and folding in the size keeps a grown file distinct from
+// a stale copy. Deliberately excludes inode (unstable across the 9p bridge)
+// and mtime (rewritten by sync tools).
+const CLAUDE_FILE_ID_PREFIX_BYTES = 64 * 1024;
+async function claudeFileIdentityHash(filePath, st) {
+  const length = Math.min(CLAUDE_FILE_ID_PREFIX_BYTES, st.size);
+  if (length <= 0) return null;
+  let fh = null;
+  try {
+    fh = await fs.open(filePath, "r");
+    const buf = Buffer.alloc(length);
+    const { bytesRead } = await fh.read(buf, 0, length, 0);
+    const hash = crypto.createHash("sha256").update(buf.subarray(0, bytesRead)).digest("hex");
+    return `${hash}:${st.size}`;
+  } catch (_e) {
+    return null;
+  } finally {
+    if (fh) await fh.close().catch(() => { });
+  }
+}
+
 async function parseClaudeIncremental({
   projectFiles,
   cursors,
@@ -747,6 +771,22 @@ async function parseClaudeIncremental({
     cursors.files = {};
   }
 
+  // Cross-environment file dedup (#307): when the scan list mixes native and
+  // \\wsl$ paths, a session file synced between the environments shows up
+  // twice under different paths. Identify never-parsed files by content hash
+  // and skip the duplicate wholesale — the message-hash layer alone is capped
+  // at 100k entries, and eviction would let bulk history double count.
+  let sawUncFile = false;
+  let sawLocalFile = false;
+  for (const entry of files) {
+    const p = typeof entry === "string" ? entry : entry?.path;
+    if (typeof p !== "string" || !p) continue;
+    if (isUncPath(p)) sawUncFile = true;
+    else sawLocalFile = true;
+    if (sawUncFile && sawLocalFile) break;
+  }
+  const seenFileIds = sawUncFile && sawLocalFile ? new Map() : null;
+
   for (let idx = 0; idx < files.length; idx++) {
     const entry = files[idx];
     const filePath = typeof entry === "string" ? entry : entry?.path;
@@ -766,6 +806,59 @@ async function parseClaudeIncremental({
     const truncated = sameInode && prevOffset > st.size;
     const startOffset = sameInode && !truncated ? prevOffset : 0;
 
+    let fileId = null;
+    if (seenFileIds) {
+      const cachedFileId =
+        sameInode && typeof prev?.fileId === "string" && prev?.fileIdSize === st.size
+          ? prev.fileId
+          : null;
+      fileId = cachedFileId || (await claudeFileIdentityHash(filePath, st));
+      if (fileId) {
+        // Cache on the live cursor object so idle files don't re-hash on
+        // every sync (the idle short-circuit below never rewrites cursors).
+        if (prev && (prev.fileId !== fileId || prev.fileIdSize !== st.size)) {
+          prev.fileId = fileId;
+          prev.fileIdSize = st.size;
+        }
+        const primary = seenFileIds.get(fileId);
+        if (primary === undefined) {
+          seenFileIds.set(fileId, filePath);
+        } else if (!prev && primary !== filePath) {
+          // Never-parsed duplicate of a file already accounted this run (the
+          // native copy sorts first). Mark it caught-up so future syncs only
+          // look at genuinely new tail bytes — message hashes still guard the
+          // tail if the copies diverge later.
+          cursors.files[key] = {
+            inode,
+            offset: st.size,
+            updatedAt: new Date().toISOString(),
+            fileId,
+            fileIdSize: st.size,
+            duplicateOf: primary,
+            ...(projectEnabled
+              ? {
+                  claudeCwd: null,
+                  projectFileContext: buildProjectFileContext(null),
+                  projectRef: null,
+                  projectKey: null,
+                }
+              : {}),
+          };
+          if (cb) {
+            cb({
+              index: idx + 1,
+              total: totalFiles,
+              filePath,
+              filesProcessed,
+              eventsAggregated,
+              bucketsQueued: touchedBuckets.size,
+            });
+          }
+          continue;
+        }
+      }
+    }
+
     // Claude's launch cwd is fixed for a session file's lifetime, so once
     // resolved (found, or confirmed absent) from content it never needs
     // re-extracting. Cache it — and the resolved project's git-config
@@ -850,6 +943,7 @@ async function parseClaudeIncremental({
       inode,
       offset: result.endOffset,
       updatedAt: new Date().toISOString(),
+      ...(fileId ? { fileId, fileIdSize: st.size } : {}),
       ...(projectEnabled
         ? {
             claudeCwd: nextCwd === undefined ? null : nextCwd,
@@ -1205,6 +1299,85 @@ async function parseOpencodeIncremental({
   return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
 }
 
+// Passive discovery of OpenClaw session transcripts (issue #264). OpenClaw was
+// previously counted ONLY when its session plugin fired an `agent_end` hook and
+// pointed sync at one specific <sessionId>.jsonl. That hook silently fails for a
+// whole class of real usage — messages arriving through a channel (e.g. the
+// WeChat ClawBot) whose sessionKey the plugin can't map back to a sessions.json
+// entry, gateways where the plugin never loaded, or newer installs that keep
+// runtime rows in SQLite and only leave archived transcripts on disk. In all of
+// those cases usage exists but shows as 0. Scanning the on-disk transcripts on
+// every full sync (like every other passive provider) closes that gap; the
+// event-identity dedup in parseOpenclawSessionFile makes a plugin trigger and a
+// passive scan of the same file idempotent, so the two paths never double-count.
+// Mirrors OpenClaw's own precedence (OPENCLAW_HOME > state dir override), but
+// deliberately keeps os.homedir() — NOT env.HOME — as the base. OpenClaw itself
+// prefers env.HOME, yet every OpenClaw cursor we have ever written was keyed off
+// an os.homedir()-derived path; switching the base would make Git Bash / MSYS
+// (HOME=/c/Users/x vs C:\Users\x) miss its own cursor and re-count the whole
+// transcript history.
+function resolveOpenclawHome(env = process.env) {
+  const override =
+    (typeof env.TOKENTRACKER_OPENCLAW_HOME === "string" && env.TOKENTRACKER_OPENCLAW_HOME.trim()) ||
+    (typeof env.OPENCLAW_HOME === "string" && env.OPENCLAW_HOME.trim()) ||
+    (typeof env.OPENCLAW_STATE_DIR === "string" && env.OPENCLAW_STATE_DIR.trim()) ||
+    "";
+  return override || path.join(os.homedir(), ".openclaw");
+}
+
+// On Windows the recommended OpenClaw install provisions an app-owned WSL
+// distro and runs the gateway inside it, so %USERPROFILE%\.openclaw is empty
+// while the real state dir sits on the distro's ext4 home (issue #264).
+function resolveOpenclawHomes(env = process.env, deps = {}) {
+  const roots = [resolveOpenclawHome(env)];
+  const platform = deps.platform || process.platform;
+  const overridden =
+    env.TOKENTRACKER_OPENCLAW_HOME || env.OPENCLAW_HOME || env.OPENCLAW_STATE_DIR;
+  if (platform === "win32" && !overridden) {
+    const discoverWslHome = deps.discoverWslHome || wsl.discoverWslHome;
+    const wslRoot = wsl.shouldProbeWsl(env) ? discoverWslHome(".openclaw", { ...deps, env }) : null;
+    if (wslRoot) roots.push(wslRoot);
+  }
+  return roots;
+}
+
+// Transcript artifacts are not always a bare `<sessionId>.jsonl`: resets and
+// deletes leave `<sessionId>.jsonl.reset.<iso>` / `.deleted.<ts>` siblings, and
+// the SQLite migration moves still-hot transcripts into
+// `session-sqlite-import-archive/`. Match the same `*.jsonl*` shape other
+// OpenClaw readers use so those are not silently dropped.
+const OPENCLAW_TRANSCRIPT_SUBDIRS = ["sessions", "session-sqlite-import-archive"];
+
+function isOpenclawTranscriptName(name) {
+  return typeof name === "string" && name.includes(".jsonl") && !name.endsWith(".json");
+}
+
+async function resolveOpenclawSessionFiles(env = process.env, deps = {}) {
+  const out = [];
+  const seen = new Set();
+  for (const openclawHome of resolveOpenclawHomes(env, deps)) {
+    const agentsDir = path.join(openclawHome, "agents");
+    const agents = await safeReadDir(agentsDir);
+    for (const agent of agents) {
+      if (!agent.isDirectory()) continue;
+      for (const subdir of OPENCLAW_TRANSCRIPT_SUBDIRS) {
+        const dir = path.join(agentsDir, agent.name, subdir);
+        const entries = await safeReadDir(dir);
+        for (const entry of entries) {
+          if (!entry.isFile() || !isOpenclawTranscriptName(entry.name)) continue;
+          const full = path.join(dir, entry.name);
+          const key = openclawCursorKey(full);
+          if (seen.has(key)) continue;
+          seen.add(key);
+          out.push(full);
+        }
+      }
+    }
+  }
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
 async function parseOpenclawIncremental({
   sessionFiles,
   cursors,
@@ -1368,6 +1541,20 @@ async function parseOpenclawIncremental({
       usageFingerprint: accepted.usageFingerprint,
       updatedAt: new Date().toISOString(),
       usageEvents: accepted.usageEvents,
+      // Sticky: once a transcript has yielded real per-event usage, the
+      // sessions.json totals fallback must defer to it to avoid double
+      // counting the same tokens twice (see applyOpenclawTotalsFallback).
+      //
+      // The usageEvents check is what makes this work for EXISTING installs:
+      // cursors written before this flag existed carry no `hasRealUsage`, and a
+      // steady-state sync of an unchanged transcript aggregates 0 new events —
+      // so keying off eventsAggregated alone would leave the flag false forever
+      // and let the fallback keep double counting for exactly the users who
+      // already have OpenClaw history.
+      hasRealUsage:
+        Boolean(prev?.hasRealUsage) ||
+        accepted.result.eventsAggregated > 0 ||
+        Object.keys(accepted.usageEvents || {}).length > 0,
     };
     cursorKeys.set(key, key);
 
@@ -2075,7 +2262,10 @@ async function parseClaudeFile({
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
 
   let eventsAggregated = 0;
-  const isMainSession = !filePath.includes("/subagents/");
+  // Separator-agnostic: WSL installs are scanned over \\wsl$ UNC paths where
+  // path.join produces backslashes, and a forward-slash-only check would
+  // misclassify subagent transcripts as main sessions (#307).
+  const isMainSession = !/[\\/]subagents[\\/]/.test(filePath);
   for await (const line of rl) {
     if (!line) continue;
 
@@ -2095,13 +2285,25 @@ async function parseClaudeFile({
           typeof content === "string" ||
           (Array.isArray(content) && content.some((b) => b?.type === "text"));
         if (hasText) {
-          const userTs = typeof userObj?.timestamp === "string" ? userObj.timestamp : null;
-          const userBucketStart = userTs ? toUtcHalfHourStart(userTs) : null;
-          if (userBucketStart) {
-            const userModel = DEFAULT_MODEL;
-            const userBucket = getHourlyBucket(hourlyState, source, userModel, userBucketStart);
-            userBucket.totals.conversation_count += 1;
-            touchedBuckets.add(bucketKey(source, userModel, userBucketStart));
+          // Dedup by the line's uuid so a synced copy of the session file
+          // (WSL mirror of a divergent native file, inode-reset re-read)
+          // cannot re-count the conversation. Usage rows get the same
+          // guarantee from claudeMessageDedupKey; user lines have no
+          // message.id, so the line uuid is the identity.
+          const userKey =
+            seenMessageHashes && typeof userObj?.uuid === "string" && userObj.uuid
+              ? `u:${userObj.uuid}`
+              : null;
+          if (!userKey || !seenMessageHashes.has(userKey)) {
+            if (userKey) seenMessageHashes.add(userKey);
+            const userTs = typeof userObj?.timestamp === "string" ? userObj.timestamp : null;
+            const userBucketStart = userTs ? toUtcHalfHourStart(userTs) : null;
+            if (userBucketStart) {
+              const userModel = DEFAULT_MODEL;
+              const userBucket = getHourlyBucket(hourlyState, source, userModel, userBucketStart);
+              userBucket.totals.conversation_count += 1;
+              touchedBuckets.add(bucketKey(source, userModel, userBucketStart));
+            }
           }
         }
       }
@@ -4420,6 +4622,356 @@ async function parseQoderDbIncremental({
   return { messagesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
 }
 
+// ── Claude Science (Anthropic's local research workbench, issue #246) ──
+//
+// Claude Science keeps all of its state in a SQLite database named
+// `operon-cli.db`. There is no native Windows build — on Windows the app runs
+// INSIDE WSL, so the DB lives on the distro's ext4 home, not under %USERPROFILE%
+// (see resolveClaudeScienceDbPaths).
+//
+// Per-frame token usage lives on the `frames` table. A row is one agent
+// session/sub-session and records its OWN counters; Claude Science's own
+// per-conversation rollup (`sumTokensForRoot`) plainly sums every row under a
+// root, so summing across frames never double-counts a parent's children.
+//
+// TWO load-bearing quirks, both verified against real frames by reproducing
+// Claude Science's own cost function to 6 significant figures:
+//
+//  1. `input_tokens` is OpenAI-style — it ALREADY INCLUDES cache reads and
+//     writes. Claude Science's accumulator adds `totalInputTokens`
+//     (= cacheRead + cacheWrite + uncached), not the Anthropic API's
+//     `input_tokens`. Treating the column as pure non-cached input prices cache
+//     reads at the full input rate and inflates cost ~5.6x, while also counting
+//     the cache columns twice in total_tokens (~1.97x). Subtract them back out.
+//  2. `aux_*` are real, billable usage from background helper calls (rolling
+//     compaction, compaction summaries, artifact provenance extraction,
+//     biosecurity screening, memory extraction). They are DISJOINT from the
+//     headline columns — the summarizer call is issued with
+//     `skip_cost_accumulation: true` so it bypasses the main accumulator — and
+//     Claude Science's own rollup adds them in. Dropping them under-counts by
+//     ~11.5%. `aux_input_tokens` carries the same cache-inclusive convention.
+//
+//     Known approximation: aux tokens get priced at the frame's headline model
+//     rate, but the helper calls actually run on a cheaper model, and Claude
+//     Science does not persist which one (nor a per-aux cache split — the
+//     aux_cache_* columns come back NULL even when aux_cost implies cache
+//     reads). Measured on real frames, that overprices the aux slice ~2.4x,
+//     i.e. ~20% high on the frame total. Counting the tokens and accepting a
+//     bounded cost skew beats dropping 11.5% of usage outright, but if Claude
+//     Science ever records the aux model, price that slice separately.
+//
+// `token_class_usage` is deliberately NOT read: it is an attribution *slice* of
+// the same tokens (assistant_prose / tool_calls / thinking / …), so its classes
+// sum back to the columns above and adding it would double count.
+// The cache and aux columns arrived in later drizzle migrations, so build the
+// SELECT from PRAGMA table_info rather than naming them blindly — an older
+// operon-cli.db must degrade to the columns it has instead of erroring the
+// whole provider out.
+//
+// The usage predicate doubles as the seed-frame filter: a fresh install ships
+// four Anthropic demo frames whose token columns are all NULL. Their
+// `context_data` JSON still carries the demo run's real numbers (~23.6M tokens
+// / $28.5), which is exactly why this parser reads columns and never that blob.
+const CLAUDE_SCIENCE_TOKEN_COLUMNS = [
+  "input_tokens",
+  "output_tokens",
+  "cache_read_tokens",
+  "cache_write_tokens",
+  "aux_input_tokens",
+  "aux_output_tokens",
+  "aux_cache_read_tokens",
+  "aux_cache_write_tokens",
+];
+
+function buildClaudeScienceFramesQuery(columnNames) {
+  const columns = new Set(columnNames);
+  const optional = (col) => (columns.has(col) ? col : `NULL AS ${col}`);
+  const present = CLAUDE_SCIENCE_TOKEN_COLUMNS.filter((col) => columns.has(col));
+  const where = present.length
+    ? `WHERE ${present.map((col) => `COALESCE(${col}, 0) <> 0`).join("\n   OR ")}`
+    : "WHERE 0";
+  return `
+SELECT
+  id,
+  parent_frame_id,
+  model,
+  ${CLAUDE_SCIENCE_TOKEN_COLUMNS.map(optional).join(",\n  ")},
+  created_at,
+  ${optional("updated_at")},
+  ${optional("completed_at")}
+FROM frames
+${where}
+ORDER BY created_at, id
+`;
+}
+
+// `operon.db` is the pre-rename filename; both are still probed.
+const CLAUDE_SCIENCE_DB_FILENAMES = ["operon-cli.db", "operon.db"];
+
+function resolveClaudeScienceRoot({ home = os.homedir(), env = process.env } = {}) {
+  const override =
+    typeof env.CLAUDE_SCIENCE_HOME === "string" && env.CLAUDE_SCIENCE_HOME.trim()
+      ? path.resolve(env.CLAUDE_SCIENCE_HOME.trim())
+      : null;
+  return override || path.join(home, ".claude-science");
+}
+
+function claudeScienceDbsUnderRoot(root) {
+  const out = [];
+  if (!root) return out;
+  for (const name of CLAUDE_SCIENCE_DB_FILENAMES) {
+    const candidate = path.join(root, name);
+    if (fssync.existsSync(candidate)) out.push(candidate);
+  }
+  // Multi-org installs keep one DB per org under orgs/<slug>/.
+  const orgsDir = path.join(root, "orgs");
+  let orgs = [];
+  try {
+    orgs = fssync.readdirSync(orgsDir, { withFileTypes: true });
+  } catch (_e) {
+    orgs = [];
+  }
+  for (const org of orgs) {
+    if (!org.isDirectory()) continue;
+    for (const name of CLAUDE_SCIENCE_DB_FILENAMES) {
+      const candidate = path.join(orgsDir, org.name, name);
+      if (fssync.existsSync(candidate)) out.push(candidate);
+    }
+  }
+  return out;
+}
+
+// Every Claude Science DB on this machine. There is no native Windows build —
+// Windows users run the app inside WSL, so on win32 the distro home is probed
+// too (same pattern as the other WSL-aware providers). Returns [] when nothing
+// is installed.
+function resolveClaudeScienceDbPaths({ home = os.homedir(), env = process.env, deps = {} } = {}) {
+  const explicit =
+    typeof env.CLAUDE_SCIENCE_DB_PATH === "string" && env.CLAUDE_SCIENCE_DB_PATH.trim()
+      ? path.resolve(env.CLAUDE_SCIENCE_DB_PATH.trim())
+      : null;
+  if (explicit) return fssync.existsSync(explicit) ? [explicit] : [];
+
+  const roots = [resolveClaudeScienceRoot({ home, env })];
+  const platform = deps.platform || process.platform;
+  if (platform === "win32" && !env.CLAUDE_SCIENCE_HOME) {
+    const discoverWslHome = deps.discoverWslHome || wsl.discoverWslHome;
+    const wslRoot = wsl.shouldProbeWsl(env)
+      ? discoverWslHome(".claude-science", { ...deps, env })
+      : null;
+    if (wslRoot) roots.push(wslRoot);
+  }
+
+  const seen = new Set();
+  const out = [];
+  for (const root of roots) {
+    for (const dbPath of claudeScienceDbsUnderRoot(root)) {
+      if (seen.has(dbPath)) continue;
+      seen.add(dbPath);
+      out.push(dbPath);
+    }
+  }
+  return out;
+}
+
+// Kept for the default single-install path (and its existing callers/tests):
+// the conventional location, whether or not it exists yet.
+function resolveClaudeScienceDbPath({ home = os.homedir(), env = process.env } = {}) {
+  const explicit =
+    typeof env.CLAUDE_SCIENCE_DB_PATH === "string" && env.CLAUDE_SCIENCE_DB_PATH.trim()
+      ? env.CLAUDE_SCIENCE_DB_PATH.trim()
+      : null;
+  if (explicit) return path.resolve(explicit);
+  return path.join(resolveClaudeScienceRoot({ home, env }), "operon-cli.db");
+}
+
+async function readClaudeScienceFrames(dbPath, sqliteOptions = {}) {
+  if (!dbPath || !fssync.existsSync(dbPath)) return [];
+  const options = { label: "Claude Science", readOnly: true, ...sqliteOptions };
+
+  // On Windows the DB lives inside WSL and is read over a \\wsl.localhost\ UNC
+  // path. operon-cli.db runs in WAL mode (its -wal/-shm sidecars must be read
+  // consistently with the main file), and SQLite over the 9p/UNC bridge can
+  // fail to open the WAL or read a torn state. Snapshot to a local temp copy
+  // first — same guard every other WSL-aware provider uses — and run BOTH the
+  // PRAGMA probe and the frames read against that one consistent copy.
+  let snapshot = null;
+  let effectiveDbPath = dbPath;
+  if (isUncPath(dbPath)) {
+    try {
+      snapshot = snapshotSqliteDb(dbPath);
+      effectiveDbPath = snapshot.path;
+    } catch (_e) {
+      // Snapshot failed (permissions, transient I/O) — fall through to a direct
+      // read so the non-UNC case never regresses.
+    }
+  }
+
+  try {
+    const pragmaRows = await readSqliteJsonRowsAsync(
+      effectiveDbPath,
+      "PRAGMA table_info(frames)",
+      options,
+    );
+    const columnNames = pragmaRows.map((row) => row?.name).filter(Boolean);
+    // No `frames` table at all (wrong DB / pre-frames build) — not an error.
+    if (columnNames.length === 0) return [];
+    return await readSqliteJsonRowsAsync(
+      effectiveDbPath,
+      buildClaudeScienceFramesQuery(columnNames),
+      options,
+    );
+  } finally {
+    if (snapshot) snapshot.cleanup();
+  }
+}
+
+// `input` here is cache-inclusive (see the header note), so peel the cache
+// columns back off to recover pure non-cached input. Main and aux counters are
+// clamped independently — mixing them before the subtraction would let one
+// group's cache mask the other's shortfall.
+function claudeScienceUncachedInput(input, cacheRead, cacheWrite) {
+  return Math.max(0, toNonNegativeInt(input) - toNonNegativeInt(cacheRead) - toNonNegativeInt(cacheWrite));
+}
+
+function normalizeClaudeScienceTokens(row) {
+  const uncachedInput =
+    claudeScienceUncachedInput(row?.input_tokens, row?.cache_read_tokens, row?.cache_write_tokens) +
+    claudeScienceUncachedInput(
+      row?.aux_input_tokens,
+      row?.aux_cache_read_tokens,
+      row?.aux_cache_write_tokens,
+    );
+  const output = toNonNegativeInt(row?.output_tokens) + toNonNegativeInt(row?.aux_output_tokens);
+  const cacheRead =
+    toNonNegativeInt(row?.cache_read_tokens) + toNonNegativeInt(row?.aux_cache_read_tokens);
+  const cacheWrite =
+    toNonNegativeInt(row?.cache_write_tokens) + toNonNegativeInt(row?.aux_cache_write_tokens);
+  const total = uncachedInput + output + cacheRead + cacheWrite;
+  if (total <= 0) return null;
+  return {
+    input_tokens: uncachedInput,
+    cached_input_tokens: cacheRead,
+    cache_creation_input_tokens: cacheWrite,
+    output_tokens: output,
+    reasoning_output_tokens: 0,
+    total_tokens: total,
+    billable_total_tokens: total,
+  };
+}
+
+function claudeScienceFrameTimestampMs(row) {
+  return (
+    coerceEpochMs(row?.completed_at) ||
+    coerceEpochMs(row?.updated_at) ||
+    coerceEpochMs(row?.created_at) ||
+    // Tolerate ISO-8601 text timestamps in case a build stores them as strings.
+    parseIsoTimestampMs(row?.completed_at) ||
+    parseIsoTimestampMs(row?.updated_at) ||
+    parseIsoTimestampMs(row?.created_at)
+  );
+}
+
+function parseIsoTimestampMs(value) {
+  if (typeof value !== "string" || !value.trim()) return 0;
+  const ms = Date.parse(value.trim());
+  return Number.isFinite(ms) && ms > 0 ? ms : 0;
+}
+
+// Idempotent, subtract-on-change aggregation keyed by frame id (mirrors the
+// Qoder DB parser): frames are re-read in full on every sync, and a frame whose
+// counters grew between syncs has its previous contribution removed from its old
+// bucket before the new totals are added, so repeated syncs never inflate.
+async function parseClaudeScienceIncremental({
+  dbRows,
+  cursors,
+  queuePath,
+  onProgress,
+} = {}) {
+  await ensureDir(path.dirname(queuePath));
+  const rows = Array.isArray(dbRows) ? dbRows : [];
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const state = normalizeQoderState(cursors?.claudeScience);
+  const touchedBuckets = new Set();
+  const cb = typeof onProgress === "function" ? onProgress : null;
+  let recordsProcessed = 0;
+  let eventsAggregated = 0;
+
+  for (let index = 0; index < rows.length; index++) {
+    const row = rows[index];
+    const frameId = normalizeMessageKeyPart(row?.id == null ? "" : String(row.id));
+    const base = normalizeClaudeScienceTokens(row);
+    const timestampMs = claudeScienceFrameTimestampMs(row);
+    const bucketStart = timestampMs
+      ? toUtcHalfHourStart(new Date(timestampMs).toISOString())
+      : null;
+    if (!frameId || !base || !bucketStart) {
+      recordsProcessed += 1;
+      continue;
+    }
+
+    // A root frame (no parent) is one user-facing conversation; nested child
+    // frames are sub-agent turns of the same conversation and must not inflate
+    // the conversation count.
+    const isRoot = !normalizeMessageKeyPart(
+      row?.parent_frame_id == null ? "" : String(row.parent_frame_id),
+    );
+    const currentTotals = { ...base, conversation_count: isRoot ? 1 : 0 };
+    const model = normalizeModelInput(row?.model) || "claude-science";
+
+    const previous = state.messages[frameId];
+    const previousTotals =
+      previous?.totals && typeof previous.totals === "object" ? previous.totals : null;
+    const unchanged =
+      previousTotals &&
+      totalsKey(previousTotals) === totalsKey(currentTotals) &&
+      previous.bucketStart === bucketStart &&
+      previous.model === model;
+
+    if (!unchanged) {
+      if (previousTotals && previous.bucketStart && previous.model) {
+        const oldBucket = getHourlyBucket(
+          hourlyState,
+          "claude-science",
+          previous.model,
+          previous.bucketStart,
+        );
+        subtractTotals(oldBucket.totals, previousTotals);
+        touchedBuckets.add(bucketKey("claude-science", previous.model, previous.bucketStart));
+      }
+      const bucket = getHourlyBucket(hourlyState, "claude-science", model, bucketStart);
+      addTotals(bucket.totals, currentTotals);
+      touchedBuckets.add(bucketKey("claude-science", model, bucketStart));
+      state.messages[frameId] = {
+        totals: currentTotals,
+        bucketStart,
+        model,
+        updatedAt: new Date().toISOString(),
+      };
+      eventsAggregated += 1;
+    }
+
+    recordsProcessed += 1;
+    if (cb) {
+      cb({
+        index: index + 1,
+        total: rows.length,
+        recordsProcessed,
+        eventsAggregated,
+        bucketsQueued: touchedBuckets.size,
+      });
+    }
+  }
+
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  const updatedAt = new Date().toISOString();
+  hourlyState.updatedAt = updatedAt;
+  state.updatedAt = updatedAt;
+  cursors.hourly = hourlyState;
+  cursors.claudeScience = state;
+  return { recordsProcessed, eventsAggregated, bucketsQueued };
+}
+
 // Resolve project context from DB message (no file path available)
 async function resolveProjectContextForDb({
   msg,
@@ -4554,37 +5106,60 @@ async function parseCursorApiIncremental({
 // Kiro token tracking (reads from devdata.sqlite or tokens_generated.jsonl)
 // ---------------------------------------------------------------------------
 
-function resolveKiroBasePath() {
+// Kiro IDE (VS Code fork) globalStorage lives under the editor config root,
+// which differs per platform: %APPDATA% on Windows, ~/.config on Linux/WSL,
+// ~/Library/Application Support on macOS.
+function resolveKiroBasePath(env = process.env) {
   const home = require("node:os").homedir();
-  return path.join(
-    home,
-    "Library",
-    "Application Support",
-    "Kiro",
-    "User",
-    "globalStorage",
-    "kiro.kiroagent",
-  );
+  const suffix = ["Kiro", "User", "globalStorage", "kiro.kiroagent"];
+  if (process.platform === "win32") {
+    const appData = typeof env.APPDATA === "string" && env.APPDATA.trim().length > 0
+      ? env.APPDATA.trim()
+      : path.join(home, "AppData", "Roaming");
+    return path.join(appData, ...suffix);
+  }
+  if (process.platform === "linux") {
+    const configHome = typeof env.XDG_CONFIG_HOME === "string" && env.XDG_CONFIG_HOME.trim().length > 0
+      ? env.XDG_CONFIG_HOME.trim()
+      : path.join(home, ".config");
+    return path.join(configHome, ...suffix);
+  }
+  return path.join(home, "Library", "Application Support", ...suffix);
 }
 
-function resolveKiroDbPath() {
-  return path.join(resolveKiroBasePath(), "dev_data", "devdata.sqlite");
+function resolveKiroDbPath(basePath) {
+  return path.join(basePath || resolveKiroBasePath(), "dev_data", "devdata.sqlite");
 }
 
-function resolveKiroJsonlPath() {
-  return path.join(resolveKiroBasePath(), "dev_data", "tokens_generated.jsonl");
+function resolveKiroJsonlPath(basePath) {
+  return path.join(basePath || resolveKiroBasePath(), "dev_data", "tokens_generated.jsonl");
 }
 
 function readKiroDbTokens(dbPath, sinceId, sqliteOptions = {}) {
   if (!dbPath || !fssync.existsSync(dbPath)) return [];
   const minId = Number.isFinite(sinceId) && sinceId > 0 ? sinceId : 0;
   const sql = `SELECT id, model, provider, tokens_prompt, tokens_generated, timestamp FROM tokens_generated WHERE id > ${minId} ORDER BY id ASC`;
-  return readSqliteJsonRows(dbPath, sql, {
-    label: "Kiro",
-    maxBuffer: 10 * 1024 * 1024,
-    timeout: 15_000,
-    ...sqliteOptions,
-  });
+
+  // WSL installs are read over the \\wsl$ UNC bridge; sqlite3 cannot safely
+  // open WAL databases there, so copy db (+ sidecars) to tmp first.
+  let snapshot = null;
+  let effectiveDbPath = dbPath;
+  if (isUncPath(dbPath)) {
+    try {
+      snapshot = snapshotSqliteDb(dbPath);
+      effectiveDbPath = snapshot.path;
+    } catch (_e) { }
+  }
+  try {
+    return readSqliteJsonRows(effectiveDbPath, sql, {
+      label: "Kiro",
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: 15_000,
+      ...sqliteOptions,
+    });
+  } finally {
+    if (snapshot) snapshot.cleanup();
+  }
 }
 
 // Read Kiro token data from JSONL fallback (tokens_generated.jsonl).
@@ -4726,7 +5301,7 @@ function normalizeKiroModelName(raw) {
   return name || null;
 }
 
-async function parseKiroIncremental({ dbPath, jsonlPath, cursors, queuePath, onProgress, sqliteOptions } = {}) {
+async function parseKiroIncremental({ basePath, dbPath, jsonlPath, cursors, queuePath, onProgress, sqliteOptions } = {}) {
   await ensureDir(path.dirname(queuePath));
   const kiroState = cursors.kiro && typeof cursors.kiro === "object" ? cursors.kiro : {};
   const lastDbId = typeof kiroState.lastDbId === "number"
@@ -4735,8 +5310,8 @@ async function parseKiroIncremental({ dbPath, jsonlPath, cursors, queuePath, onP
   const jsonlState = kiroState.jsonl && typeof kiroState.jsonl === "object" ? kiroState.jsonl : {};
   const lastJsonlLine = typeof jsonlState.lastLine === "number" ? jsonlState.lastLine : 0;
 
-  const resolvedDbPath = dbPath || resolveKiroDbPath();
-  const resolvedJsonlPath = jsonlPath || resolveKiroJsonlPath();
+  const resolvedDbPath = dbPath || resolveKiroDbPath(basePath);
+  const resolvedJsonlPath = jsonlPath || resolveKiroJsonlPath(basePath);
 
   // Try SQLite first, fall back to JSONL.
   let rows = [];
@@ -4784,9 +5359,12 @@ async function parseKiroIncremental({ dbPath, jsonlPath, cursors, queuePath, onP
     return { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
   }
 
-  // Build model timeline from .chat files for model name resolution
-  const basePath = resolveKiroBasePath();
-  const modelTimeline = buildKiroModelTimeline(basePath);
+  // Build model timeline from .chat files for model name resolution.
+  // Must come from the SAME install as the rows being parsed (dual-install:
+  // a WSL install's rows must not be resolved against native .chat files).
+  const timelineBase = basePath
+    || (dbPath ? path.dirname(path.dirname(dbPath)) : resolveKiroBasePath());
+  const modelTimeline = buildKiroModelTimeline(timelineBase);
 
   const hourlyState = normalizeHourlyState(cursors?.hourly);
   const touchedBuckets = new Set();
@@ -5075,6 +5653,74 @@ function hermesInstallOwnsCursor(hermesPath, flatState, sqliteOptions) {
   return allDbs.some((db) => sqliteDbContainsIds(db, "sessions", sample, sqliteOptions));
 }
 
+function kiroInstallOwnsCursor(dbPath, flatState, sqliteOptions) {
+  // The flat cursor tracks the max AUTOINCREMENT id it consumed. An install
+  // whose tokens_generated table never reached that id cannot be the flat
+  // cursor's host. Both installs containing the id (short/equal histories)
+  // yields two hits upstream → caller seeds every namespace (safe).
+  const lastDbId = typeof flatState?.lastDbId === "number" && Number.isInteger(flatState.lastDbId) && flatState.lastDbId > 0
+    ? flatState.lastDbId
+    : (typeof flatState?.lastId === "number" && Number.isInteger(flatState.lastId) && flatState.lastId > 0
+      ? flatState.lastId
+      : 0);
+  if (!lastDbId) return false;
+  return sqliteDbContainsIds(dbPath, "tokens_generated", [String(lastDbId)], sqliteOptions);
+}
+
+// Kiro CLI request_ids live inside the conversations_v2 JSON payload, not in
+// an id column — probe via json_each instead of sqliteDbContainsIds.
+function kiroCliDbContainsRequestIds(dbPath, requestIds, sqliteOptions = {}) {
+  if (!dbPath || !Array.isArray(requestIds) || requestIds.length === 0) return false;
+  if (!fssync.existsSync(dbPath)) return false;
+  const inList = requestIds.map(sqliteStringLiteral).join(",");
+  // Alias both tables: conversations_v2.value and json_each's own `value`
+  // column collide — a bare `value` is "ambiguous column name" and sqlite
+  // errors out (which readSqliteJsonRows swallows into []).
+  const sql =
+    "SELECT 1 FROM conversations_v2 AS c, " +
+    "json_each(json_extract(c.value, '$.user_turn_metadata.requests')) AS je " +
+    `WHERE json_extract(je.value, '$.request_id') IN (${inList}) LIMIT 1`;
+
+  let snapshot = null;
+  let effectiveDbPath = dbPath;
+  if (isUncPath(dbPath)) {
+    try {
+      snapshot = snapshotSqliteDb(dbPath);
+      effectiveDbPath = snapshot.path;
+    } catch (_e) { }
+  }
+  try {
+    const rows = readSqliteJsonRows(effectiveDbPath, sql, {
+      label: "InstallProbe",
+      maxBuffer: 1024 * 1024,
+      timeout: 10_000,
+      ...sqliteOptions,
+    });
+    return Array.isArray(rows) && rows.length > 0;
+  } catch (_e) {
+    return false;
+  } finally {
+    if (snapshot) snapshot.cleanup();
+  }
+}
+
+function kiroCliInstallOwnsCursor(dbPath, flatState, sqliteOptions) {
+  // Only SQLite-origin request_id UUIDs are probe evidence: session-file
+  // entries synthesize `${sessionId}:${loopRand}` keys or carry a session_id
+  // tag, and neither appears in conversations_v2. Filter BEFORE sampling so
+  // recent session-file churn cannot blind the probe to older SQLite ids.
+  const requests =
+    flatState?.requests && typeof flatState.requests === "object" ? flatState.requests : {};
+  const sqliteKeyed = {};
+  for (const [k, v] of Object.entries(requests)) {
+    if (k.includes(":")) continue;
+    if (v && typeof v === "object" && typeof v.session_id === "string" && v.session_id) continue;
+    sqliteKeyed[k] = v;
+  }
+  const sample = sampleRecentKeys(sqliteKeyed);
+  return kiroCliDbContainsRequestIds(dbPath, sample, sqliteOptions);
+}
+
 function hasLegacyHermesDefaultState(hermesState) {
   return (
     typeof hermesState.lastStartedAt === "number" ||
@@ -5307,6 +5953,22 @@ const KIRO_CLI_CREDITS_SIDECAR = "kiro-credits.json";
 function resolveKiroCliDbPath(env = process.env) {
   if (env.KIRO_CLI_DB_PATH) return env.KIRO_CLI_DB_PATH;
   const home = env.HOME || require("node:os").homedir();
+  if (process.platform === "win32") {
+    // Speculative: Kiro CLI descends from Amazon Q CLI, which ships
+    // macOS/Linux only — Windows users run it inside WSL (handled by the
+    // dual-install path in sync). Kept as the conventional %LOCALAPPDATA%
+    // location so a future native build is picked up; harmless when absent.
+    const localAppData = typeof env.LOCALAPPDATA === "string" && env.LOCALAPPDATA.trim().length > 0
+      ? env.LOCALAPPDATA.trim()
+      : path.join(home, "AppData", "Local");
+    return path.join(localAppData, "kiro-cli", "data.sqlite3");
+  }
+  if (process.platform === "linux") {
+    const dataHome = typeof env.XDG_DATA_HOME === "string" && env.XDG_DATA_HOME.trim().length > 0
+      ? env.XDG_DATA_HOME.trim()
+      : path.join(home, ".local", "share");
+    return path.join(dataHome, "kiro-cli", "data.sqlite3");
+  }
   return path.join(home, "Library", "Application Support", "kiro-cli", "data.sqlite3");
 }
 
@@ -5870,6 +6532,7 @@ async function readKiroCliV2SessionTurns(messagesPath) {
 
 async function writeKiroCliCreditsSidecar({
   queuePath,
+  installKey,
   totalCredits,
   recordCount,
   sessionCount,
@@ -5882,15 +6545,64 @@ async function writeKiroCliCreditsSidecar({
     KIRO_CLI_CREDITS_SIDECAR,
   );
   try {
-    await writeJson(sidecarPath, {
-      version: 1,
-      source: "kiro-cli-usage-summary",
+    // Dual-install (#306): keep one entry per install and aggregate at the
+    // top level, so a second install's write never clobbers the first. The
+    // top-level fields keep the v1 shape readKiroCreditsSummary consumes.
+    let installs = {};
+    try {
+      const prev = JSON.parse(await fs.readFile(sidecarPath, "utf8"));
+      if (prev?.version === 1 && prev.installs && typeof prev.installs === "object") {
+        installs = prev.installs;
+      }
+    } catch {
+      // first write or pre-dual-install sidecar — start fresh
+    }
+    // Expire entries whose install stopped syncing (deleted WSL distro,
+    // distro rename / UNC alias flip leaving a duplicate key, mode switched
+    // to *-only). Without this the read-modify-write merge would inflate the
+    // aggregate with phantom installs forever; a 30-day grace keeps entries
+    // alive across transient wsl.exe probe failures.
+    const staleMs = 30 * 24 * 60 * 60 * 1000;
+    for (const [k, entry] of Object.entries(installs)) {
+      const ts = Date.parse(entry?.updated_at || "");
+      if (!Number.isFinite(ts) || Date.now() - ts > staleMs) delete installs[k];
+    }
+    const key = typeof installKey === "string" && installKey ? installKey : "default";
+    installs[key] = {
       total_credits: Number(totalCredits.toFixed(12)),
       record_count: recordCount,
       session_count: sessionCount,
       file_count: fileCount,
       latest_at: latestAt,
       updated_at: new Date().toISOString(),
+    };
+    let aggCredits = 0;
+    let aggRecords = 0;
+    let aggSessions = 0;
+    let aggFiles = 0;
+    let aggLatestAt = null;
+    for (const entry of Object.values(installs)) {
+      aggCredits += Number(entry.total_credits) || 0;
+      aggRecords += Number(entry.record_count) || 0;
+      aggSessions += Number(entry.session_count) || 0;
+      aggFiles += Number(entry.file_count) || 0;
+      if (
+        typeof entry.latest_at === "string" &&
+        (!aggLatestAt || Date.parse(entry.latest_at) > Date.parse(aggLatestAt))
+      ) {
+        aggLatestAt = entry.latest_at;
+      }
+    }
+    await writeJson(sidecarPath, {
+      version: 1,
+      source: "kiro-cli-usage-summary",
+      total_credits: Number(aggCredits.toFixed(12)),
+      record_count: aggRecords,
+      session_count: aggSessions,
+      file_count: aggFiles,
+      latest_at: aggLatestAt,
+      updated_at: new Date().toISOString(),
+      installs,
     });
     await chmod600IfPossible(sidecarPath);
   } catch {
@@ -5953,13 +6665,29 @@ function readKiroCliRequests(dbPath, env = process.env, sqliteOptions = {}) {
     "json_extract(value, '$.user_turn_metadata.requests') AS requests_json " +
     "FROM conversations_v2 " +
     "WHERE json_extract(value, '$.user_turn_metadata.requests') IS NOT NULL";
-  const rows = readSqliteJsonRows(dbPath, sql, {
-    label: "Kiro CLI",
-    env,
-    maxBuffer: 128 * 1024 * 1024,
-    timeout: 120_000,
-    ...sqliteOptions,
-  });
+
+  // WSL installs are read over the \\wsl$ UNC bridge; snapshot to tmp so
+  // sqlite3 never opens a WAL database across the 9p bridge.
+  let snapshot = null;
+  let effectiveDbPath = dbPath;
+  if (isUncPath(dbPath)) {
+    try {
+      snapshot = snapshotSqliteDb(dbPath);
+      effectiveDbPath = snapshot.path;
+    } catch (_e) { }
+  }
+  let rows;
+  try {
+    rows = readSqliteJsonRows(effectiveDbPath, sql, {
+      label: "Kiro CLI",
+      env,
+      maxBuffer: 128 * 1024 * 1024,
+      timeout: 120_000,
+      ...sqliteOptions,
+    });
+  } finally {
+    if (snapshot) snapshot.cleanup();
+  }
   const flat = [];
   for (const row of rows) {
     let requests;
@@ -6058,6 +6786,11 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
   }
   await writeKiroCliCreditsSidecar({
     queuePath,
+    // Install identity mirrors resolveKiroCliSessionFiles' sessions home so
+    // dual installs keep separate sidecar entries.
+    installKey:
+      resolvedEnv.KIRO_HOME ||
+      path.join(resolvedEnv.HOME || require("node:os").homedir(), ".kiro"),
     totalCredits: kiroCreditTotal,
     recordCount: kiroCreditRecords,
     sessionCount: kiroCreditSessions,
@@ -14371,6 +15104,7 @@ module.exports = {
   resolveQoderDbPath,
   resolveQoderDbPaths,
   readQoderDbMessages,
+  resolveKiroBasePath,
   resolveKiroDbPath,
   resolveKiroJsonlPath,
   resolveHermesPath,
@@ -14398,12 +15132,22 @@ module.exports = {
   parseQoderDbIncremental,
   openclawCursorKey,
   parseOpenclawIncremental,
+  resolveOpenclawHome,
+  resolveOpenclawHomes,
+  resolveOpenclawSessionFiles,
+  resolveClaudeScienceDbPath,
+  resolveClaudeScienceDbPaths,
+  buildClaudeScienceFramesQuery,
+  readClaudeScienceFrames,
+  parseClaudeScienceIncremental,
   parseCursorApiIncremental,
   parseKiroIncremental,
   parseHermesIncremental,
   gooseInstallOwnsCursor,
   zedInstallOwnsCursor,
   hermesInstallOwnsCursor,
+  kiroInstallOwnsCursor,
+  kiroCliInstallOwnsCursor,
   copilotOtelCursorHasLegacyCliUsage,
   pruneCopilotUsageClaims,
   parseCopilotIncremental,