tokentracker-cli 0.87.16 → 0.87.18

package/src/lib/rollout.js

@@ -329,15 +329,28 @@ async function parseRolloutIncremental({
   }) => {
     if (rebuildingBaseline) return true;
     if (prev && (!sameInode || truncated)) return true;
-    if (sameInode && !truncated && startOffset > 0) return false;
-    if (prev?.lastTotal) return true;
+
+    // Same session under another cursor path — the two roots of a `union`
+    // install (src/lib/install-resolver.js) reaching one file, or a
+    // sessions/ -> archived_sessions/ move. This MUST be decided before the
+    // steady-state short-circuit below: the append-only tracker only knows keys
+    // written during the current run, so when the other path has nothing new to
+    // read it contributes none, and a path whose cursor fell behind (a distro
+    // that was briefly unreachable, a TOKENTRACKER_WSL_MODE round-trip) replays
+    // its gap into the persisted buckets. Only the persisted set can catch that.
     const sessionId = codexSessionIdFromPath(filePath);
     if (!sessionId) return true;
     const knownPaths = getCursorSessionPaths().get(sessionId);
-    if (!knownPaths) return false;
-    for (const knownPath of knownPaths) {
-      if (knownPath !== filePath) return true;
+    if (knownPaths) {
+      for (const knownPath of knownPaths) {
+        if (knownPath !== filePath) return true;
+      }
     }
+
+    // Steady state: one path, already read past, not rotated. Everything after
+    // our own offset is genuinely new, so skip the persisted-set construction.
+    if (sameInode && !truncated && startOffset > 0) return false;
+    if (prev?.lastTotal) return true;
     return false;
   };
 

package/src/lib/session-analytics.js

@@ -795,6 +795,59 @@ function providerRoots(home, providerDir, env, deps = {}) {
   return [...new Set(roots)];
 }
 
+// Collapse the same Claude session discovered under more than one root.
+//
+// Codex gets this from its session-id pass below; Claude only ever had per-file
+// message dedup (`claudeMessageDedupKey` inside `scanClaudeSession`), which
+// cannot see a second copy of the same file under a different path spelling.
+// Every discovered path becomes its own row keyed by the resolved file path, so
+// a WSL `$HOME` pointing at the Windows profile — the same files reachable as
+// both `C:\Users\dev\.claude\...` and `\\wsl$\Ubuntu\home\dev\.claude\...` —
+// duplicated sessions in the browser, the project list and the CSV export.
+//
+// Cross-root only, on purpose: a single root is passed through verbatim, so
+// single-install machines are unaffected, and two same-named files inside one
+// tree stay distinct (unproven identity must not delete a session). A basename
+// without a session UUID never participates either.
+function dedupeClaudeFilesAcrossRoots(groups) {
+  const rootGroups = (groups || []).filter((group) => Array.isArray(group) && group.length > 0);
+  if (rootGroups.length <= 1) return [...new Set(rootGroups[0] || [])];
+
+  const mtimeOf = (filePath) => {
+    try { return fs.statSync(filePath).mtimeMs; } catch { return -Infinity; }
+  };
+  // Preserve root order for everything kept, so native precedence is stable.
+  // Claims are compared only against EARLIER roots: two same-UUID files inside
+  // one tree are siblings, not copies, and must both survive.
+  const ordered = [];
+  const winnerBySession = new Map();
+  for (const group of rootGroups) {
+    const claimedHere = new Map();
+    for (const filePath of group) {
+      const id = path.basename(filePath).match(/^([0-9a-f-]{36})\.jsonl$/i)?.[1] || null;
+      if (!id || claimedHere.has(id)) {
+        // No session identity, or a sibling within this same root.
+        if (!ordered.includes(filePath)) ordered.push(filePath);
+        continue;
+      }
+      claimedHere.set(id, filePath);
+      const previous = winnerBySession.get(id);
+      if (previous === undefined) {
+        winnerBySession.set(id, filePath);
+        ordered.push(filePath);
+        continue;
+      }
+      if (previous === filePath) continue;
+      // Same session in an earlier root: keep the newer file, mirroring Codex.
+      if (mtimeOf(filePath) > mtimeOf(previous)) {
+        winnerBySession.set(id, filePath);
+        ordered[ordered.indexOf(previous)] = filePath;
+      }
+    }
+  }
+  return [...new Set(ordered)];
+}
+
 async function discoverSessionFiles(home, env = process.env, deps = {}) {
   const grokHome = resolveGrokHome(home);
   const claudeRoots = providerRoots(home, ".claude", env, deps);
@@ -805,7 +858,7 @@ async function discoverSessionFiles(home, env = process.env, deps = {}) {
     Promise.all(codexRoots.map((r) => listRolloutFilesDeep(path.join(r, "archived_sessions")))),
     listGrokSessionFiles(path.join(grokHome, "sessions")),
   ]);
-  const allClaude = [...new Set(claudeGroups.flat())];
+  const allClaude = dedupeClaudeFilesAcrossRoots(claudeGroups);
   const codex = [...new Set(codexGroups.flat())];
   const archived = [...new Set(archivedGroups.flat())];
   // Claude Memory stores thousands of background observer transcripts beside
@@ -1302,4 +1355,5 @@ module.exports = {
   resumeCommandFor,
   sessionsToCsv,
   providerRoots,
+  dedupeClaudeFilesAcrossRoots,
 };

package/dashboard/dist/assets/DialogDescription-BFVB627n.js

@@ -1 +0,0 @@
-import{r as n,z as a}from"./__vite-browser-external-CDv96ZcG.js";import{u as p}from"./DialogTitle-Cw53obf0.js";import{u as c}from"./useScrollLock-CU659jBG.js";const x=n.forwardRef(function(e,r){const{render:l,className:u,style:m,id:s,...t}=e,{store:i}=p(),o=c(s);return i.useSyncedValueWithCleanup("descriptionElementId",o),a("p",e,{ref:r,props:[{id:o},t]})});export{x as D};

package/dashboard/dist/assets/use-reduced-motion-DhNppA5X.js

@@ -1 +0,0 @@
-import{r as o}from"./__vite-browser-external-CDv96ZcG.js";import{h as r,i as t,p as s}from"./react-Cc1Ca2uE.js";function i(){!r.current&&t();const[e]=o.useState(s.current);return e}export{i as u};