tokentracker-cli 0.48.0 → 0.49.0

package/src/commands/sync.js

@@ -122,6 +122,20 @@ const CLAUDE_MEM_OBSERVER_PATH_SEGMENT = "--claude-mem-observer-sessions";
 // for whatever data is actually on disk. A targeted, log-gap-safe mimo
 // migration will ship later under its own key.
 const CLAUDE_GROUND_TRUTH_REPAIR_KEY = "claudeGroundTruthRepair_2026_05_v4";
+// One-time full re-upload: the cloud ingest dropped `conversation_count` to 0
+// from 2026-04-18 until the 2026-06-10 field-mapping fix (it read
+// `b.conversations`; queue rows carry `conversation_count`). Historical cloud
+// rows can only be repaired from each user's local queue.jsonl — resetting the
+// upload offset replays the full queue and the ingest's whole-row upsert
+// overwrites every historical bucket with the correct conversation counts
+// (token columns replay to the same final values: last emission per key wins,
+// exactly how the cloud rows were built the first time).
+const CLOUD_CONVERSATIONS_BACKFILL_KEY = "cloudConversationsBackfill_2026_06";
+
+function warnProviderParseFailure(label, err, opts) {
+  if (opts?.auto) return;
+  process.stderr.write(`${label} sync: ${err && err.message ? err.message : err}\n`);
+}
 
 async function cmdSync(argv) {
   const opts = parseArgs(argv);
@@ -210,47 +224,61 @@ async function cmdSync(argv) {
       );
     }
 
-    const parseResult = await parseRolloutIncremental({
-      rolloutFiles,
-      cursors,
-      queuePath,
-      projectQueuePath,
-      onProgress: (p) => {
-        if (!progress?.enabled) return;
-        const pct = p.total > 0 ? p.index / p.total : 1;
-        progress.update(
-          `Parsing ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
-            p.bucketsQueued,
-          )}`,
-        );
-      },
-    });
+    let parseResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    try {
+      parseResult = await parseRolloutIncremental({
+        rolloutFiles,
+        cursors,
+        queuePath,
+        projectQueuePath,
+        onProgress: (p) => {
+          if (!progress?.enabled) return;
+          const pct = p.total > 0 ? p.index / p.total : 1;
+          progress.update(
+            `Parsing ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
+              p.bucketsQueued,
+            )}`,
+          );
+        },
+      });
+    } catch (err) {
+      warnProviderParseFailure("Codex", err, opts);
+    }
 
     let openclawResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
     if (openclawFiles.length > 0) {
       // Only runs when explicitly triggered by OpenClaw hooks.
-      openclawResult = await parseOpenclawIncremental({
-        sessionFiles: openclawFiles,
+      try {
+        openclawResult = await parseOpenclawIncremental({
+          sessionFiles: openclawFiles,
+          cursors,
+          queuePath,
+          projectQueuePath,
+          source: "openclaw",
+        });
+      } catch (err) {
+        warnProviderParseFailure("OpenClaw", err, opts);
+      }
+    }
+
+    let openclawFallback = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    try {
+      openclawFallback = await applyOpenclawTotalsFallback({
+        trackerDir,
+        signal: openclawSignal,
         cursors,
         queuePath,
         projectQueuePath,
-        source: "openclaw",
       });
+    } catch (err) {
+      warnProviderParseFailure("OpenClaw", err, opts);
     }
-
-    const openclawFallback = await applyOpenclawTotalsFallback({
-      trackerDir,
-      signal: openclawSignal,
-      cursors,
-      queuePath,
-      projectQueuePath,
-    });
     openclawResult.filesProcessed += openclawFallback.filesProcessed;
     openclawResult.eventsAggregated += openclawFallback.eventsAggregated;
     openclawResult.bucketsQueued += openclawFallback.bucketsQueued;
 
     const claudeFiles = await listClaudeProjectFiles(claudeProjectsDir);
-    await reincludeClaudeMemObserverFiles({ cursors, claudeFiles, queuePath });
+    await reincludeClaudeMemObserverFiles({ cursors, claudeFiles, queuePath, queueStatePath });
     await repairClaudeQueueFromGroundTruth({
       cursors,
       queuePath,
@@ -265,22 +293,26 @@ async function cmdSync(argv) {
           `Parsing Claude ${renderBar(0)} 0/${formatNumber(claudeFiles.length)} files | buckets 0`,
         );
       }
-      claudeResult = await parseClaudeIncremental({
-        projectFiles: claudeFiles,
-        cursors,
-        queuePath,
-        projectQueuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Claude ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
-              p.bucketsQueued,
-            )}`,
-          );
-        },
-        source: "claude",
-      });
+      try {
+        claudeResult = await parseClaudeIncremental({
+          projectFiles: claudeFiles,
+          cursors,
+          queuePath,
+          projectQueuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Claude ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
+                p.bucketsQueued,
+              )}`,
+            );
+          },
+          source: "claude",
+        });
+      } catch (err) {
+        warnProviderParseFailure("Claude", err, opts);
+      }
     }
 
     const geminiFiles = await listGeminiSessionFiles(geminiTmpDir);
@@ -291,22 +323,26 @@ async function cmdSync(argv) {
           `Parsing Gemini ${renderBar(0)} 0/${formatNumber(geminiFiles.length)} files | buckets 0`,
         );
       }
-      geminiResult = await parseGeminiIncremental({
-        sessionFiles: geminiFiles,
-        cursors,
-        queuePath,
-        projectQueuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Gemini ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
-              p.bucketsQueued,
-            )}`,
-          );
-        },
-        source: "gemini",
-      });
+      try {
+        geminiResult = await parseGeminiIncremental({
+          sessionFiles: geminiFiles,
+          cursors,
+          queuePath,
+          projectQueuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Gemini ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
+                p.bucketsQueued,
+              )}`,
+            );
+          },
+          source: "gemini",
+        });
+      } catch (err) {
+        warnProviderParseFailure("Gemini", err, opts);
+      }
     }
 
     const antigravityFiles = await listAntigravityTranscripts(geminiHome);
@@ -317,22 +353,26 @@ async function cmdSync(argv) {
           `Parsing Antigravity ${renderBar(0)} 0/${formatNumber(antigravityFiles.length)} files | buckets 0`,
         );
       }
-      antigravityResult = await parseAntigravityIncremental({
-        sessionFiles: antigravityFiles,
-        cursors,
-        queuePath,
-        projectQueuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Antigravity ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
-              p.bucketsQueued,
-            )}`,
-          );
-        },
-        source: "antigravity",
-      });
+      try {
+        antigravityResult = await parseAntigravityIncremental({
+          sessionFiles: antigravityFiles,
+          cursors,
+          queuePath,
+          projectQueuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Antigravity ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(
+                p.bucketsQueued,
+              )}`,
+            );
+          },
+          source: "antigravity",
+        });
+      } catch (err) {
+        warnProviderParseFailure("Antigravity", err, opts);
+      }
     }
 
     const opencodeFiles = await listOpencodeMessageFiles(opencodeStorageDir);
@@ -343,22 +383,26 @@ async function cmdSync(argv) {
           `Parsing Opencode ${renderBar(0)} 0/${formatNumber(opencodeFiles.length)} files | buckets 0`,
         );
       }
-      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",
-      });
+      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);
+      }
     }
 
     // OpenCode v1.2+ stores messages in SQLite (opencode.db) instead of JSON files.
@@ -371,22 +415,26 @@ async function cmdSync(argv) {
           `Parsing Opencode DB ${renderBar(0)} 0/${formatNumber(dbMessages.length)} msgs | buckets 0`,
         );
       }
-      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",
-      });
+      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;
@@ -405,23 +453,27 @@ async function cmdSync(argv) {
           `Parsing Kilo CLI ${renderBar(0)} 0/${formatNumber(kiloDbMessages.length)} msgs | buckets 0`,
         );
       }
-      kiloResult = await parseOpencodeDbIncremental({
-        dbMessages: kiloDbMessages,
-        cursors,
-        queuePath,
-        projectQueuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Kilo CLI ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-              p.total,
-            )} msgs | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-        source: "kilo-cli",
-        cursorKey: "kiloCli",
-      });
+      try {
+        kiloResult = await parseOpencodeDbIncremental({
+          dbMessages: kiloDbMessages,
+          cursors,
+          queuePath,
+          projectQueuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Kilo CLI ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
+                p.total,
+              )} msgs | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+          source: "kilo-cli",
+          cursorKey: "kiloCli",
+        });
+      } catch (err) {
+        warnProviderParseFailure("Kilo CLI", err, opts);
+      }
     }
 
     // ── Kilo Code VS Code extension (Cline-style ui_messages.json) ──
@@ -433,20 +485,24 @@ async function cmdSync(argv) {
           `Parsing Kilo Code ${renderBar(0)} 0/${formatNumber(kilocodeTaskFiles.length)} tasks | buckets 0`,
         );
       }
-      kilocodeResult = await parseKilocodeIncremental({
-        taskFiles: kilocodeTaskFiles,
-        cursors,
-        queuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Kilo Code ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-              p.total,
-            )} tasks | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        kilocodeResult = await parseKilocodeIncremental({
+          taskFiles: kilocodeTaskFiles,
+          cursors,
+          queuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Kilo Code ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
+                p.total,
+              )} tasks | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Kilo Code", err, opts);
+      }
     }
 
     // ── Goose (Block) — SQLite sessions with cumulative tokens per session ──
@@ -456,20 +512,24 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing Goose ${renderBar(0)} 0 sessions | buckets 0`);
       }
-      gooseResult = await parseGooseIncremental({
-        dbPath: gooseDbPath,
-        cursors,
-        queuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Goose ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-              p.total,
-            )} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        gooseResult = await parseGooseIncremental({
+          dbPath: gooseDbPath,
+          cursors,
+          queuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Goose ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
+                p.total,
+              )} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Goose", err, opts);
+      }
     }
 
     // ── Droid (Factory CLI) — passive reader for ~/.factory/sessions/*.settings.json ──
@@ -481,24 +541,28 @@ async function cmdSync(argv) {
           `Parsing Droid ${renderBar(0)} 0/${formatNumber(droidSettingsFiles.length)} sessions | buckets 0`,
         );
       }
-      droidResult = await parseDroidIncremental({
-        settingsFiles: droidSettingsFiles,
-        cursors,
-        queuePath,
-        // Full-scan sync: drop cursor entries for any session whose
-        // settings.json has disappeared off disk so cursors.droid stays
-        // bounded by the actual on-disk session count.
-        prune: true,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Droid ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-              p.total,
-            )} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        droidResult = await parseDroidIncremental({
+          settingsFiles: droidSettingsFiles,
+          cursors,
+          queuePath,
+          // Full-scan sync: drop cursor entries for any session whose
+          // settings.json has disappeared off disk so cursors.droid stays
+          // bounded by the actual on-disk session count.
+          prune: true,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Droid ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
+                p.total,
+              )} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Droid", err, opts);
+      }
     }
 
     // ── Zed Agent (all providers; cumulative-delta over SQLite threads) ──
@@ -508,20 +572,24 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing Zed Agent ${renderBar(0)} 0 threads | buckets 0`);
       }
-      zedResult = await parseZedIncremental({
-        dbPath: zedDbPath,
-        cursors,
-        queuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Zed Agent ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-              p.total,
-            )} threads | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        zedResult = await parseZedIncremental({
+          dbPath: zedDbPath,
+          cursors,
+          queuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Zed Agent ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
+                p.total,
+              )} threads | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Zed Agent", err, opts);
+      }
     }
 
     // ── Roo Code VS Code extension (Cline-derived; rooveterinaryinc.roo-cline) ──
@@ -533,20 +601,24 @@ async function cmdSync(argv) {
           `Parsing Roo Code ${renderBar(0)} 0/${formatNumber(roocodeTaskFiles.length)} tasks | buckets 0`,
         );
       }
-      roocodeResult = await parseRoocodeIncremental({
-        taskFiles: roocodeTaskFiles,
-        cursors,
-        queuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Roo Code ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
-              p.total,
-            )} tasks | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        roocodeResult = await parseRoocodeIncremental({
+          taskFiles: roocodeTaskFiles,
+          cursors,
+          queuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Roo Code ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
+                p.total,
+              )} tasks | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Roo Code", err, opts);
+      }
     }
 
     // ── Cursor (API-based) ──
@@ -605,19 +677,23 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing Kiro ${renderBar(0)} | buckets 0`);
       }
-      kiroResult = await parseKiroIncremental({
-        dbPath: kiroDbPath,
-        jsonlPath: kiroJsonlPath,
-        cursors,
-        queuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Kiro ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} records | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        kiroResult = await parseKiroIncremental({
+          dbPath: kiroDbPath,
+          jsonlPath: kiroJsonlPath,
+          cursors,
+          queuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Kiro ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} records | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Kiro", err, opts);
+      }
     }
 
     // ── Hermes Agent (SQLite-based) ──
@@ -627,18 +703,22 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing Hermes ${renderBar(0)} | buckets 0`);
       }
-      hermesResult = await parseHermesIncremental({
-        hermesPath,
-        cursors,
-        queuePath,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Hermes ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        hermesResult = await parseHermesIncremental({
+          hermesPath,
+          cursors,
+          queuePath,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Hermes ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Hermes", err, opts);
+      }
     }
 
     // ── Kiro CLI (reads ~/Library/Application Support/kiro-cli/data.sqlite3
@@ -682,19 +762,23 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing Kimi Code ${renderBar(0)} | buckets 0`);
       }
-      kimiResult = await parseKimiIncremental({
-        wireFiles: kimiWireFiles,
-        cursors,
-        queuePath,
-        env: process.env,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Kimi Code ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        kimiResult = await parseKimiIncremental({
+          wireFiles: kimiWireFiles,
+          cursors,
+          queuePath,
+          env: process.env,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Kimi Code ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Kimi Code", err, opts);
+      }
     }
 
     // ── Kimi Code official (@moonshot-ai/kimi-code, ~/.kimi-code) ──
@@ -704,19 +788,23 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing Kimi Code (official) ${renderBar(0)} | buckets 0`);
       }
-      kimiCodeResult = await parseKimiCodeIncremental({
-        wireFiles: kimiCodeWireFiles,
-        cursors,
-        queuePath,
-        env: process.env,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Kimi Code (official) ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        kimiCodeResult = await parseKimiCodeIncremental({
+          wireFiles: kimiCodeWireFiles,
+          cursors,
+          queuePath,
+          env: process.env,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Kimi Code (official) ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Kimi Code (official)", err, opts);
+      }
     }
 
     // ── CodeBuddy CLI (passive ~/.codebuddy/projects/**/*.jsonl reader) ──
@@ -728,19 +816,23 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing CodeBuddy ${renderBar(0)} | buckets 0`);
       }
-      codebuddyResult = await parseCodebuddyIncremental({
-        projectFiles: codebuddyFiles,
-        cursors,
-        queuePath,
-        env: process.env,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing CodeBuddy ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        codebuddyResult = await parseCodebuddyIncremental({
+          projectFiles: codebuddyFiles,
+          cursors,
+          queuePath,
+          env: process.env,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing CodeBuddy ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("CodeBuddy", err, opts);
+      }
     }
 
     // ── oh-my-pi (passive ~/.omp/agent/sessions/**/*.jsonl reader) ──
@@ -750,19 +842,23 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing oh-my-pi ${renderBar(0)} | buckets 0`);
       }
-      ompResult = await parseOmpIncremental({
-        sessionFiles: ompFiles,
-        cursors,
-        queuePath,
-        env: process.env,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing oh-my-pi ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        ompResult = await parseOmpIncremental({
+          sessionFiles: ompFiles,
+          cursors,
+          queuePath,
+          env: process.env,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing oh-my-pi ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("oh-my-pi", err, opts);
+      }
     }
 
     // ── pi (@mariozechner/pi-coding-agent) — passive ~/.pi/agent/sessions/**/*.jsonl reader ──
@@ -777,19 +873,23 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing pi ${renderBar(0)} | buckets 0`);
       }
-      piResult = await parsePiIncremental({
-        sessionFiles: piFiles,
-        cursors,
-        queuePath,
-        env: process.env,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing pi ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        piResult = await parsePiIncremental({
+          sessionFiles: piFiles,
+          cursors,
+          queuePath,
+          env: process.env,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing pi ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("pi", err, opts);
+      }
     }
 
     // ── Craft Agents (passive ~/.craft-agent + workspaces session.jsonl reader) ──
@@ -799,19 +899,23 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing Craft ${renderBar(0)} | buckets 0`);
       }
-      craftResult = await parseCraftIncremental({
-        sessionFiles: craftFiles,
-        cursors,
-        queuePath,
-        env: process.env,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Craft ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        craftResult = await parseCraftIncremental({
+          sessionFiles: craftFiles,
+          cursors,
+          queuePath,
+          env: process.env,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Craft ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Craft", err, opts);
+      }
     }
 
     // ── Grok Build (xAI) ──
@@ -860,19 +964,24 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing Grok Build ${renderBar(0)} | buckets 0`);
       }
-      const grokScanResult = await parseGrokBuildIncremental({
-        sessions: grokSessionInputs,
-        cursors,
-        queuePath,
-        env: process.env,
-        onProgress: (p) => {
-          if (!progress?.enabled) return;
-          const pct = p.total > 0 ? p.index / p.total : 1;
-          progress.update(
-            `Parsing Grok Build ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      let grokScanResult = { recordsProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+      try {
+        grokScanResult = await parseGrokBuildIncremental({
+          sessions: grokSessionInputs,
+          cursors,
+          queuePath,
+          env: process.env,
+          onProgress: (p) => {
+            if (!progress?.enabled) return;
+            const pct = p.total > 0 ? p.index / p.total : 1;
+            progress.update(
+              `Parsing Grok Build ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} sessions | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Grok Build", err, opts);
+      }
       grokResult = {
         recordsProcessed: grokResult.recordsProcessed + grokScanResult.recordsProcessed,
         eventsAggregated: grokResult.eventsAggregated + grokScanResult.eventsAggregated,
@@ -890,19 +999,23 @@ async function cmdSync(argv) {
       if (progress?.enabled) {
         progress.start(`Parsing Copilot ${renderBar(0)} | buckets 0`);
       }
-      copilotResult = await parseCopilotIncremental({
-        otelPaths: copilotPaths,
-        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 ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
-          );
-        },
-      });
+      try {
+        copilotResult = await parseCopilotIncremental({
+          otelPaths: copilotPaths,
+          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 ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(p.total)} files | buckets ${formatNumber(p.bucketsQueued)}`,
+            );
+          },
+        });
+      } catch (err) {
+        warnProviderParseFailure("Copilot", err, opts);
+      }
     }
 
     if (cursors?.projectHourly?.projects && projectQueuePath && projectQueueStatePath) {
@@ -920,6 +1033,8 @@ async function cmdSync(argv) {
       }
     }
 
+    await applyCloudConversationsBackfill({ cursors, queueStatePath });
+
     cursors.updatedAt = new Date().toISOString();
     await writeJson(cursorsPath, cursors);
     if (grokHookSignalConsumed && grokHookSignalPath) {
@@ -1095,10 +1210,12 @@ module.exports = {
   migrateRolloutCumulativeDeltaBuckets,
   reincludeClaudeMemObserverFiles,
   repairGrokQueueFromSessionSnapshots,
+  applyCloudConversationsBackfill,
   CURSOR_UNKNOWN_MIGRATION_KEY,
   ROLLOUT_CUMULATIVE_DELTA_MIGRATION_KEY,
   CLAUDE_MEM_OBSERVER_REINCLUDE_KEY,
   GROK_APPEND_ONLY_REPAIR_MIGRATION_KEY,
+  CLOUD_CONVERSATIONS_BACKFILL_KEY,
 };
 
 function normalizeString(value) {
@@ -1458,6 +1575,12 @@ async function readQueueBatch(queuePath, startOffset, maxBuckets) {
     const model = (typeof bucket?.model === "string" ? bucket.model.trim() : "") || "unknown";
     bucket.source = source;
     bucket.model = model;
+    // Apply the same legacy-row corrections every local reader applies
+    // (local-api readQueueData / project queue / wrapped aggregator). Without
+    // this the cloud permanently kept the RAW legacy values — e.g. old Codex
+    // rows whose input_tokens still include cached tokens (6-7x inflated) —
+    // while the local dashboard showed corrected numbers.
+    bucket = require("../lib/local-api").normalizeQueueRow(bucket);
     bucketMap.set(`${source}|${model}|${hourStart}`, bucket);
     linesRead += 1;
     if (linesRead >= maxBuckets) break;
@@ -1806,6 +1929,32 @@ async function repairGrokQueueFromSessionSnapshots({ cursors, queuePath, queueSt
   return true;
 }
 
+async function applyCloudConversationsBackfill({ cursors, queueStatePath }) {
+  if (!cursors || typeof cursors !== "object") return false;
+  cursors.migrations = cursors.migrations || {};
+  if (cursors.migrations[CLOUD_CONVERSATIONS_BACKFILL_KEY]) return false;
+
+  // Reset ONLY the cloud upload offset. The queue file itself is untouched;
+  // ingest upserts are idempotent per (user, device, hour, source, model),
+  // so replaying the whole queue is safe — it costs upload batches, not
+  // correctness. Project queue is never uploaded and is not touched.
+  let prevOffset = 0;
+  try {
+    const st = (await readJson(queueStatePath)) || {};
+    prevOffset = Number(st.offset || 0);
+  } catch (_e) {
+    /* missing state file — nothing to reset */
+  }
+  if (prevOffset > 0) {
+    await writeJson(queueStatePath, { offset: 0, updatedAt: new Date().toISOString() });
+  }
+  cursors.migrations[CLOUD_CONVERSATIONS_BACKFILL_KEY] = {
+    appliedAt: new Date().toISOString(),
+    previousOffset: prevOffset,
+  };
+  return prevOffset > 0;
+}
+
 async function migrateCursorUnknownBuckets({ cursors, queuePath }) {
   if (!cursors || typeof cursors !== "object") return;
   cursors.migrations = cursors.migrations || {};
@@ -2169,7 +2318,7 @@ async function repairClaudeQueueFromGroundTruth({
   return true;
 }
 
-async function reincludeClaudeMemObserverFiles({ cursors, claudeFiles, queuePath }) {
+async function reincludeClaudeMemObserverFiles({ cursors, claudeFiles, queuePath, queueStatePath }) {
   if (!cursors || typeof cursors !== "object") return false;
   const migrations = (cursors.migrations ||= {});
   if (migrations[CLAUDE_MEM_OBSERVER_REINCLUDE_KEY]) return false;
@@ -2207,7 +2356,7 @@ async function reincludeClaudeMemObserverFiles({ cursors, claudeFiles, queuePath
   }
 
   const queueRowsRelabeled = typeof queuePath === "string" && queuePath
-    ? await relabelClaudeMemQueueRows(queuePath)
+    ? await relabelClaudeMemQueueRows(queuePath, queueStatePath)
     : 0;
 
   migrations[CLAUDE_MEM_OBSERVER_REINCLUDE_KEY] = {
@@ -2219,7 +2368,7 @@ async function reincludeClaudeMemObserverFiles({ cursors, claudeFiles, queuePath
   return filesReset > 0 || hashesRemoved > 0 || queueRowsRelabeled > 0;
 }
 
-async function relabelClaudeMemQueueRows(queuePath) {
+async function relabelClaudeMemQueueRows(queuePath, queueStatePath = null) {
   let raw;
   try {
     raw = await fs.readFile(queuePath, "utf8");
@@ -2228,32 +2377,73 @@ async function relabelClaudeMemQueueRows(queuePath) {
   }
   if (!raw || !raw.includes('"claude-mem"')) return 0;
 
+  // The cloud-upload cursor (queue.state.json `offset`) is a byte position in
+  // the pre-rewrite file. Relabeling shrinks rewritten lines ("claude-mem" →
+  // "claude"), so the old offset would land mid-line in the new file and the
+  // next drainQueueToCloud batch would skip part of a row (or a whole row).
+  // Track the old→new byte mapping while rewriting and remap the offset to
+  // the equivalent line boundary (same pattern as project-usage-purge.js).
+  let previousOffset = 0;
+  if (typeof queueStatePath === "string" && queueStatePath) {
+    try {
+      const st = JSON.parse(await fs.readFile(queueStatePath, "utf8"));
+      const off = Number(st?.offset || 0);
+      if (Number.isFinite(off) && off > 0) previousOffset = off;
+    } catch (_e) {
+      previousOffset = 0;
+    }
+  }
+
   const lines = raw.split("\n");
   const out = [];
   let relabeled = 0;
-  for (const line of lines) {
-    if (!line) {
-      out.push(line);
-      continue;
+  let inputOffset = 0;
+  let outputOffset = 0;
+  let nextOffset = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const isLast = i === lines.length - 1;
+    let outLine = line;
+    if (line) {
+      try {
+        const obj = JSON.parse(line);
+        if (obj && obj.source === "claude-mem") {
+          obj.source = "claude";
+          relabeled += 1;
+          outLine = JSON.stringify(obj);
+        }
+      } catch (_e) {
+        // keep malformed lines verbatim
+      }
     }
-    let obj;
+    out.push(outLine);
+    inputOffset += Buffer.byteLength(line, "utf8") + (isLast ? 0 : 1);
+    outputOffset += Buffer.byteLength(outLine, "utf8") + (isLast ? 0 : 1);
+    // Upload offsets always sit at line boundaries; a mid-line offset
+    // (corruption) rounds down to the previous boundary so no row is skipped
+    // — worst case a row is re-uploaded, and cloud ingest upserts by key.
+    if (inputOffset <= previousOffset) nextOffset = outputOffset;
+  }
+  if (relabeled === 0) return 0;
+
+  // Atomic rewrite: temp file in the same directory + rename, so a crash
+  // mid-write can never leave queue.jsonl truncated.
+  const tmpPath = `${queuePath}.tmp`;
+  await fs.writeFile(tmpPath, out.join("\n"), "utf8");
+  await fs.rename(tmpPath, queuePath);
+
+  if (typeof queueStatePath === "string" && queueStatePath && previousOffset > 0) {
+    let state = {};
     try {
-      obj = JSON.parse(line);
+      state = JSON.parse(await fs.readFile(queueStatePath, "utf8"));
+      if (!state || typeof state !== "object") state = {};
     } catch (_e) {
-      out.push(line);
-      continue;
-    }
-    if (obj && obj.source === "claude-mem") {
-      obj.source = "claude";
-      relabeled += 1;
-      out.push(JSON.stringify(obj));
-    } else {
-      out.push(line);
+      state = {};
     }
+    state.offset = nextOffset;
+    state.updatedAt = new Date().toISOString();
+    await fs.writeFile(queueStatePath, JSON.stringify(state), "utf8");
   }
-  if (relabeled === 0) return 0;
-
-  await fs.writeFile(queuePath, out.join("\n"), "utf8");
   return relabeled;
 }