tokentracker-cli 0.77.1 → 0.78.0

package/src/commands/sync.js

@@ -24,6 +24,11 @@ const {
   resolveKiroJsonlPath,
   resolveHermesPath,
   resolveCopilotOtelPaths,
+  normalizeCopilotDbPath,
+  uniqueCopilotDbPaths,
+  coalesceCopilotDbStatesByIdentity,
+  resolveCopilotSessionStorePaths,
+  getCopilotSqliteFingerprint,
   resolveCopilotAppDbPaths,
   parseRolloutIncremental,
   parseClaudeIncremental,
@@ -37,7 +42,10 @@ const {
   gooseInstallOwnsCursor,
   zedInstallOwnsCursor,
   hermesInstallOwnsCursor,
+  copilotOtelCursorHasLegacyCliUsage,
+  pruneCopilotUsageClaims,
   parseCopilotIncremental,
+  parseCopilotSessionStoreIncremental,
   parseCopilotAppDbIncremental,
   resolveKimiWireFiles,
   parseKimiIncremental,
@@ -218,6 +226,50 @@ function warnProviderParseFailure(label, err, opts) {
   process.stderr.write(`${label} sync: ${err && err.message ? err.message : err}\n`);
 }
 
+function mergeParseResult(total, next) {
+  return {
+    recordsProcessed: total.recordsProcessed + next.recordsProcessed,
+    eventsAggregated: total.eventsAggregated + next.eventsAggregated,
+    bucketsQueued: total.bucketsQueued + next.bucketsQueued,
+  };
+}
+
+function copilotAppBaselineTotal(baseline) {
+  return (
+    Math.max(0, Number(baseline?.input) || 0) +
+    Math.max(0, Number(baseline?.output) || 0) +
+    Math.max(0, Number(baseline?.cached) || 0) +
+    Math.max(0, Number(baseline?.reasoning) || 0)
+  );
+}
+
+function mergeCopilotAppDbStates(primary = {}, alias = {}) {
+  const primaryUpdatedAt = Date.parse(primary?.updatedAt || "") || 0;
+  const aliasUpdatedAt = Date.parse(alias?.updatedAt || "") || 0;
+  const newer = aliasUpdatedAt > primaryUpdatedAt ? alias : primary;
+  const sessionTotals = {};
+  for (const state of [primary, alias]) {
+    for (const [sessionId, baseline] of Object.entries(
+      state?.sessionTotals || {},
+    )) {
+      const current = sessionTotals[sessionId];
+      const baselineTotal = copilotAppBaselineTotal(baseline);
+      const currentTotal = copilotAppBaselineTotal(current);
+      const baselineUpdatedAt = Date.parse(baseline?.updatedAt || "") || 0;
+      const currentUpdatedAt = Date.parse(current?.updatedAt || "") || 0;
+      if (
+        !current ||
+        baselineTotal > currentTotal ||
+        (baselineTotal === currentTotal &&
+          baselineUpdatedAt > currentUpdatedAt)
+      ) {
+        sessionTotals[sessionId] = baseline;
+      }
+    }
+  }
+  return { ...primary, ...newer, sessionTotals };
+}
+
 async function cmdSync(argv) {
   const opts = parseArgs(argv);
   const home = os.homedir();
@@ -261,14 +313,8 @@ async function cmdSync(argv) {
     }
     let grokHookSignalConsumed = false;
 
-    const codexHome = process.env.CODEX_HOME || path.join(home, ".codex");
-    const codeHome = process.env.CODE_HOME || path.join(home, ".code");
     const claudeProjectsDir = path.join(home, ".claude", "projects");
-    const geminiHome = process.env.GEMINI_HOME || path.join(home, ".gemini");
-    const geminiTmpDir = path.join(geminiHome, "tmp");
     const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
-    const opencodeHome = process.env.OPENCODE_HOME || path.join(xdgDataHome, "opencode");
-    const opencodeStorageDir = path.join(opencodeHome, "storage");
     const kiloHome = process.env.KILO_HOME || path.join(xdgDataHome, "kilo");
     const mimoHome = process.env.MIMO_HOME || path.join(xdgDataHome, "mimocode");
     const zcodeHome = process.env.ZCODE_HOME || path.join(home, ".zcode");
@@ -295,22 +341,36 @@ async function cmdSync(argv) {
 
     const sources = [];
     if (sourceAllowed("codex")) {
-      sources.push({ source: "codex", sessionsDir: path.join(codexHome, "sessions"), codexInventoryCache: true });
-      if (!isBackgroundLightweightSync) {
-        sources.push(
-          // Codex-Manager archives sessions to ~/.codex/archived_sessions/ on every
-          // account/channel switch (issue #187). Scanning it too keeps that usage
-          // counted instead of orphaning it in the cloud (a re-upload's upsert can
-          // never delete cloud rows whose local source file has vanished). Safe
-          // against double-counting: the codex event dedup keys on sessionUUID (in
-          // the filename) + event timestamp, both stable across a sessions/ ->
-          // archived_sessions/ move, so re-reading an archived copy is a no-op.
-          { source: "codex", sessionsDir: path.join(codexHome, "archived_sessions"), deep: true },
-        );
+      const codexNativeValue = process.env.CODEX_HOME || path.join(home, ".codex");
+      const wslCodexDir = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+        ? wsl.discoverWslHome(".codex")
+        : null;
+      const codexPaths = resolveInstallPaths({ nativeValue: codexNativeValue, wslValue: wslCodexDir });
+      if (codexPaths.native) {
+        sources.push({ source: "codex", sessionsDir: path.join(codexPaths.native, "sessions"), codexInventoryCache: true });
+        if (!isBackgroundLightweightSync) {
+          sources.push({ source: "codex", sessionsDir: path.join(codexPaths.native, "archived_sessions"), deep: true });
+        }
+      }
+      if (codexPaths.wsl) {
+        sources.push({ source: "codex", sessionsDir: path.join(codexPaths.wsl, "sessions"), codexInventoryCache: true });
+        if (!isBackgroundLightweightSync) {
+          sources.push({ source: "codex", sessionsDir: path.join(codexPaths.wsl, "archived_sessions"), deep: true });
+        }
       }
     }
     if (sourceAllowed("every-code")) {
-      sources.push({ source: "every-code", sessionsDir: path.join(codeHome, "sessions") });
+      const codeNativeValue = process.env.CODE_HOME || path.join(home, ".code");
+      const wslCodeDir = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+        ? wsl.discoverWslHome(".code")
+        : null;
+      const codePaths = resolveInstallPaths({ nativeValue: codeNativeValue, wslValue: wslCodeDir });
+      if (codePaths.native) {
+        sources.push({ source: "every-code", sessionsDir: path.join(codePaths.native, "sessions") });
+      }
+      if (codePaths.wsl) {
+        sources.push({ source: "every-code", sessionsDir: path.join(codePaths.wsl, "sessions") });
+      }
     }
 
     const rolloutFiles = [];
@@ -480,7 +540,34 @@ async function cmdSync(argv) {
       }
     }
 
-    const geminiFiles = sourceAllowed("gemini") ? await listGeminiSessionFiles(geminiTmpDir) : [];
+    let geminiPaths = null;
+    if (sourceAllowed("gemini") || sourceAllowed("antigravity")) {
+      const geminiNativeValue = process.env.GEMINI_HOME || path.join(home, ".gemini");
+      const wslGeminiDir = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+        ? wsl.discoverWslHome(".gemini")
+        : null;
+      geminiPaths = resolveInstallPaths({ nativeValue: geminiNativeValue, wslValue: wslGeminiDir });
+    }
+
+    let geminiFiles = [];
+    if (sourceAllowed("gemini") && geminiPaths) {
+      const fileSets = [];
+      if (geminiPaths.native) {
+        fileSets.push(await listGeminiSessionFiles(path.join(geminiPaths.native, "tmp")));
+      }
+      if (geminiPaths.wsl) {
+        fileSets.push(await listGeminiSessionFiles(path.join(geminiPaths.wsl, "tmp")));
+      }
+      const seen = new Set();
+      for (const set of fileSets) {
+        for (const f of set) {
+          if (!seen.has(f)) {
+            seen.add(f);
+            geminiFiles.push(f);
+          }
+        }
+      }
+    }
     let geminiResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (geminiFiles.length > 0) {
       if (progress?.enabled) {
@@ -510,7 +597,25 @@ async function cmdSync(argv) {
       }
     }
 
-    const antigravityFiles = sourceAllowed("antigravity") ? await listAntigravityTranscripts(geminiHome) : [];
+    let antigravityFiles = [];
+    if (sourceAllowed("antigravity") && geminiPaths) {
+      const fileSets = [];
+      if (geminiPaths.native) {
+        fileSets.push(await listAntigravityTranscripts(geminiPaths.native));
+      }
+      if (geminiPaths.wsl) {
+        fileSets.push(await listAntigravityTranscripts(geminiPaths.wsl));
+      }
+      const seen = new Set();
+      for (const set of fileSets) {
+        for (const f of set) {
+          if (!seen.has(f)) {
+            seen.add(f);
+            antigravityFiles.push(f);
+          }
+        }
+      }
+    }
     let antigravityResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (antigravityFiles.length > 0) {
       if (progress?.enabled) {
@@ -540,69 +645,89 @@ async function cmdSync(argv) {
       }
     }
 
-    const opencodeFiles = sourceAllowed("opencode") ? await listOpencodeMessageFiles(opencodeStorageDir) : [];
     let opencodeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    if (opencodeFiles.length > 0) {
-      if (progress?.enabled) {
-        progress.start(
-          `Parsing Opencode ${renderBar(0)} 0/${formatNumber(opencodeFiles.length)} files | buckets 0`,
-        );
-      }
-      try {
-        opencodeResult = await parseOpencodeIncremental({
-          messageFiles: opencodeFiles,
-          cursors,
-          queuePath,
-          projectQueuePath,
-          onProgress: (p) => {
-            if (!progress?.enabled) return;
-            const pct = p.total > 0 ? p.index / p.total : 1;
-            progress.update(
-              `Parsing Opencode ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-                p.total,
-              )} files | buckets ${formatNumber(p.bucketsQueued)}`,
-            );
-          },
-          source: "opencode",
-        });
-      } catch (err) {
-        warnProviderParseFailure("Opencode", err, opts);
-      }
-    }
+    if (sourceAllowed("opencode")) {
+      const opencodeStorageNativeValue = process.env.OPENCODE_HOME || path.join(xdgDataHome, "opencode");
+      const wslOpencodeStorageDir = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+        ? wsl.discoverWslHome(".local/share/opencode")
+        : null;
+      const storagePaths = resolveInstallPaths({
+        nativeValue: opencodeStorageNativeValue,
+        wslValue: wslOpencodeStorageDir,
+      });
 
-    // OpenCode v1.2+ stores messages in SQLite (opencode.db) instead of JSON files.
-    const opencodeDbPath = path.join(opencodeHome, "opencode.db");
-    let opencodeDbResult = { messagesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    const dbMessages = sourceAllowed("opencode") ? readOpencodeDbMessages(opencodeDbPath) : [];
-    if (dbMessages.length > 0) {
-      if (progress?.enabled) {
-        progress.start(
-          `Parsing Opencode DB ${renderBar(0)} 0/${formatNumber(dbMessages.length)} msgs | buckets 0`,
-        );
-      }
-      try {
-        opencodeDbResult = await parseOpencodeDbIncremental({
-          dbMessages,
-          cursors,
-          queuePath,
-          projectQueuePath,
-          onProgress: (p) => {
-            if (!progress?.enabled) return;
-            const pct = p.total > 0 ? p.index / p.total : 1;
-            progress.update(
-              `Parsing Opencode DB ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-                p.total,
-              )} msgs | buckets ${formatNumber(p.bucketsQueued)}`,
-            );
-          },
-          source: "opencode",
-        });
-      } catch (err) {
-        warnProviderParseFailure("Opencode DB", err, opts);
-      }
-      opencodeResult.filesProcessed += opencodeDbResult.messagesProcessed;
-      opencodeResult.eventsAggregated += opencodeDbResult.eventsAggregated;
-      opencodeResult.bucketsQueued += opencodeDbResult.bucketsQueued;
+      const opencodeDbNativeValue = process.env.OPENCODE_HOME || path.join(xdgDataHome, "opencode");
+      const wslOpencodeDbDir = process.platform === "win32" && wsl.shouldProbeWsl(process.env)
+        ? wsl.discoverWslHome(".local/share/opencode")
+        : null;
+      const dbPaths = resolveInstallPaths({
+        nativeValue: opencodeDbNativeValue,
+        wslValue: wslOpencodeDbDir,
+      });
+
+      const parseOpencodeForInstall = async (options) => {
+        const { storageDir, dbDir, cursors } = options;
+        let filesResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+        if (storageDir) {
+          const storagePath = path.join(storageDir, "storage");
+          const messageFiles = await listOpencodeMessageFiles(storagePath);
+          if (messageFiles.length > 0) {
+            filesResult = await parseOpencodeIncremental({
+              ...options,
+              messageFiles,
+            });
+          }
+        }
+
+        let dbResult = { messagesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+        if (dbDir) {
+          const dbPath = path.join(dbDir, "opencode.db");
+          const dbMessages = readOpencodeDbMessages(dbPath);
+          if (dbMessages.length > 0) {
+            dbResult = await parseOpencodeDbIncremental({
+              ...options,
+              dbMessages,
+            });
+          }
+        }
+
+        return {
+          recordsProcessed: filesResult.filesProcessed + dbResult.messagesProcessed,
+          eventsAggregated: filesResult.eventsAggregated + dbResult.eventsAggregated,
+          bucketsQueued: filesResult.bucketsQueued + dbResult.bucketsQueued,
+        };
+      };
+
+      const opencodePaths = {
+        native: storagePaths.native || dbPaths.native,
+        wsl: storagePaths.wsl || dbPaths.wsl,
+      };
+
+      const multiResult = await multiInstallParse({
+        paths: opencodePaths,
+        parserFn: parseOpencodeForInstall,
+        providerName: "opencode",
+        cursors,
+        queuePath,
+        projectQueuePath,
+        getParams: (p, key) => ({ storageDir: storagePaths[key], dbDir: dbPaths[key] }),
+        onProgress: (p) => {
+          if (!progress?.enabled) return;
+          const pct = p.total > 0 ? p.index / p.total : 1;
+          progress.update(
+            `Parsing Opencode (${p.install || "default"}) ${renderBar(pct)} ${formatNumber(
+              p.index,
+            )}/${formatNumber(p.total)} | buckets ${formatNumber(p.bucketsQueued)}`,
+          );
+        },
+        source: "opencode",
+      });
+
+      opencodeResult = {
+        filesProcessed: multiResult.recordsProcessed,
+        eventsAggregated: multiResult.eventsAggregated,
+        bucketsQueued: multiResult.bucketsQueued,
+      };
     }
 
     async function parseOpencodeDbForInstall({ dbPath, readFn, source, cursorKey, ...rest }) {
@@ -1045,7 +1170,9 @@ async function cmdSync(argv) {
 
     // ── Kimi (passive wire.jsonl reader) ──
     let kimiResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    const kimiWireFiles = sourceAllowed("kimi") ? resolveKimiWireFiles(process.env) : [];
+    const kimiWireFiles = sourceAllowed("kimi")
+      ? mergeBothFileSources({ resolveFiles: resolveKimiWireFiles, env: process.env })
+      : [];
     if (kimiWireFiles.length > 0) {
       if (progress?.enabled) {
         progress.start(`Parsing Kimi Code ${renderBar(0)} | buckets 0`);
@@ -1326,19 +1453,135 @@ async function cmdSync(argv) {
       await repairGrokQueueFromSessionSnapshots({ cursors, queuePath, queueStatePath });
     }
 
-    // ── GitHub Copilot CLI / Chat extension (OTEL JSONL files) ──
+    // ── GitHub Copilot App / CLI unified local runtime ──
+    //
+    // First adoption deliberately runs legacy OTEL + App DB once before the
+    // session-store parser records its max-id barrier. Subsequent scans use
+    // session-store as canonical for CLI/App requests: OTEL keeps only Chat
+    // extension LogRecords, while App DB remains an observe-only baseline.
     let copilotResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
-    const copilotPaths = sourceAllowed("copilot") ? resolveCopilotOtelPaths(process.env) : [];
+    const copilotSourceAllowed = sourceAllowed("copilot");
+    const adoptedCopilotStorePaths = new Set(
+      Object.entries(cursors?.copilotStore?.dbs || {})
+        .filter(([, state]) => state?.adoptedAt)
+        .map(([dbPath]) => dbPath),
+    );
+    const copilotStorePaths = copilotSourceAllowed
+      ? Array.from(
+          new Set([
+            ...resolveCopilotSessionStorePaths(process.env),
+            ...adoptedCopilotStorePaths,
+          ]),
+        ).filter((dbPath) => {
+          if (adoptedCopilotStorePaths.has(dbPath)) return true;
+          try { return fssync.existsSync(dbPath); } catch (_e) { return false; }
+        })
+      : [];
+    const copilotStoreWasActive = cursors?.copilotStore?.active === true;
+    const copilotStoreAdoptionFingerprints = {};
+    if (!copilotStoreWasActive) {
+      for (const dbPath of copilotStorePaths) {
+        try {
+          copilotStoreAdoptionFingerprints[dbPath] =
+            getCopilotSqliteFingerprint(dbPath);
+        } catch (_e) {}
+      }
+    }
+    let copilotHadLegacyCliOtelHistory = false;
+    if (!copilotStoreWasActive) {
+      copilotHadLegacyCliOtelHistory =
+        await copilotOtelCursorHasLegacyCliUsage(cursors);
+      if (cursors?.copilot && typeof cursors.copilot === "object") {
+        if (copilotHadLegacyCliOtelHistory) {
+          cursors.copilot.legacyCliHistory = true;
+        } else {
+          cursors.copilot.usageClaimsComplete = true;
+        }
+      }
+    }
+    let copilotLegacyHealthy = true;
+    let copilotOtelUsageClaims =
+      cursors?.copilot?.recentUsageEvents || [];
+    let copilotStoreResult = {
+      active: copilotStoreWasActive,
+      healthy: false,
+      adoptedThisRun: false,
+      canonicalDbPaths: [],
+      recordsProcessed: 0,
+      eventsAggregated: 0,
+      bucketsQueued: 0,
+      usageClaims: cursors?.copilotStore?.recentEvents || [],
+    };
+    if (copilotSourceAllowed && copilotStoreWasActive) {
+      if (progress?.enabled) {
+        progress.start(`Parsing Copilot App/CLI ${renderBar(0)} | buckets 0`);
+      }
+      try {
+        copilotStoreResult = await parseCopilotSessionStoreIncremental({
+          dbPaths: copilotStorePaths,
+          cursors,
+          queuePath,
+          env: process.env,
+          otelUsageEvents: cursors?.copilot?.recentUsageEvents,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Copilot App/CLI ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} events | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+        copilotResult = mergeParseResult(copilotResult, copilotStoreResult);
+      } catch (err) {
+        warnProviderParseFailure("Copilot App/CLI session store", err, opts);
+      }
+    }
+    const copilotPathKey = (dbPath) => {
+      const normalized = path.normalize(dbPath);
+      return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+    };
+    const canonicalCopilotStorePaths = new Set(
+      (copilotStoreResult.canonicalDbPaths || []).map(copilotPathKey),
+    );
+    const adoptedCopilotStorePathKeys = new Set(
+      Object.entries(cursors?.copilotStore?.dbs || {})
+        .filter(([, state]) => state?.adoptedAt)
+        .map(([dbPath]) => copilotPathKey(dbPath)),
+    );
+    const explicitCopilotStorePath =
+      typeof process.env.TOKENTRACKER_COPILOT_SESSION_STORE_DB === "string" &&
+      process.env.TOKENTRACKER_COPILOT_SESSION_STORE_DB.trim()
+        ? copilotPathKey(
+            normalizeCopilotDbPath(
+              process.env.TOKENTRACKER_COPILOT_SESSION_STORE_DB,
+              process.env,
+            ),
+          )
+        : null;
+    const explicitStoreIsCanonical =
+      explicitCopilotStorePath !== null &&
+      canonicalCopilotStorePaths.has(explicitCopilotStorePath);
+    const explicitStoreIsAdopted =
+      explicitCopilotStorePath !== null &&
+      adoptedCopilotStorePathKeys.has(explicitCopilotStorePath);
+
+    // ── GitHub Copilot CLI / Chat extension (OTEL JSONL files) ──
+    const copilotPaths = copilotSourceAllowed ? resolveCopilotOtelPaths(process.env) : [];
     if (copilotPaths.length > 0) {
       if (progress?.enabled) {
         progress.start(`Parsing Copilot ${renderBar(0)} | buckets 0`);
       }
       try {
-        copilotResult = await parseCopilotIncremental({
+        const copilotOtelResult = await parseCopilotIncremental({
           otelPaths: copilotPaths,
           cursors,
           queuePath,
           env: process.env,
+          storeUsageEvents:
+            copilotStoreResult.usageClaims ||
+            cursors?.copilotStore?.recentEvents ||
+            [],
+          skipCliSpans: copilotStoreWasActive,
           onProgress: (p) => {
             if (!progress?.enabled) return;
             const pct = p.total > 0 ? p.index / p.total : 1;
@@ -1347,42 +1590,189 @@ async function cmdSync(argv) {
             );
           },
         });
+        copilotOtelUsageClaims =
+          copilotOtelResult.usageClaims ||
+          cursors?.copilot?.recentUsageEvents ||
+          [];
+        copilotResult = mergeParseResult(copilotResult, copilotOtelResult);
       } catch (err) {
+        copilotLegacyHealthy = false;
         warnProviderParseFailure("Copilot", err, opts);
       }
     }
 
     // ── GitHub Copilot App (passive data.db session summaries) ──
-    const copilotAppDbPaths = sourceAllowed("copilot")
-      ? resolveCopilotAppDbPaths(process.env).filter((p) => {
-          try { return fssync.existsSync(p); } catch (_e) { return false; }
+    const copilotAppDbStates =
+      cursors?.copilotApp?.dbs && typeof cursors.copilotApp.dbs === "object"
+        ? cursors.copilotApp.dbs
+        : null;
+    const initialTrackedCopilotAppDbPaths = new Set(
+      Object.keys(copilotAppDbStates || {}),
+    );
+    const copilotAppDbCandidates = uniqueCopilotDbPaths(
+      [
+        ...resolveCopilotAppDbPaths(process.env),
+        ...initialTrackedCopilotAppDbPaths,
+      ],
+      process.env,
+      Array.from(initialTrackedCopilotAppDbPaths),
+    );
+    coalesceCopilotDbStatesByIdentity(
+      copilotAppDbStates,
+      copilotAppDbCandidates,
+      mergeCopilotAppDbStates,
+    );
+    const explicitStoreOwnsSingleApp =
+      copilotAppDbCandidates.length === 1 &&
+      explicitStoreIsAdopted;
+    if (copilotAppDbStates && (copilotStoreWasActive || copilotStorePaths.length > 0)) {
+      for (const dbPath of Object.keys(copilotAppDbStates)) {
+        try {
+          fssync.statSync(dbPath);
+        } catch (err) {
+          const matchingStorePath = copilotPathKey(
+            path.join(path.dirname(dbPath), "session-store.db"),
+          );
+          if (err?.code === "ENOENT") {
+            if (
+              canonicalCopilotStorePaths.has(matchingStorePath) ||
+              (explicitStoreOwnsSingleApp && explicitStoreIsCanonical)
+            ) {
+              delete copilotAppDbStates[dbPath];
+            }
+          } else {
+            if (!copilotStoreWasActive) copilotLegacyHealthy = false;
+          }
+        }
+      }
+    }
+    const trackedCopilotAppDbPaths = new Set(
+      Object.keys(cursors?.copilotApp?.dbs || {}),
+    );
+    const rawCopilotAppDbPaths = copilotSourceAllowed
+      ? Array.from(new Set([
+          ...copilotAppDbCandidates,
+          ...trackedCopilotAppDbPaths,
+        ])).filter((dbPath) => {
+          if (trackedCopilotAppDbPaths.has(dbPath)) return true;
+          try { return fssync.existsSync(dbPath); } catch (_e) { return false; }
         })
       : [];
+    const copilotAppDbPaths = uniqueCopilotDbPaths(
+      rawCopilotAppDbPaths,
+      process.env,
+      Array.from(trackedCopilotAppDbPaths),
+    );
     if (copilotAppDbPaths.length > 0) {
       if (progress?.enabled) {
         progress.start(`Parsing Copilot App ${renderBar(0)} | buckets 0`);
       }
+      for (const appDbPath of copilotAppDbPaths) {
+        const storePathKey = copilotPathKey(
+          path.join(path.dirname(appDbPath), "session-store.db"),
+        );
+        const observeOnly =
+          copilotStoreWasActive ||
+          adoptedCopilotStorePathKeys.has(storePathKey) ||
+          (copilotAppDbPaths.length === 1 && explicitStoreIsAdopted);
+        const catchupRelevant =
+          !observeOnly &&
+          !copilotStoreWasActive &&
+          copilotStorePaths.length > 0;
+        try {
+          const copilotAppResult = await parseCopilotAppDbIncremental({
+            dbPaths: [appDbPath],
+            cursors,
+            queuePath,
+            env: process.env,
+            observeOnly,
+            onProgress: (p) => {
+              if (!progress?.enabled) return;
+              const pct = p.total > 0 ? p.index / p.total : 1;
+              progress.update(
+                `Parsing Copilot App ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
+              );
+            },
+          });
+          copilotResult = mergeParseResult(copilotResult, copilotAppResult);
+          if (catchupRelevant && copilotAppResult.dbErrors > 0) {
+            copilotLegacyHealthy = false;
+          }
+        } catch (err) {
+          if (catchupRelevant) copilotLegacyHealthy = false;
+          warnProviderParseFailure("Copilot App", err, opts);
+        }
+      }
+    }
+
+    if (
+      copilotSourceAllowed &&
+      !copilotStoreWasActive &&
+      copilotStorePaths.length > 0 &&
+      copilotLegacyHealthy
+    ) {
+      if (progress?.enabled) {
+        progress.start(`Adopting Copilot App/CLI store ${renderBar(0)} | buckets 0`);
+      }
       try {
-        const copilotAppResult = await parseCopilotAppDbIncremental({
-          dbPaths: copilotAppDbPaths,
+        const copilotHasOtelCursorHistory =
+          (Array.isArray(cursors?.copilot?.seenIds) &&
+            cursors.copilot.seenIds.length > 0) ||
+          (cursors?.copilot?.fileOffsets &&
+            Object.keys(cursors.copilot.fileOffsets).length > 0);
+        const copilotOtelClaimsIncomplete =
+          copilotHadLegacyCliOtelHistory ||
+          (copilotHasOtelCursorHistory &&
+            cursors?.copilot?.usageClaimsComplete !== true);
+        const appSessionIds = [];
+        const appSessionTotals = {};
+        for (const dbState of Object.values(cursors?.copilotApp?.dbs || {})) {
+          for (const [sessionId, totals] of Object.entries(
+            dbState?.sessionTotals || {},
+          )) {
+            const total =
+              Number(totals?.input || 0) +
+              Number(totals?.output || 0) +
+              Number(totals?.cached || 0) +
+              Number(totals?.reasoning || 0);
+            if (total <= 0) continue;
+            appSessionIds.push(sessionId);
+            const prior = appSessionTotals[sessionId];
+            const priorTotal =
+              Number(prior?.input || 0) +
+              Number(prior?.output || 0) +
+              Number(prior?.cached || 0) +
+              Number(prior?.reasoning || 0);
+            if (total > priorTotal) appSessionTotals[sessionId] = totals;
+          }
+        }
+        copilotStoreResult = await parseCopilotSessionStoreIncremental({
+          dbPaths: copilotStorePaths,
           cursors,
           queuePath,
           env: process.env,
-          onProgress: (p) => {
-            if (!progress?.enabled) return;
-            const pct = p.total > 0 ? p.index / p.total : 1;
-            progress.update(
-              `Parsing Copilot App ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
-            );
-          },
+          backfillOnFirstRun: !copilotOtelClaimsIncomplete,
+          excludeSessionIdsOnFirstRun: appSessionIds,
+          excludeSessionTotalsOnFirstRun: appSessionTotals,
+          expectedFingerprints: copilotStoreAdoptionFingerprints,
+          otelUsageEvents: copilotOtelUsageClaims,
         });
-        copilotResult = {
-          recordsProcessed: copilotResult.recordsProcessed + copilotAppResult.recordsProcessed,
-          eventsAggregated: copilotResult.eventsAggregated + copilotAppResult.eventsAggregated,
-          bucketsQueued: copilotResult.bucketsQueued + copilotAppResult.bucketsQueued,
-        };
+        copilotResult = mergeParseResult(copilotResult, copilotStoreResult);
       } catch (err) {
-        warnProviderParseFailure("Copilot App", err, opts);
+        warnProviderParseFailure("Copilot App/CLI session store", err, opts);
+      }
+    }
+
+    if (copilotSourceAllowed) {
+      if (Array.isArray(cursors?.copilot?.recentUsageEvents)) {
+        cursors.copilot.recentUsageEvents = pruneCopilotUsageClaims(
+          cursors.copilot.recentUsageEvents,
+        );
+      }
+      if (Array.isArray(cursors?.copilotStore?.recentEvents)) {
+        cursors.copilotStore.recentEvents = pruneCopilotUsageClaims(
+          cursors.copilotStore.recentEvents,
+        );
       }
     }