fix(stats): dedup usage records by sessionId and skip in-progress writes (#4995)

* fix(stats): dedup usage records by sessionId and skip in-progress writes (#4994)

Opening /stats during the first-ever turn followed by /clear (or exit) used
to write the same sessionId twice into ~/.qwen/usage_record.jsonl, permanently
inflating every aggregate (sessions / tokens / durations / tools / heatmap /
projects) 2x for that session. Closes #4994.

Defense in depth:
- Read side: loadUsageHistory dedups records by sessionId (last-wins), so any
  duplicates already on disk from this bug stop inflating future aggregates.
- Write side: rebuildFromSessionJsonl skips the in-progress session when its
  sessionId is passed in; statsDataService threads currentSession.sessionId
  through. New duplicates are no longer created at the source.

Regression coverage in usageHistoryService.test.ts mirrors the exact bug
sequence (open /stats during first turn -> /clear -> re-open /stats) and
asserts sessionCount=1, totalTokens=1600 for a single ~1.6k-token session.

* fix(stats): address PR review — log dedup count and rename rebuild-skip param

Why:
- dedupBySessionId silently dropped duplicate records, making it
  impossible to observe how many users were affected by the #4994 bug.
  Now logs the removed count at debug level.
- The new loadUsageHistory parameter was named currentSessionId but only
  controls the write-side skip during rebuildFromSessionJsonl — the read
  path ignores it. Renaming to skipSessionInRebuild makes the limited
  scope explicit; statsDataService still strips/re-pushes the live
  current session for defense-in-depth.

PR review feedback on #4995.

Author: BenGuanRan

packages/cli/src/ui/utils/statsDataService.ts

@@ -248,7 +248,7 @@ export async function loadStatsData(
   range: TimeRange,
   currentSession?: UsageSummaryRecord,
 ): Promise<StatsData> {
-  const persisted = await loadUsageHistory();
+  const persisted = await loadUsageHistory(currentSession?.sessionId);
   let records = persisted;
   if (currentSession) {
     records = persisted.filter((r) => r.sessionId !== currentSession.sessionId);

packages/core/src/services/usageHistoryService.test.ts

@@ -4,8 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { describe, it, expect } from 'vitest';
-import { metricsToUsageRecord, aggregateUsage } from './usageHistoryService.js';
+import { afterEach, beforeEach, describe, it, expect } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  metricsToUsageRecord,
+  aggregateUsage,
+  loadUsageHistory,
+  persistSessionUsage,
+} from './usageHistoryService.js';
 import { ToolCallDecision } from '../telemetry/tool-call-decision.js';
 import type { SessionMetrics } from '../telemetry/uiTelemetry.js';
 import type { UsageSummaryRecord } from './usageHistoryService.js';
@@ -349,3 +357,222 @@ describe('aggregateUsage', () => {
     expect(report.tools.topTools).toEqual([]);
   });
 });
+
+// Regression coverage for issue #4994: opening /stats during the first-ever
+// turn followed by /clear or process exit used to write the same sessionId
+// twice into usage_record.jsonl, permanently inflating every aggregate 2x.
+describe('loadUsageHistory + persistSessionUsage (issue #4994 regression)', () => {
+  let tmpHome: string;
+  let originalQwenHome: string | undefined;
+
+  beforeEach(() => {
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'qwen-usage-history-'));
+    originalQwenHome = process.env['QWEN_HOME'];
+    process.env['QWEN_HOME'] = path.join(tmpHome, '.qwen');
+    fs.mkdirSync(process.env['QWEN_HOME'], { recursive: true });
+  });
+
+  afterEach(() => {
+    if (originalQwenHome === undefined) delete process.env['QWEN_HOME'];
+    else process.env['QWEN_HOME'] = originalQwenHome;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  function plantChatJsonl(sessionId: string, tokens: number) {
+    const cwd = '/repro/project';
+    const start = new Date('2026-06-11T00:00:00Z').toISOString();
+    const mid = new Date('2026-06-11T00:01:00Z').toISOString();
+    const end = new Date('2026-06-11T00:02:00Z').toISOString();
+    const projDir = path.join(
+      process.env['QWEN_HOME']!,
+      'projects',
+      'repro-project',
+    );
+    fs.mkdirSync(path.join(projDir, 'chats'), { recursive: true });
+    const records = [
+      {
+        sessionId,
+        cwd,
+        uuid: 'u1',
+        parentUuid: null,
+        timestamp: start,
+        type: 'user',
+        message: { role: 'user', content: 'hi' },
+      },
+      {
+        sessionId,
+        cwd,
+        uuid: 'u2',
+        parentUuid: 'u1',
+        timestamp: mid,
+        type: 'system',
+        subtype: 'ui_telemetry',
+        systemPayload: {
+          uiEvent: {
+            'event.name': 'qwen-code.api_response',
+            'event.timestamp': mid,
+            response_id: 'r1',
+            model: 'qwen-max',
+            duration_ms: 1200,
+            input_token_count: tokens * 0.6,
+            output_token_count: tokens * 0.3,
+            cached_content_token_count: 0,
+            thoughts_token_count: tokens * 0.1,
+            total_token_count: tokens,
+            prompt_id: 'p1',
+          },
+        },
+      },
+      {
+        sessionId,
+        cwd,
+        uuid: 'u3',
+        parentUuid: 'u2',
+        timestamp: end,
+        type: 'assistant',
+        message: { role: 'assistant', content: 'ok' },
+      },
+    ];
+    fs.writeFileSync(
+      path.join(projDir, 'chats', `${sessionId}.jsonl`),
+      records.map((r) => JSON.stringify(r)).join('\n') + '\n',
+    );
+  }
+
+  function makeLiveMetrics(tokens: number): SessionMetrics {
+    return {
+      models: {
+        'qwen-max': {
+          api: { totalRequests: 1, totalErrors: 0, totalLatencyMs: 1200 },
+          tokens: {
+            prompt: tokens * 0.6,
+            candidates: tokens * 0.3,
+            total: tokens,
+            cached: 0,
+            thoughts: tokens * 0.1,
+          },
+          bySource: {},
+        },
+      },
+      tools: {
+        totalCalls: 0,
+        totalSuccess: 0,
+        totalFail: 0,
+        totalDurationMs: 0,
+        totalDecisions: {
+          [ToolCallDecision.ACCEPT]: 0,
+          [ToolCallDecision.REJECT]: 0,
+          [ToolCallDecision.MODIFY]: 0,
+          [ToolCallDecision.AUTO_ACCEPT]: 0,
+        },
+        byName: {},
+      },
+      files: { totalLinesAdded: 0, totalLinesRemoved: 0 },
+    };
+  }
+
+  it('read-side: dedups duplicate sessionId records already on disk (last-wins)', async () => {
+    // Simulate a usage_record.jsonl already corrupted by the pre-fix bug:
+    // two records with the same sessionId.
+    const sessionId = 'sess-dup-1';
+    const usagePath = path.join(
+      process.env['QWEN_HOME']!,
+      'usage_record.jsonl',
+    );
+    const rec = (totalTokens: number) => ({
+      version: 1 as const,
+      sessionId,
+      timestamp: Date.now(),
+      startTime: Date.now() - 60000,
+      project: '/p',
+      durationMs: 60000,
+      totalLatencyMs: 1200,
+      models: {
+        'qwen-max': {
+          requests: 1,
+          inputTokens: totalTokens * 0.6,
+          outputTokens: totalTokens * 0.3,
+          cachedTokens: 0,
+          thoughtsTokens: totalTokens * 0.1,
+          totalTokens,
+        },
+      },
+      tools: { totalCalls: 0, totalSuccess: 0, totalFail: 0, byName: {} },
+      files: { linesAdded: 0, linesRemoved: 0 },
+    });
+    fs.writeFileSync(
+      usagePath,
+      JSON.stringify(rec(1000)) + '\n' + JSON.stringify(rec(1600)) + '\n',
+    );
+
+    const records = await loadUsageHistory();
+
+    expect(records).toHaveLength(1);
+    // Last-wins: the second record (1600 tokens) survives.
+    expect(records[0]!.models['qwen-max']!.totalTokens).toBe(1600);
+
+    const report = aggregateUsage(records, 'all');
+    expect(report.sessionCount).toBe(1);
+  });
+
+  it('write-side: rebuildFromSessionJsonl skips the in-progress session when skipSessionInRebuild is passed', async () => {
+    const sessionId = 'sess-in-progress';
+    plantChatJsonl(sessionId, 1600);
+    const usagePath = path.join(
+      process.env['QWEN_HOME']!,
+      'usage_record.jsonl',
+    );
+
+    // First /stats open during the live session.
+    const first = await loadUsageHistory(sessionId);
+    expect(first).toHaveLength(1);
+    // Critically: the file must NOT contain the in-progress session.
+    expect(fs.existsSync(usagePath)).toBe(false);
+
+    // /clear or process exit writes the authoritative record exactly once.
+    persistSessionUsage({
+      sessionId,
+      startTime: new Date('2026-06-11T00:00:00Z'),
+      endTime: new Date('2026-06-11T00:02:00Z'),
+      project: '/repro/project',
+      metrics: makeLiveMetrics(1600),
+    });
+    const lines = fs.readFileSync(usagePath, 'utf8').trim().split('\n');
+    expect(lines).toHaveLength(1);
+
+    // Subsequent /stats open after session end aggregates exactly one record.
+    const second = await loadUsageHistory();
+    expect(second).toHaveLength(1);
+    const report = aggregateUsage(second, 'all');
+    expect(report.sessionCount).toBe(1);
+    let totalTokens = 0;
+    for (const m of Object.values(report.models)) totalTokens += m.totalTokens;
+    expect(totalTokens).toBe(1600);
+  });
+
+  it('end-to-end: /stats during first turn + /clear must not 2x the session', async () => {
+    const sessionId = 'sess-e2e';
+    plantChatJsonl(sessionId, 1600);
+
+    // Step 1: open /stats (first time) during the live session.
+    await loadUsageHistory(sessionId);
+
+    // Step 2: /clear or exit.
+    persistSessionUsage({
+      sessionId,
+      startTime: new Date('2026-06-11T00:00:00Z'),
+      endTime: new Date('2026-06-11T00:02:00Z'),
+      project: '/repro/project',
+      metrics: makeLiveMetrics(1600),
+    });
+
+    // Step 3: re-open /stats.
+    const records = await loadUsageHistory();
+    const report = aggregateUsage(records, 'all');
+
+    expect(report.sessionCount).toBe(1);
+    let totalTokens = 0;
+    for (const m of Object.values(report.models)) totalTokens += m.totalTokens;
+    expect(totalTokens).toBe(1600);
+  });
+});

packages/core/src/services/usageHistoryService.ts

@@ -173,7 +173,9 @@ export function metricsToUsageRecord(
   };
 }
 
-async function rebuildFromSessionJsonl(): Promise<UsageSummaryRecord[]> {
+async function rebuildFromSessionJsonl(
+  skipSessionInRebuild?: string,
+): Promise<UsageSummaryRecord[]> {
   const projectsDir = path.join(Storage.getGlobalQwenDir(), 'projects');
   try {
     if (!fs.existsSync(projectsDir)) return [];
@@ -261,23 +263,44 @@ async function rebuildFromSessionJsonl(): Promise<UsageSummaryRecord[]> {
   if (results.length > 0) {
     const usagePath = getUsageHistoryPath();
     for (const record of results) {
+      // Skip the in-progress current session: persistSessionUsage() will write
+      // its authoritative record on /clear or exit. Writing here would create
+      // a permanent duplicate in usage_record.jsonl (issue #4994).
+      if (skipSessionInRebuild && record.sessionId === skipSessionInRebuild)
+        continue;
       jsonl.writeLineSync(usagePath, record);
     }
   }
 
   return results;
 }
 
-export async function loadUsageHistory(): Promise<UsageSummaryRecord[]> {
+function dedupBySessionId(records: UsageSummaryRecord[]): UsageSummaryRecord[] {
+  // Last-wins by sessionId. Protects existing users whose usage_record.jsonl
+  // already contains duplicates produced by the bug fixed in this change
+  // (issue #4994) — without this, every aggregate stays inflated forever.
+  const map = new Map<string, UsageSummaryRecord>();
+  for (const r of records) map.set(r.sessionId, r);
+  if (map.size < records.length) {
+    debugLogger.debug(
+      `dedupBySessionId: removed ${records.length - map.size} duplicate record(s)`,
+    );
+  }
+  return [...map.values()];
+}
+
+export async function loadUsageHistory(
+  skipSessionInRebuild?: string,
+): Promise<UsageSummaryRecord[]> {
   try {
     const records = await jsonl.read<UsageSummaryRecord>(getUsageHistoryPath());
     const filtered = records.filter((r) => r.version === 1);
-    if (filtered.length > 0) return filtered;
+    if (filtered.length > 0) return dedupBySessionId(filtered);
   } catch (e) {
     debugLogger.debug(`loadUsageHistory: failed to read usage file: ${e}`);
   }
 
-  return rebuildFromSessionJsonl();
+  return dedupBySessionId(await rebuildFromSessionJsonl(skipSessionInRebuild));
 }
 
 export function getTimeRangeBounds(range: TimeRange): {