tokentracker-cli 0.84.8 → 0.85.0

package/src/lib/rollout.js

@@ -5,7 +5,7 @@ const path = require("node:path");
 const readline = require("node:readline");
 
 const crypto = require("node:crypto");
-const { ensureDir } = require("./fs");
+const { ensureDir, writeJson, chmod600IfPossible } = require("./fs");
 const { readSqliteJsonRows, readSqliteJsonRowsAsync } = require("./sqlite-reader");
 const wsl = require("./wsl-probe");
 const { resolveInstallPaths } = require("./install-resolver");
@@ -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,
@@ -2075,7 +2169,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 +2192,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));
+            }
           }
         }
       }
@@ -4554,37 +4663,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 +4858,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 +4867,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 +4916,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 +5210,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" ||
@@ -5302,10 +5505,27 @@ function resolveKimiDefaultModel(env = process.env) {
 // ─────────────────────────────────────────────────────────────────────────────
 
 const KIRO_CLI_CHARS_PER_TOKEN = 4;
+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");
 }
 
@@ -5619,18 +5839,45 @@ function kiroCliV2ContentChars(value) {
   return 0;
 }
 
+function kiroCliV2UsageCredits(payload) {
+  const summaries = Array.isArray(payload?.promptTurnSummaries)
+    ? payload.promptTurnSummaries
+    : [];
+  let totalCredits = 0;
+  let hasCreditEntry = false;
+  for (const summary of summaries) {
+    if (!summary || typeof summary !== "object") continue;
+    const unit = String(summary.unit || "").trim().toLowerCase();
+    if (unit !== "credit" && unit !== "credits") continue;
+    const usage = Number(summary.usage);
+    if (!Number.isFinite(usage) || usage < 0) continue;
+    totalCredits += usage;
+    hasCreditEntry = true;
+  }
+  return {
+    totalCredits,
+    recordCount: hasCreditEntry ? 1 : 0,
+  };
+}
+
 // Kiro CLI 2.13+ writes event-sourced sessions under
 // ~/.kiro/sessions/<workspaceHash>/sess_<uuid>/messages.jsonl. The records do
-// not carry token counts, but user/assistant text, turn boundaries, timestamps,
-// and assistant reasoningModelId are sufficient for the same 4 chars/token
-// approximation used by the legacy CLI reader.
+// not carry token counts, but user/assistant text, tool_result payloads, turn
+// boundaries, timestamps, and assistant reasoningModelId are sufficient for
+// the same 4 chars/token approximation used by the legacy CLI reader.
+// tool_result content counts as INPUT: tool output (file reads, command
+// output, search results) is fed back to the model as context on the next
+// request — skipping it undercounted tool-heavy sessions by ~67% (#366).
 async function readKiroCliV2SessionTurns(messagesPath) {
   if (
     !messagesPath ||
     path.basename(messagesPath) !== "messages.jsonl" ||
     !fssync.existsSync(messagesPath)
   ) {
-    return [];
+    return {
+      turns: [],
+      credits: { totalCredits: 0, recordCount: 0, latestAt: null },
+    };
   }
 
   const sessionDir = path.dirname(messagesPath);
@@ -5658,7 +5905,10 @@ async function readKiroCliV2SessionTurns(messagesPath) {
   try {
     stream = fssync.createReadStream(messagesPath, { encoding: "utf8" });
   } catch {
-    return flat;
+    return {
+      turns: flat,
+      credits: { totalCredits: 0, recordCount: 0, latestAt: null },
+    };
   }
   const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
 
@@ -5666,6 +5916,10 @@ async function readKiroCliV2SessionTurns(messagesPath) {
   let pendingUserTimestampMs = NaN;
   let turn = null;
   let fallbackTurnIndex = 0;
+  const seenCreditEvents = new Set();
+  let totalCredits = 0;
+  let creditRecordCount = 0;
+  let latestCreditAt = null;
 
   const flushTurn = () => {
     if (!turn) return;
@@ -5747,8 +6001,35 @@ async function readKiroCliV2SessionTurns(messagesPath) {
         continue;
       }
 
+      if (type === "usage_summary") {
+        const creditEventKey =
+          typeof event.id === "string" && event.id
+            ? event.id
+            : `${payload.executionId || ""}:${event.timestamp || ""}:${creditRecordCount}`;
+        if (!seenCreditEvents.has(creditEventKey)) {
+          seenCreditEvents.add(creditEventKey);
+          const usage = kiroCliV2UsageCredits(payload);
+          if (usage.recordCount > 0) {
+            totalCredits += usage.totalCredits;
+            creditRecordCount += usage.recordCount;
+            if (
+              Number.isFinite(timestampMs) &&
+              (
+                !latestCreditAt ||
+                timestampMs > Date.parse(latestCreditAt)
+              )
+            ) {
+              latestCreditAt = new Date(timestampMs).toISOString();
+            }
+          }
+        }
+        // Billing summaries are independent metadata. They can arrive after
+        // turn_end, so they must not create or mutate token turns.
+        continue;
+      }
+
       if (
-        ["assistant", "tool_call", "tool_result", "usage_summary"].includes(
+        ["assistant", "tool_call", "tool_result"].includes(
           type,
         ) &&
         !turn
@@ -5784,6 +6065,10 @@ async function readKiroCliV2SessionTurns(messagesPath) {
         ) {
           turn.modelId = payload.reasoningModelId;
         }
+      } else if (type === "tool_result") {
+        // #366: tool output re-enters the model as input context on the
+        // next request within the turn. Same ÷4 heuristic as user text.
+        turn.inputChars += kiroCliV2ContentChars(payload.content);
       } else if (type === "turn_end") {
         flushTurn();
       }
@@ -5792,7 +6077,95 @@ async function readKiroCliV2SessionTurns(messagesPath) {
     // Return complete turns parsed before a concurrent truncate/delete.
   }
   flushTurn();
-  return flat;
+  return {
+    turns: flat,
+    credits: {
+      totalCredits,
+      recordCount: creditRecordCount,
+      latestAt: latestCreditAt,
+    },
+  };
+}
+
+async function writeKiroCliCreditsSidecar({
+  queuePath,
+  installKey,
+  totalCredits,
+  recordCount,
+  sessionCount,
+  fileCount,
+  latestAt,
+} = {}) {
+  if (!queuePath || !(fileCount > 0)) return;
+  const sidecarPath = path.join(
+    path.dirname(queuePath),
+    KIRO_CLI_CREDITS_SIDECAR,
+  );
+  try {
+    // 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 {
+    // Credits are supplemental billing metadata. A sidecar write failure must
+    // never block the canonical token queue.
+  }
 }
 
 // Canonicalize a Kiro-CLI-emitted model id so IDE and CLI rows collapse when
@@ -5849,13 +6222,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;
@@ -5923,13 +6312,48 @@ async function parseKiroCliIncremental({ sessionFiles, cursors, queuePath, onPro
     : [];
   const sessionFilesList = resolveKiroCliSessionFiles(resolvedEnv);
   let flatSessions = [];
+  let kiroCreditTotal = 0;
+  let kiroCreditRecords = 0;
+  let kiroCreditSessions = 0;
+  let kiroCreditFiles = 0;
+  let latestKiroCreditAt = null;
   for (const sessionPath of sessionFilesList) {
-    const turns =
-      path.basename(sessionPath) === "messages.jsonl"
-        ? await readKiroCliV2SessionTurns(sessionPath)
-        : await readKiroCliSessionTurns(sessionPath);
+    let turns;
+    if (path.basename(sessionPath) === "messages.jsonl") {
+      kiroCreditFiles++;
+      const parsed = await readKiroCliV2SessionTurns(sessionPath);
+      turns = parsed.turns;
+      const credits = parsed.credits;
+      kiroCreditTotal += credits.totalCredits;
+      kiroCreditRecords += credits.recordCount;
+      if (credits.recordCount > 0) kiroCreditSessions++;
+      if (
+        credits.latestAt &&
+        (
+          !latestKiroCreditAt ||
+          Date.parse(credits.latestAt) > Date.parse(latestKiroCreditAt)
+        )
+      ) {
+        latestKiroCreditAt = credits.latestAt;
+      }
+    } else {
+      turns = await readKiroCliSessionTurns(sessionPath);
+    }
     for (const turn of turns) flatSessions.push(turn);
   }
+  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,
+    fileCount: kiroCreditFiles,
+    latestAt: latestKiroCreditAt,
+  });
   // Per-request state replaces the old seenIds set. Each entry captures
   // what we contributed for that request_id last time, so a later mutation
   // (same request_id, different fingerprint) can subtract-old/add-new
@@ -14237,6 +14661,7 @@ module.exports = {
   resolveQoderDbPath,
   resolveQoderDbPaths,
   readQoderDbMessages,
+  resolveKiroBasePath,
   resolveKiroDbPath,
   resolveKiroJsonlPath,
   resolveHermesPath,
@@ -14270,6 +14695,8 @@ module.exports = {
   gooseInstallOwnsCursor,
   zedInstallOwnsCursor,
   hermesInstallOwnsCursor,
+  kiroInstallOwnsCursor,
+  kiroCliInstallOwnsCursor,
   copilotOtelCursorHasLegacyCliUsage,
   pruneCopilotUsageClaims,
   parseCopilotIncremental,