@@ -76,8 +76,8 @@ saved totals first, then updates them when Cursor's API responds. When an enviro
 Usage shows its last report for the selected window when this browser saved that exact window,
 marked with the time it was read. Otherwise that environment shows no saved usage until it
 reconnects. Environments on one machine that read
-the same history folder count its newest completed scan once. When scans were read at the same time,
-the environment that attributed more of the work to T3 threads is used.
+the same history folder count it once, from the environment that attributed more of the work to T3
+threads. A scan that counted fewer records than a newer one is never used.
 
 If recent work is missing or a new model shows no cost, refresh to rescan session history and
 update model pricing.
 
@@ -318,13 +318,18 @@ describe("mergeUsage", () => {
       ],
       projects: [],
     });
-    // At the same read time, prefer the scan with stronger T3 attribution.
+    // Read later, but it only sees the session from outside, or (an older
+    // server) cannot split by thread at all.
     const outside = environment("outside", {
       ...summary([bucket({ thread: 0 })], [source]),
+      readAt: "2026-08-07T00:01:00.000Z",
       threads: [{ key: "session:claude:s", located: true }],
       projects: [],
     });
-    const older = environment("older", summary([bucket()], [source], USAGE_MERGE_COMPATIBLE_SINCE));
+    const older = environment("older", {
+      ...summary([bucket()], [source], USAGE_MERGE_COMPATIBLE_SINCE),
+      readAt: "2026-08-07T00:02:00.000Z",
+    });
 
     for (const ordered of [
       [ran, outside, older],
@@ -336,40 +341,41 @@ describe("mergeUsage", () => {
     }
   });
 
-  it("uses the newest complete scan even when it has less T3 attribution", () => {
+  it("keeps one complete scan per directory, even when a newer one differs", () => {
+    // Aliases or a later read can make the same records look like other cells.
     const source = { provider: "claude" as const, hostId: "mac", homePath: "/home/theo/.claude" };
-    const older = environment("older", {
+    const ran = environment("ran", {
       ...summary([bucket({ thread: 0 })], [source]),
       threads: [{ key: "t3:ship", threadId: ThreadId.make("ship"), located: true }],
       projects: [],
     });
-    const newer = environment("newer", {
-      ...summary([bucket({ thread: 0, costUsd: 15, records: 6 })], [source]),
+    const later = environment("later", {
+      ...summary([bucket({ thread: 0, model: "fable-alias", costUsd: 15 })], [source]),
       readAt: "2026-08-07T00:05:00.000Z",
       threads: [{ key: "session:claude:s", located: true }],
       projects: [],
     });
-    const merged = mergeUsage([newer, older], USAGE_CONTRACT_VERSION);
-    expect(merged.costUsd).toBe(15);
-    expect(merged.records).toBe(6);
-    expect(merged.contributions.map((entry) => entry.environmentId)).toEqual(["newer"]);
+    const merged = mergeUsage([later, ran], USAGE_CONTRACT_VERSION);
+    expect(merged.costUsd).toBe(10);
+    expect(merged.contributions.map((entry) => entry.environmentId)).toEqual(["ran"]);
   });
 
-  it("does not let a scan kept from a failed refresh hold a directory", () => {
+  it("does not let a better attributed scan drop records a newer scan counted", () => {
     const source = { provider: "claude" as const, hostId: "mac", homePath: "/home/theo/.claude" };
     const stale = environment("stale", {
       ...summary([bucket({ thread: 0 })], [source]),
       threads: [{ key: "t3:ship", threadId: ThreadId.make("ship"), located: true }],
       projects: [],
     });
     const fresh = environment("fresh", {
-      ...summary([bucket({ thread: 0, costUsd: 50 })], [source]),
-      readAt: "2026-08-07T03:00:00.000Z",
+      ...summary([bucket({ thread: 0, costUsd: 50, records: 6 })], [source]),
+      readAt: "2026-08-07T00:05:00.000Z",
       threads: [{ key: "session:claude:s", located: true }],
       projects: [],
     });
     const merged = mergeUsage([stale, fresh], USAGE_CONTRACT_VERSION);
     expect(merged.costUsd).toBe(50);
+    expect(merged.records).toBe(6);
     expect(merged.contributions.map((entry) => entry.environmentId)).toEqual(["fresh"]);
   });
 
@@ -390,6 +396,7 @@ describe("mergeUsage", () => {
         [bucket({ records: 9 }), bucket({ model: "y", thread: 0, costUsd: 1, records: 1 })],
         [source],
       ),
+      readAt: "2026-08-07T00:01:00.000Z",
       threads,
       projects: [],
     });
 
@@ -188,23 +188,27 @@ function dayKey(bucket: UsageBucket): string {
 }
 
 /**
- * How well an environment can attribute a source: -1 when its server cannot
- * split usage by thread at all, otherwise the records it placed in its own T3
- * threads.
+ * What an environment's scan of a source holds: every record it counted, and
+ * how many it placed in its own T3 threads (-1 when its server cannot split
+ * usage by thread at all).
  */
-function recordsInT3Threads(summary: UsageSummary, source: UsageSource): number {
+function scanCoverage(
+  summary: UsageSummary,
+  source: UsageSource,
+): { readonly records: number; readonly inThreads: number } {
   const threads = summary.threads;
-  if (threads === undefined) return -1;
   let records = 0;
+  let inThreads = threads === undefined ? -1 : 0;
   for (const bucket of bucketsForSource(summary, source)) {
-    if (bucket.thread !== undefined && threads[bucket.thread]?.threadId !== undefined) {
-      records += bucket.records;
+    records += bucket.records;
+    if (bucket.thread !== undefined && threads?.[bucket.thread]?.threadId !== undefined) {
+      inThreads += bucket.records;
     }
   }
-  return records;
+  return { records, inThreads };
 }
 
-/** Claim shared physical folders once; prefer complete, fresh scans.
+/** Claim shared physical folders once; prefer complete scans, then the best attributed one that drops nothing.
  * Claim whole summaries before narrowing buckets so slices retain the full merge's owners.
  */
 function claimSources(environments: readonly EnvironmentUsage[]): {
@@ -248,15 +252,19 @@ function claimSources(environments: readonly EnvironmentUsage[]): {
       }
     }
     for (const [key, list] of candidates) {
+      // `list` is newest first. The scan that attributed most to T3 threads owns
+      // the folder, unless it counted fewer records than the newest scan: that
+      // one predates usage the newest saw, and owning the folder would drop it.
+      const newest = list[0];
+      const floor =
+        newest === undefined ? 0 : scanCoverage(newest.environment.summary, newest.source).records;
       for (const entry of list) {
-        entry.inThreads = recordsInT3Threads(entry.environment.summary, entry.source);
+        const coverage = scanCoverage(entry.environment.summary, entry.source);
+        entry.inThreads = coverage.records < floor ? -2 : coverage.inThreads;
       }
-      // Parsed timestamps in the same millisecond are equally fresh; attribution breaks only that tie.
-      const [owner, ...rest] = [...list].sort(
-        (a, b) =>
-          (Date.parse(b.environment.summary.readAt) || 0) -
-            (Date.parse(a.environment.summary.readAt) || 0) || b.inThreads - a.inThreads,
-      );
+      // A stable sort keeps the read-time order among equals. A copy, not
+      // `toSorted`: this also runs on Hermes.
+      const [owner, ...rest] = [...list].sort((a, b) => b.inThreads - a.inThreads);
       if (owner === undefined) continue;
       ownerByFingerprint.set(key, owner.environment.environmentId);
       ownerScanByFingerprint.set(key, owner);