ccus-cli 0.1.19 → 0.1.22

package/dist/lib/aggregate.js

@@ -4,7 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadWeeklyExportBundles = loadWeeklyExportBundles;
+exports.computeCumulativeSevenDayCurve = computeCumulativeSevenDayCurve;
 exports.computeCumulativeSevenDay = computeCumulativeSevenDay;
+exports.deburrSevenDayEvents = deburrSevenDayEvents;
+exports.buildSevenDayCurveFromEvents = buildSevenDayCurveFromEvents;
 exports.buildPersonSevenDayCurve = buildPersonSevenDayCurve;
 exports.buildAggregatedDetailRows = buildAggregatedDetailRows;
 exports.buildAggregatedDailyRows = buildAggregatedDailyRows;
@@ -16,6 +19,10 @@ const node_zlib_1 = require("node:zlib");
 const payload_1 = require("./payload");
 const time_1 = require("./time");
 const gunzipAsync = (0, node_util_1.promisify)(node_zlib_1.gunzip);
+function maxOrNull(values) {
+    const numbers = values.filter((v) => v !== null);
+    return numbers.length > 0 ? Math.max(...numbers) : null;
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -91,20 +98,29 @@ async function readBundleFileContent(filePath) {
 /** 读取目录里的 export bundle json 文件。 */
 async function loadWeeklyExportBundles(inputDir) {
     const files = await collectBundleJsonFiles(inputDir);
-    const bundles = [];
     const invalidFiles = [];
-    for (const filePath of files) {
+    const results = await Promise.all(files.map(async (filePath) => {
         try {
             const content = await readBundleFileContent(filePath);
             const parsed = JSON.parse(content);
             if (isWeeklyExportBundle(parsed)) {
-                bundles.push({ filePath, bundle: parsed });
-                continue;
+                return { filePath, bundle: parsed };
             }
-            invalidFiles.push(filePath);
+            return { filePath, bundle: null };
         }
         catch {
+            return null;
+        }
+    }));
+    const bundles = [];
+    for (const result of results) {
+        if (result === null)
             continue;
+        if (result.bundle === null) {
+            invalidFiles.push(result.filePath);
+        }
+        else {
+            bundles.push({ filePath: result.filePath, bundle: result.bundle });
         }
     }
     if (invalidFiles.length > 0) {
@@ -140,31 +156,87 @@ function dayDataTier(day) {
         return 1;
     return 0;
 }
-/** winner 比较：数据质量等级高优先，同级别内 generatedAt 较新优先，最后用 filePath 做稳定 tie-break。 */
-function isBetterCandidate(nextTier, nextGeneratedAt, nextFilePath, currentTier, currentGeneratedAt, currentFilePath) {
+/**
+ * winner 比较：数据质量等级高优先；同 tier=2 時消息数多优先（避免"仅 generatedAt 更新"的低活跃机器
+ * 覆盖同一天高活跃机器的数据）；同 count 内 generatedAt 较新优先；最后用 filePath 做稳定 tie-break。
+ */
+function isBetterCandidate(nextTier, nextMsgCount, nextApiCount, nextGeneratedAt, nextFilePath, currentTier, currentMsgCount, currentApiCount, currentGeneratedAt, currentFilePath) {
     if (nextTier !== currentTier) {
         return nextTier > currentTier;
     }
+    if (nextTier === 2) {
+        if (nextMsgCount !== currentMsgCount) {
+            return nextMsgCount > currentMsgCount;
+        }
+        if (nextApiCount !== currentApiCount) {
+            return nextApiCount > currentApiCount;
+        }
+    }
     if (nextGeneratedAt !== currentGeneratedAt) {
         return nextGeneratedAt > currentGeneratedAt;
     }
     return nextFilePath > currentFilePath;
 }
-/** 对每个 (personKey, date) 选出 generatedAt 最新、且尽量有数据的那份 bundle 当天数据。 */
-function selectDailyWinners(bundles) {
-    const winners = new Map();
+/**
+ * 同一 (personKey, date) 的所有 bundle，按 rawEvents sessionId 集合的交集分组：
+ * - 有交集的视为同机器重复导出（同一账号同一天的会话在两份 bundle 里均存在），只取最优 winner
+ * - 无交集的视为不同机器的独立数据，分别保留，后续叠加
+ *
+ * sessionId 集合为空的候选（该天没有 statusline 事件）不参与交集判断，单独成组。
+ */
+function selectDailyRepresentatives(bundles) {
+    // 收集每个 (personKey, date) 的所有候选
+    const candidatesByKey = new Map();
     for (const { filePath, bundle } of bundles) {
         const personKey = bundlePersonKey(bundle);
         const generatedAt = bundle.generatedAt ?? "";
+        const eventsByDate = bundleEventsByDate(bundle);
         for (const day of bundle.dailySummaries) {
             const key = `${personKey}|${day.date}`;
-            const current = winners.get(key);
-            if (!current || isBetterCandidate(dayDataTier(day), generatedAt, filePath, dayDataTier(current.day), current.generatedAt, current.filePath)) {
-                winners.set(key, { personKey, date: day.date, day, bundle, generatedAt, filePath });
+            const events = eventsByDate.get(day.date) ?? [];
+            const sessionIds = new Set(events.map((e) => e.sessionId).filter((s) => s !== null));
+            const list = candidatesByKey.get(key) ?? [];
+            list.push({ day, bundle, generatedAt, filePath, sessionIds });
+            candidatesByKey.set(key, list);
+        }
+    }
+    const result = new Map();
+    for (const [key, candidates] of candidatesByKey.entries()) {
+        const barIdx = key.indexOf("|");
+        const personKey = key.slice(0, barIdx);
+        const date = key.slice(barIdx + 1);
+        // 贪心分组：候选有 sessionId 且与某组内任意候选的 sessionId 有交集，则并入该组；否则新建组
+        const groups = [];
+        for (const candidate of candidates) {
+            let added = false;
+            if (candidate.sessionIds.size > 0) {
+                for (const group of groups) {
+                    const hasOverlap = group.some((c) => c.sessionIds.size > 0 && [...candidate.sessionIds].some((s) => c.sessionIds.has(s)));
+                    if (hasOverlap) {
+                        group.push(candidate);
+                        added = true;
+                        break;
+                    }
+                }
+            }
+            if (!added) {
+                groups.push([candidate]);
             }
         }
+        // 每组取最优代表（同机器多次导出只保留一份）
+        const reps = groups.map((group) => {
+            let best = group[0];
+            for (let i = 1; i < group.length; i++) {
+                const c = group[i];
+                if (isBetterCandidate(dayDataTier(c.day), c.day.userMessageCount, c.day.apiRequestCount, c.generatedAt, c.filePath, dayDataTier(best.day), best.day.userMessageCount, best.day.apiRequestCount, best.generatedAt, best.filePath)) {
+                    best = c;
+                }
+            }
+            return { personKey, date, day: best.day, bundle: best.bundle };
+        });
+        result.set(key, reps);
     }
-    return winners;
+    return result;
 }
 /** 把 bundle 的 rawEvents 计算成 StatuslineEvent 并按本地自然日分组，结果做缓存复用。 */
 const bundleEventsCache = new WeakMap();
@@ -196,7 +268,8 @@ function bundleEventsByDate(bundle) {
  */
 const SEVEN_DAY_RESET_RATIO = 0.5;
 /**
- * 7 天额度累计真实使用量：对一组事件取非 null `sevenDayUsagePct`、按时间升序，用**分段峰谷和**还原。
+ * 7 天额度累计真实使用量的**逐点曲线**：对一组事件取非 null `sevenDayUsagePct`、按时间升序，用**分段峰谷和**
+ * 还原，并在每个样本处输出「截至此刻的累计值」，得到一条单调非递减曲线。
  *
  * 把曲线按 reset（样本跌破当前段峰值的 {@link SEVEN_DAY_RESET_RATIO}）切成若干上升段，
  * 每段贡献「段内峰值 − 段内谷值」，累计 = 各段贡献之和。等价于「正增量累加，但忽略未跌破段峰一半的小回落」。
@@ -205,21 +278,23 @@ const SEVEN_DAY_RESET_RATIO = 0.5;
  * 朴素累加会把每次上抖都计成真实增长，导致严重高估（实测 gaoshang 102 vs 分段 50）。
  * 分段峰谷和对抖动 / aging 回落鲁棒，又能正确累计「涨到峰 → 归零 → 再涨」的多段真实使用。
  *
- * 无有效样本返回 null（区别于 0：0 表示有样本但无净增长）；单样本返回 0。
+ * 每个点的累计 = 已锁定的各完整段贡献 + 当前段 (segMax − segMin)；段内更新 / reset 都不会让它回落，
+ * 所以曲线单调非递减、终点恒等于 {@link computeCumulativeSevenDay} 的标量返回值。输入建议先经 deburr 去毛刺。
+ * 无有效样本返回空数组；单样本返回单点 0。
  */
-function computeCumulativeSevenDay(events) {
-    const values = [...events]
-        .sort((left, right) => new Date(left.timestamp).getTime() - new Date(right.timestamp).getTime())
-        .map((event) => event.sevenDayUsagePct)
-        .filter((value) => value !== null);
-    if (values.length === 0) {
-        return null;
+function computeCumulativeSevenDayCurve(events) {
+    const sorted = [...events]
+        .filter((event) => event.sevenDayUsagePct !== null)
+        .sort((left, right) => new Date(left.timestamp).getTime() - new Date(right.timestamp).getTime());
+    if (sorted.length === 0) {
+        return [];
     }
+    const points = [{ timestamp: sorted[0].timestamp, cumulative: 0 }];
     let cumulative = 0;
-    let segMin = values[0];
-    let segMax = values[0];
-    for (let index = 1; index < values.length; index += 1) {
-        const value = values[index];
+    let segMin = sorted[0].sevenDayUsagePct;
+    let segMax = sorted[0].sevenDayUsagePct;
+    for (let index = 1; index < sorted.length; index += 1) {
+        const value = sorted[index].sevenDayUsagePct;
         if (value > segMax) {
             segMax = value;
         }
@@ -233,9 +308,18 @@ function computeCumulativeSevenDay(events) {
             // 段内小回落（抖动 / aging）：只更新谷值，不分段、不重复计数。
             segMin = value;
         }
+        points.push({ timestamp: sorted[index].timestamp, cumulative: (0, time_1.roundNumber)(cumulative + (segMax - segMin), 1) ?? 0 });
     }
-    cumulative += segMax - segMin;
-    return (0, time_1.roundNumber)(cumulative, 1);
+    return points;
+}
+/**
+ * 7 天额度累计真实使用量（标量）：取 {@link computeCumulativeSevenDayCurve} 曲线终点。
+ *
+ * 无有效样本返回 null（区别于 0：0 表示有样本但无净增长）；单样本返回 0。
+ */
+function computeCumulativeSevenDay(events) {
+    const curve = computeCumulativeSevenDayCurve(events);
+    return curve.length === 0 ? null : curve[curve.length - 1].cumulative;
 }
 /** 7d 曲线读数去毛刺的最小持续时长：短于此的中间读数段视为 stale / 瞬时异常。 */
 const SEVEN_DAY_MIN_HOLD_MS = 2 * 60 * 1000;
@@ -243,10 +327,14 @@ const SEVEN_DAY_MIN_HOLD_MS = 2 * 60 * 1000;
  * 7d 曲线读数去毛刺：真实 7d 信号变化慢、每个档位会被高频采样连续覆盖几十上百个样本，
  * 而 stale 缓存读数 / 瞬时异常只会短暂出现（秒级，如 baseline 很低时偶发跳到 30 又落回）。
  *
- * 把**中间**持续短于 {@link SEVEN_DAY_MIN_HOLD_MS} 的读数段（下一段起始 − 本段起始）替换为最近的已保留前值，
- * 抹掉这些尖峰；首尾段无条件保留（端点缺上下文判断持续性）。这等价于人眼在曲线图上自动忽略短毛刺。
+ * 把**中间**持续短于 {@link SEVEN_DAY_MIN_HOLD_MS} 的读数段替换为最近的已保留前值，抹掉这些尖峰；
+ * 首尾段无条件保留（端点缺上下文判断持续性）。这等价于人眼在曲线图上自动忽略短毛刺。
+ *
+ * 持续时长默认按「下一段起始 − 本段起始」度量（密集采样下约等于本段实际持续）；但当**多样本**段后面紧跟一段
+ * 比阈值还大的**采集间隙**时，该度量会把间隙也算进去、把只持续几十秒的短尖峰“撑”过阈值而漏抹，
+ * 此时改用**段内真实跨度（最后样本 − 第一样本）**判定。单样本段无段内跨度、无法据此判断，仍走原度量。
  *
- * 仅对密集采样的真实曲线生效：稀疏数据（每个值只有一两个样本、间隔很大）的中间段持续时长通常远超阈值，
+ * 仅对密集采样的真实曲线生效：稀疏数据（每个值只有一两个样本、间隔很大）的单样本中间段仍按原度量保留，
  * 不会被误删，所以 spec 的稀疏示例与单样本段不受影响。输入须按 timestamp 升序。
  */
 function deburrSevenDayEvents(events, minHoldMs = SEVEN_DAY_MIN_HOLD_MS) {
@@ -260,14 +348,28 @@ function deburrSevenDayEvents(events, minHoldMs = SEVEN_DAY_MIN_HOLD_MS) {
         while (end + 1 < events.length && events[end + 1].sevenDayUsagePct === events[index].sevenDayUsagePct) {
             end += 1;
         }
-        runs.push({ value: events[index].sevenDayUsagePct, startIdx: index, endIdx: end, startTime: new Date(events[index].timestamp).getTime() });
+        runs.push({
+            value: events[index].sevenDayUsagePct,
+            startIdx: index,
+            endIdx: end,
+            startTime: new Date(events[index].timestamp).getTime(),
+            endTime: new Date(events[end].timestamp).getTime(),
+        });
         index = end + 1;
     }
     const result = [...events];
     let lastKept = runs[0].value;
     for (let k = 0; k < runs.length; k += 1) {
         const isEdge = k === 0 || k === runs.length - 1;
-        const holdMs = k + 1 < runs.length ? runs[k + 1].startTime - runs[k].startTime : Number.POSITIVE_INFINITY;
+        // 默认持续时长 = 下一段起始 − 本段起始（密集采样下约等于本段实际持续）。
+        const toNext = k + 1 < runs.length ? runs[k + 1].startTime - runs[k].startTime : Number.POSITIVE_INFINITY;
+        // 本段最后样本到下一段起始的采集间隙：密集采样下很小，遇到数据采集中断时会变大。
+        const gapAfter = k + 1 < runs.length ? runs[k + 1].startTime - runs[k].endTime : Number.POSITIVE_INFINITY;
+        // 多样本段（段内本身有跨度）后面若紧跟一段比阈值还大的采集间隙，说明 toNext 把间隙也算进了持续时长，
+        // 会把本只持续几十秒的短尖峰“撑”过阈值而漏抹；此时改用段内真实跨度判定，正确识别这类 stale 尖峰。
+        // 单样本段（无段内跨度）无法据此判断真实持续，仍走 toNext，避免误伤稀疏单样本数据。
+        const multiSample = runs[k].endIdx > runs[k].startIdx;
+        const holdMs = multiSample && gapAfter > minHoldMs ? runs[k].endTime - runs[k].startTime : toNext;
         if (isEdge || holdMs >= minHoldMs) {
             lastKept = runs[k].value;
             continue;
@@ -278,6 +380,28 @@ function deburrSevenDayEvents(events, minHoldMs = SEVEN_DAY_MIN_HOLD_MS) {
     }
     return result;
 }
+/**
+ * 把一组事件整理成一条可用于累计计算的 7d 曲线：取非 null `sevenDayUsagePct`、按时间升序、
+ * 对完全相同 timestamp 去重，再做读数去毛刺。
+ *
+ * 单台机器的本地日志（dashboard 个人看板）与多机合并（aggregate）都走这同一套整理逻辑，
+ * 保证两边的累计口径不会漂移。
+ */
+function buildSevenDayCurveFromEvents(events) {
+    const sorted = [...events]
+        .filter((event) => event.sevenDayUsagePct !== null)
+        .sort((left, right) => new Date(left.timestamp).getTime() - new Date(right.timestamp).getTime());
+    const seen = new Set();
+    const deduped = [];
+    for (const event of sorted) {
+        if (seen.has(event.timestamp)) {
+            continue;
+        }
+        seen.add(event.timestamp);
+        deduped.push(event);
+    }
+    return deburrSevenDayEvents(deduped);
+}
 /**
  * 同一 personKey 的 7d 累计曲线：把该人**所有 bundle**（非仅 winner）的 rawEvents 计算成事件、
  * 取非 null `sevenDayUsagePct`、按 timestamp 升序合并、对完全相同 timestamp 去重，再做读数去毛刺，
@@ -311,17 +435,7 @@ function buildPersonSevenDayCurve(bundles) {
     }
     const curves = new Map();
     for (const [personKey, events] of collected.entries()) {
-        const sorted = [...events].sort((left, right) => new Date(left.timestamp).getTime() - new Date(right.timestamp).getTime());
-        const seen = new Set();
-        const deduped = [];
-        for (const event of sorted) {
-            if (seen.has(event.timestamp)) {
-                continue;
-            }
-            seen.add(event.timestamp);
-            deduped.push(event);
-        }
-        curves.set(personKey, deburrSevenDayEvents(deduped));
+        curves.set(personKey, buildSevenDayCurveFromEvents(events));
     }
     personSevenDayCurveCache.set(bundles, curves);
     return curves;
@@ -346,52 +460,72 @@ function recomputeUsage(events) {
         sevenDayLatestUsagePct: newestFirst.find((event) => event.sevenDayUsagePct !== null)?.sevenDayUsagePct ?? null,
     };
 }
-/** 从 winner bundle 的事件展开 detail.csv，同人同天只保留 winner，那份的当天 token 总量随行附带。 */
+/** 展开 detail.csv：同人同天各机器的代表 bundle 事件都列出来，token 总量随本机器当天的 daySummary 附带。 */
 function buildAggregatedDetailRows(bundles) {
-    const winners = selectDailyWinners(bundles);
+    const repsMap = selectDailyRepresentatives(bundles);
     const rows = [];
-    for (const winner of winners.values()) {
-        const events = bundleEventsByDate(winner.bundle).get(winner.date) ?? [];
-        for (const event of events) {
-            rows.push({
-                ...event,
-                personKey: winner.personKey,
-                weekKey: weekKey(new Date(event.timestamp)),
-                dateKey: winner.date,
-                inputTokens: winner.day.inputTokens,
-                outputTokens: winner.day.outputTokens,
-                cacheReadInputTokens: winner.day.cacheReadInputTokens,
-            });
+    for (const reps of repsMap.values()) {
+        for (const rep of reps) {
+            const events = bundleEventsByDate(rep.bundle).get(rep.date) ?? [];
+            for (const event of events) {
+                rows.push({
+                    ...event,
+                    personKey: rep.personKey,
+                    weekKey: weekKey(new Date(event.timestamp)),
+                    dateKey: rep.date,
+                    inputTokens: rep.day.inputTokens,
+                    outputTokens: rep.day.outputTokens,
+                    cacheReadInputTokens: rep.day.cacheReadInputTokens,
+                });
+            }
         }
     }
     return rows.sort((left, right) => left.timestamp.localeCompare(right.timestamp));
 }
-/** 展开 daily.csv：同人同天取 winner bundle 的累加值，usage 从该 bundle 当天事件重算。 */
+/**
+ * 展开 daily.csv：同人同天的不同机器数据直接叠加（计数字段相加），usage 从所有机器该天事件合并后重算。
+ * 同机器重复导出由 selectDailyRepresentatives 在分组阶段去重，不会翻倍。
+ */
 function buildAggregatedDailyRows(bundles) {
-    const winners = selectDailyWinners(bundles);
+    const repsMap = selectDailyRepresentatives(bundles);
     const curves = buildPersonSevenDayCurve(bundles);
     const rows = [];
-    for (const winner of winners.values()) {
-        const day = winner.day;
-        const usage = recomputeUsage(bundleEventsByDate(winner.bundle).get(winner.date) ?? []);
-        // 累计指标走全样本合并曲线，不走 winner 的 recomputeUsage，避免漏掉非 winner 机器的样本。
-        const sevenDayCumulativeUsagePct = computeCumulativeSevenDay(sliceCurveByDate(curves.get(winner.personKey) ?? [], winner.date));
+    for (const reps of repsMap.values()) {
+        const { personKey, date } = reps[0];
+        // 不同机器的独立数据直接叠加
+        const userMessageCount = reps.reduce((sum, r) => sum + r.day.userMessageCount, 0);
+        const apiRequestCount = reps.reduce((sum, r) => sum + r.day.apiRequestCount, 0);
+        const inputTokens = reps.reduce((sum, r) => sum + r.day.inputTokens, 0);
+        const outputTokens = reps.reduce((sum, r) => sum + r.day.outputTokens, 0);
+        const cacheReadInputTokens = reps.reduce((sum, r) => sum + r.day.cacheReadInputTokens, 0);
+        const sampleCount = reps.reduce((sum, r) => sum + r.day.sampleCount, 0);
+        const uniqueSessions = reps.reduce((sum, r) => sum + r.day.uniqueSessions, 0);
+        const uniqueWorkspaces = reps.reduce((sum, r) => sum + r.day.uniqueWorkspaces, 0);
+        // usage 从所有机器该天事件合并后重算；rawEvents 缺失时用各代表 daySummary 回退
+        const allEvents = reps.flatMap((r) => bundleEventsByDate(r.bundle).get(date) ?? []);
+        const usage = recomputeUsage(allEvents);
+        const fiveHourPeakFallback = maxOrNull(reps.map((r) => r.day.fiveHourPeakUsagePct));
+        const sevenDayPeakFallback = maxOrNull(reps.map((r) => r.day.sevenDayPeakUsagePct));
+        const fiveHourLatestFallback = reps.find((r) => r.day.fiveHourLatestUsagePct !== null)?.day.fiveHourLatestUsagePct ?? null;
+        const sevenDayLatestFallback = reps.find((r) => r.day.sevenDayLatestUsagePct !== null)?.day.sevenDayLatestUsagePct ?? null;
+        // 累计指标走全样本合并曲线，不走单机的 recomputeUsage，避免漏掉另一台机器的样本。
+        const sevenDayCumulativeUsagePct = computeCumulativeSevenDay(sliceCurveByDate(curves.get(personKey) ?? [], date));
         rows.push({
-            personKey: winner.personKey,
-            date: day.date,
-            userMessageCount: day.userMessageCount,
-            apiRequestCount: day.apiRequestCount,
-            inputTokens: day.inputTokens,
-            outputTokens: day.outputTokens,
-            cacheReadInputTokens: day.cacheReadInputTokens,
-            sampleCount: day.sampleCount,
-            fiveHourPeakUsagePct: usage.fiveHourPeakUsagePct ?? day.fiveHourPeakUsagePct,
-            fiveHourLatestUsagePct: usage.fiveHourLatestUsagePct ?? day.fiveHourLatestUsagePct,
-            sevenDayPeakUsagePct: usage.sevenDayPeakUsagePct ?? day.sevenDayPeakUsagePct,
-            sevenDayLatestUsagePct: usage.sevenDayLatestUsagePct ?? day.sevenDayLatestUsagePct,
+            personKey,
+            date,
+            userMessageCount,
+            apiRequestCount,
+            inputTokens,
+            outputTokens,
+            cacheReadInputTokens,
+            sampleCount,
+            fiveHourPeakUsagePct: usage.fiveHourPeakUsagePct ?? fiveHourPeakFallback,
+            fiveHourLatestUsagePct: usage.fiveHourLatestUsagePct ?? fiveHourLatestFallback,
+            sevenDayPeakUsagePct: usage.sevenDayPeakUsagePct ?? sevenDayPeakFallback,
+            sevenDayLatestUsagePct: usage.sevenDayLatestUsagePct ?? sevenDayLatestFallback,
             sevenDayCumulativeUsagePct,
-            uniqueSessions: day.uniqueSessions,
-            uniqueWorkspaces: day.uniqueWorkspaces,
+            uniqueSessions,
+            uniqueWorkspaces,
         });
     }
     return rows.sort((left, right) => `${left.personKey}|${left.date}`.localeCompare(`${right.personKey}|${right.date}`));
@@ -409,46 +543,47 @@ function fallbackWeeklyUsage(days) {
     };
 }
 /**
- * 展开 weekly.csv：一个人同一周有多份 bundle（多台电脑各导出）时，不取单独一份的整周汇总，
- * 而是复用按天去重后的 daily winner（每天选有数据的那份），按 (person, 周) 把每天的 token / 计数累加上卷，
- * usage 从该周所有 winner 天的事件重算（peak 取 max、latest 取时间戳最新），缺失时回退到 daySummary 自带值。
+ * 展开 weekly.csv：不同机器的同人同天数据已在 selectDailyRepresentatives 层按 sessionId 去重分组，
+ * 这里直接按 (person, 周) 把所有代表的 token / 计数累加上卷，usage 从该周所有代表事件重算。
  */
 function buildAggregatedWeeklyRows(bundles) {
-    const dailyWinners = selectDailyWinners(bundles);
+    const repsMap = selectDailyRepresentatives(bundles);
     const curves = buildPersonSevenDayCurve(bundles);
     const groups = new Map();
-    for (const winner of dailyWinners.values()) {
-        const week = weekKey(new Date(winner.bundle.range.start));
-        const key = `${winner.personKey}|${week}`;
-        let acc = groups.get(key);
-        if (!acc) {
-            acc = {
-                personKey: winner.personKey,
-                week,
-                userMessageCount: 0,
-                apiRequestCount: 0,
-                inputTokens: 0,
-                outputTokens: 0,
-                cacheReadInputTokens: 0,
-                sampleCount: 0,
-                uniqueSessions: 0,
-                uniqueWorkspaces: 0,
-                days: [],
-                events: [],
-            };
-            groups.set(key, acc);
+    for (const reps of repsMap.values()) {
+        for (const rep of reps) {
+            const week = weekKey(new Date(rep.bundle.range.start));
+            const key = `${rep.personKey}|${week}`;
+            let acc = groups.get(key);
+            if (!acc) {
+                acc = {
+                    personKey: rep.personKey,
+                    week,
+                    userMessageCount: 0,
+                    apiRequestCount: 0,
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    cacheReadInputTokens: 0,
+                    sampleCount: 0,
+                    uniqueSessions: 0,
+                    uniqueWorkspaces: 0,
+                    days: [],
+                    events: [],
+                };
+                groups.set(key, acc);
+            }
+            const day = rep.day;
+            acc.userMessageCount += day.userMessageCount;
+            acc.apiRequestCount += day.apiRequestCount;
+            acc.inputTokens += day.inputTokens;
+            acc.outputTokens += day.outputTokens;
+            acc.cacheReadInputTokens += day.cacheReadInputTokens;
+            acc.sampleCount += day.sampleCount;
+            acc.uniqueSessions += day.uniqueSessions;
+            acc.uniqueWorkspaces += day.uniqueWorkspaces;
+            acc.days.push(day);
+            acc.events.push(...(bundleEventsByDate(rep.bundle).get(rep.date) ?? []));
         }
-        const day = winner.day;
-        acc.userMessageCount += day.userMessageCount;
-        acc.apiRequestCount += day.apiRequestCount;
-        acc.inputTokens += day.inputTokens;
-        acc.outputTokens += day.outputTokens;
-        acc.cacheReadInputTokens += day.cacheReadInputTokens;
-        acc.sampleCount += day.sampleCount;
-        acc.uniqueSessions += day.uniqueSessions;
-        acc.uniqueWorkspaces += day.uniqueWorkspaces;
-        acc.days.push(day);
-        acc.events.push(...(bundleEventsByDate(winner.bundle).get(winner.date) ?? []));
     }
     const rows = [];
     for (const acc of groups.values()) {