ccus-cli 0.1.16 → 0.1.18

package/README.md

@@ -177,6 +177,10 @@ ccus aggregate serve --input-dir ./team-exports
   - `detail.csv`：来自 winner bundle 的 `rawEvents`（同人同天只展开最新那份的事件），`contextUsedM` / `contextMaxM` 为单条事件的 context window token；另附带 `inputTokensM` / `outputTokensM` / `cacheReadInputTokensM`（按 `date` 取自当天 `dailySummaries` 的日总量，同一天多行会重复，不能按行求和）
   - `daily.csv`：同人同天取最新导出 bundle 的 `dailySummaries`，usage 从该 bundle 当天事件重算
   - `weekly.csv`：把同人同周的各天 winner（已按天去重）上卷累加得到，usage 从该周全部 winner 天的事件重算
+- `daily.csv` / `weekly.csv` 还各带一列 `sevenDayCumulativeUsagePct`：7 天额度的**累计真实使用量**，把锯齿波（涨到峰值→窗口重置归零→再涨）还原成实际消耗。计算分两层：先**去毛刺**（把持续短于 2 分钟的 stale 瞬时读数尖峰抹平，只保留真实持续的水平），再做**分段峰谷和**（按 reset 跌破段峰值一半切成上升段，每段累加「段内峰值−谷值」）。以百分比累加表达、可大于 100（用掉多于一个 7d 额度）。对 ±1 采样抖动和 stale 读数尖峰都鲁棒，不会被噪声虚增
+  - 该列**绕开按天 winner**，对同一个人**所有机器、所有周**的 bundle `rawEvents` 先按时间合并去重成一条账号级曲线再算，绝不分机相加（同账号 7d 额度共享）
+  - 区间内第一个有效样本无前值、不贡献增量，所以 **`daily.csv` 逐行相加只是对全局总量的近似**（跨天边界增量不计入单天）；`weekly.csv` 在整周连续算、把跨天增量也计入，更连续，恒有 `weekly ≥ Σ 同周 daily`，想要更准的总量请看 weekly 这列
+  - 无有效样本写空（`null`），有样本但无净增长写 `0`；`detail.csv` 不含此列（单事件行不承载区间累计语义）
 - CSV 里所有以 token 计的列（context 与 in/out/cache）都以百万（M）为单位（原始值除以 1,000,000），列名统一带 `M` 后缀；`contextWindowPct` 仍是百分比
 - 想直接查看团队多人 dashboard，可以用 `ccus aggregate serve --input-dir DIR [--port 0] [--host 127.0.0.1]`：默认监听 `127.0.0.1` 上的随机端口，启动后会自动用系统默认浏览器打开，每次请求实时读取目录里的 bundle，不写入任何文件
 

package/dist/lib/aggregate-dashboard.js

@@ -31,7 +31,7 @@ function maxOrNull(values) {
  *
  * 这里只信任 daily.csv 的口径，确保数字和 aggregate 输出的 CSV 一致。
  */
-function summarizePeople(dailyRows) {
+function summarizePeople(dailyRows, weeklyRows = []) {
     const grouped = new Map();
     for (const row of dailyRows) {
         const items = grouped.get(row.personKey);
@@ -42,6 +42,15 @@ function summarizePeople(dailyRows) {
             grouped.set(row.personKey, [row]);
         }
     }
+    // 累计 7d 走 weekly.csv 同源：按 personKey 把各周 weekly 行的累计值相加（weekly ≥ Σ daily，不能用 daily 求和）。
+    const cumulativeByPerson = new Map();
+    for (const row of weeklyRows) {
+        if (row.sevenDayCumulativeUsagePct === null) {
+            continue;
+        }
+        const current = cumulativeByPerson.get(row.personKey);
+        cumulativeByPerson.set(row.personKey, (current ?? 0) + row.sevenDayCumulativeUsagePct);
+    }
     const summaries = [];
     for (const [personKey, items] of grouped.entries()) {
         const sortedByDate = [...items].sort((left, right) => left.date.localeCompare(right.date));
@@ -66,6 +75,7 @@ function summarizePeople(dailyRows) {
             fiveHourLatestUsagePct: latestRowWithUsage?.fiveHourLatestUsagePct ?? null,
             sevenDayPeakUsagePct: maxOrNull(items.map((row) => row.sevenDayPeakUsagePct)),
             sevenDayLatestUsagePct: latestRowWithSevenDay?.sevenDayLatestUsagePct ?? null,
+            sevenDayCumulativeUsagePct: cumulativeByPerson.get(personKey) ?? null,
             activeDays,
             firstDate: sortedByDate[0]?.date ?? null,
             lastDate: sortedByDate.at(-1)?.date ?? null,
@@ -175,13 +185,13 @@ function renderDailyUserRequestChart(people, dailyIndex, dateAxis) {
         const points = series.values
             .map((value, index) => `<circle cx="${xFor(index).toFixed(2)}" cy="${yFor(value).toFixed(2)}" r="3" fill="${color}"><title>${escapeHtml(series.person.personKey)} · ${escapeHtml(dateAxis[index])} · ${formatNumber(value)} 用户请求</title></circle>`)
             .join("");
-        return `<g><path d="${path}" fill="none" stroke="${color}" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" />${points}</g>`;
+        return `<g data-person="${escapeHtml(series.person.personKey)}"><path d="${path}" fill="none" stroke="${color}" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" />${points}</g>`;
     })
         .join("");
     const legend = seriesData
         .map((series, seriesIndex) => {
         const color = palette[seriesIndex % palette.length];
-        return `<span class="legend-chip"><span class="legend-dot" style="background:${color}"></span>${escapeHtml(series.person.personKey)}</span>`;
+        return `<span class="legend-chip legend-toggle" data-person="${escapeHtml(series.person.personKey)}"><span class="legend-dot" style="background:${color}"></span>${escapeHtml(series.person.personKey)}</span>`;
     })
         .join("");
     return `
@@ -191,7 +201,7 @@ function renderDailyUserRequestChart(people, dailyIndex, dateAxis) {
           <p class="eyebrow">Daily User Requests</p>
           <h2>每日用户请求数对比</h2>
         </div>
-        <p class="muted">基于每人 daily 汇总中的 userMessageCount（已剔除 tool_result 工具回填；sidechain 子 agent 提示保留）。</p>
+        <p class="muted">基于每人 daily 汇总中的 userMessageCount（已剔除 tool_result 工具回填；sidechain 子 agent 提示保留）。点击图例人名可只高亮该人曲线。</p>
       </div>
       <div class="legend">${legend}</div>
       <svg viewBox="0 0 ${width} ${height}" class="chart" role="img" aria-label="每日用户请求数对比">
@@ -203,24 +213,26 @@ function renderDailyUserRequestChart(people, dailyIndex, dateAxis) {
   `;
 }
 /**
- * 用横向条形图对比每个人的「周使用量（7 天额度）峰值」。
+ * 用横向条形图对比每个人的「周使用量（7 天额度）累计真实使用量」。
  *
- * 7 天额度是 Claude 给出的滚动周额度使用率，峰值代表这段时间里每个人最接近用满周额度的程度。
- * 条长按固定的 100% 满刻度归一，直接反映绝对使用率水平；右侧仍标注绝对百分比。
+ * sevenDayCumulativeUsagePct 把 7 天额度的锯齿波还原成区间内累计真实使用量，比峰值更能反映
+ * 一段时间里实际消耗了多少额度（峰值相同但累计可相差数倍）。条长默认按 100% 满刻度归一、
+ * 直接反映绝对使用率；仅当有人累计超过 100% 时才放大刻度到该最大值，避免超长条溢出。右侧仍
+ * 标注绝对累计百分比。
  */
-function renderSevenDayPeakChart(people) {
+function renderSevenDayCumulativeChart(people) {
     const ranked = people
-        .filter((person) => person.sevenDayPeakUsagePct !== null)
-        .sort((left, right) => (right.sevenDayPeakUsagePct ?? 0) - (left.sevenDayPeakUsagePct ?? 0));
+        .filter((person) => person.sevenDayCumulativeUsagePct !== null)
+        .sort((left, right) => (right.sevenDayCumulativeUsagePct ?? 0) - (left.sevenDayCumulativeUsagePct ?? 0));
     if (ranked.length === 0) {
         return `
       <section class="panel chart-panel">
         <div class="panel-header">
           <div>
-            <p class="eyebrow">Weekly Peak Usage</p>
-            <h2>周使用量峰值对比</h2>
+            <p class="eyebrow">Weekly Cumulative Usage</p>
+            <h2>周使用量累计对比</h2>
           </div>
-          <p class="muted">还没有 7 天额度使用率样本。</p>
+          <p class="muted">还没有 7 天额度累计使用量样本。</p>
         </div>
       </section>
     `;
@@ -234,10 +246,12 @@ function renderSevenDayPeakChart(people) {
     const height = paddingTop + paddingBottom + ranked.length * rowHeight;
     const trackX = labelWidth;
     const trackWidth = width - labelWidth - valueWidth - 16;
-    const maxValue = 100;
+    // 默认按 100% 满刻度，条长直接反映绝对使用率；仅当有人累计超过 100% 时才放大刻度到该最大值，
+    // 避免超长条溢出轨道。下限 100 同时兜底全 0 时的除零（条归零而非 NaN）。
+    const maxValue = Math.max(100, ...ranked.map((person) => person.sevenDayCumulativeUsagePct ?? 0));
     const bars = ranked
         .map((person, index) => {
-        const pct = person.sevenDayPeakUsagePct ?? 0;
+        const pct = person.sevenDayCumulativeUsagePct ?? 0;
         const rowTop = paddingTop + index * rowHeight;
         const barHeight = 18;
         const barY = rowTop + (rowHeight - barHeight) / 2;
@@ -256,12 +270,12 @@ function renderSevenDayPeakChart(people) {
     <section class="panel chart-panel">
       <div class="panel-header">
         <div>
-          <p class="eyebrow">Weekly Peak Usage</p>
-          <h2>周使用量峰值对比</h2>
+          <p class="eyebrow">Weekly Cumulative Usage</p>
+          <h2>周使用量累计对比</h2>
         </div>
-        <p class="muted">每个人 7 天额度使用率（sevenDayPeakUsagePct）的峰值，条越长越接近用满周额度。</p>
+        <p class="muted">每个人 7 天额度累计真实使用量（sevenDayCumulativeUsagePct），条越长累计消耗越多；默认按 100% 满刻度，仅当有人累计超过 100% 时才放大刻度到在场最大值。</p>
       </div>
-      <svg viewBox="0 0 ${width} ${height}" class="chart" role="img" aria-label="周使用量峰值对比">
+      <svg viewBox="0 0 ${width} ${height}" class="chart" role="img" aria-label="周使用量累计对比">
         ${bars}
       </svg>
     </section>
@@ -351,14 +365,14 @@ function renderFiveHourUsageChart(people, detailRows) {
         const sevenPath = entry.sevenPoints.length > 0
             ? `<path d="${pathFor(entry.sevenPoints)}" fill="none" stroke="${sevenColor}" stroke-width="2" stroke-dasharray="5 4" stroke-linecap="round" stroke-linejoin="round"><title>${escapeHtml(entry.person.personKey)} · 7d</title></path>`
             : "";
-        return `<g>${fivePath}${sevenPath}</g>`;
+        return `<g data-person="${escapeHtml(entry.person.personKey)}">${fivePath}${sevenPath}</g>`;
     })
         .join("");
     const legend = series
         .map((entry) => {
         const color = CHART_PALETTE[entry.index % CHART_PALETTE.length];
         const sevenColor = SEVEN_DAY_PALETTE[entry.index % SEVEN_DAY_PALETTE.length];
-        return `<span class="legend-chip"><span class="legend-dot" style="background:${color}"></span><span class="legend-dot" style="background:${sevenColor}"></span>${escapeHtml(entry.person.personKey)}</span>`;
+        return `<span class="legend-chip legend-toggle" data-person="${escapeHtml(entry.person.personKey)}"><span class="legend-dot" style="background:${color}"></span><span class="legend-dot" style="background:${sevenColor}"></span>${escapeHtml(entry.person.personKey)}</span>`;
     })
         .join("");
     return `
@@ -368,7 +382,7 @@ function renderFiveHourUsageChart(people, detailRows) {
           <p class="eyebrow">Usage Detail</p>
           <h2>5h / 7d 使用率详细曲线</h2>
         </div>
-        <p class="muted">每条 statusline 采样的 5 小时额度（实线）与 7 天周额度（对比色虚线）使用率，按真实时间戳绘制、共用 Y 轴。</p>
+        <p class="muted">每条 statusline 采样的 5 小时额度（实线）与 7 天周额度（对比色虚线）使用率，按真实时间戳绘制、共用 Y 轴。点击图例人名可只高亮该人曲线。</p>
       </div>
       <div class="legend">
         ${legend}
@@ -411,6 +425,7 @@ function renderPeopleLeaderboard(people) {
         <td>${escapeHtml(statValue(person.fiveHourLatestUsagePct))}</td>
         <td>${escapeHtml(statValue(person.sevenDayPeakUsagePct))}</td>
         <td>${escapeHtml(statValue(person.sevenDayLatestUsagePct))}</td>
+        <td>${escapeHtml(statValue(person.sevenDayCumulativeUsagePct))}</td>
         <td>${person.activeDays}</td>
         <td class="muted-col">${formatNumber(person.apiRequestCount)}</td>
       </tr>`)
@@ -438,6 +453,7 @@ function renderPeopleLeaderboard(people) {
               <th>5h Latest</th>
               <th>7d Peak</th>
               <th>7d Latest</th>
+              <th>7d 累计</th>
               <th>活跃天数</th>
               <th class="muted-col">API 请求</th>
             </tr>
@@ -517,6 +533,7 @@ function renderWeeklyTable(weeklyRows) {
         <td>${escapeHtml(statValue(row.fiveHourLatestUsagePct))}</td>
         <td>${escapeHtml(statValue(row.sevenDayPeakUsagePct))}</td>
         <td>${escapeHtml(statValue(row.sevenDayLatestUsagePct))}</td>
+        <td>${escapeHtml(statValue(row.sevenDayCumulativeUsagePct))}</td>
         <td class="muted-col">${formatNumber(row.apiRequestCount)}</td>
       </tr>`)
         .join("");
@@ -543,6 +560,7 @@ function renderWeeklyTable(weeklyRows) {
               <th>5h Latest</th>
               <th>7d Peak</th>
               <th>7d Latest</th>
+              <th>7d 累计</th>
               <th class="muted-col">API 请求</th>
             </tr>
           </thead>
@@ -558,7 +576,7 @@ function renderWeeklyTable(weeklyRows) {
  * 这是一份单文件静态页面，所有数据已经内联，可直接打开或拷贝分享。
  */
 function buildAggregateDashboardHtml(detailRows, dailyRows, weeklyRows, generatedAt = new Date()) {
-    const people = summarizePeople(dailyRows);
+    const people = summarizePeople(dailyRows, weeklyRows);
     const overall = summarizeOverall(dailyRows, people);
     const dateAxis = collectDateAxis(dailyRows);
     const dailyIndex = indexDailyRows(dailyRows);
@@ -678,7 +696,14 @@ function buildAggregateDashboardHtml(detailRows, dailyRows, weeklyRows, generate
         font-size: 13px;
       }
       .legend-chip { display: inline-flex; align-items: center; gap: 8px; }
+      .legend-toggle { cursor: pointer; user-select: none; transition: opacity 0.15s ease; }
+      .legend-toggle:hover { color: var(--text); }
+      .legend-toggle.is-active { color: var(--text); font-weight: 600; }
+      .legend-toggle.is-dimmed { opacity: 0.4; }
       .legend-dot { display: inline-block; width: 10px; height: 10px; border-radius: 50%; }
+      svg [data-person] { transition: opacity 0.15s ease; }
+      svg [data-person].is-dimmed { opacity: 0.1; }
+      svg [data-person].is-active { opacity: 1; }
       .legend-line { display: inline-block; width: 22px; height: 0; border-top-width: 2px; border-top-style: solid; border-top-color: var(--muted); }
       .legend-line-dashed { border-top-style: dashed; }
       .table-panel { margin-top: 22px; }
@@ -762,12 +787,32 @@ function buildAggregateDashboardHtml(detailRows, dailyRows, weeklyRows, generate
         </article>
       </section>
       ${renderPeopleLeaderboard(people)}
-      ${renderSevenDayPeakChart(people)}
+      ${renderSevenDayCumulativeChart(people)}
       ${renderFiveHourUsageChart(people, detailRows)}
       ${renderDailyUserRequestChart(people, dailyIndex, dateAxis)}
       ${renderDailyMatrix(people, dailyIndex, dateAxis)}
       ${renderWeeklyTable(weeklyRows)}
     </main>
+    <script>
+      (function () {
+        // 点击图例里的人名：高亮该人在所有图表里的曲线，其余淡化；再次点击同名取消高亮。
+        var active = null;
+        function apply() {
+          document.querySelectorAll("[data-person]").forEach(function (el) {
+            el.classList.remove("is-active", "is-dimmed");
+            if (active === null) return;
+            el.classList.add(el.getAttribute("data-person") === active ? "is-active" : "is-dimmed");
+          });
+        }
+        document.querySelectorAll(".legend-toggle").forEach(function (chip) {
+          chip.addEventListener("click", function () {
+            var person = chip.getAttribute("data-person");
+            active = active === person ? null : person;
+            apply();
+          });
+        });
+      })();
+    </script>
   </body>
 </html>`;
 }

package/dist/lib/aggregate.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadWeeklyExportBundles = loadWeeklyExportBundles;
+exports.computeCumulativeSevenDay = computeCumulativeSevenDay;
+exports.buildPersonSevenDayCurve = buildPersonSevenDayCurve;
 exports.buildAggregatedDetailRows = buildAggregatedDetailRows;
 exports.buildAggregatedDailyRows = buildAggregatedDailyRows;
 exports.buildAggregatedWeeklyRows = buildAggregatedWeeklyRows;
@@ -186,6 +188,152 @@ function bundleEventsByDate(bundle) {
     bundleEventsCache.set(bundle, byDate);
     return byDate;
 }
+/**
+ * 7d 曲线判定额度重置（reset）的阈值：某样本跌到「当前段峰值 × 此比例」及以下时视为一次归零重置，开启新段。
+ *
+ * 真实 7d 曲线在每个档位附近会 ±1 抖动、并随滚动窗口小幅回落（aging），这些都不该被当成新使用量。
+ * 只有跌破段峰值一半才算真正的额度重置；0.4 / 0.5 / 0.6 对实测数值几乎不敏感，取中间值 0.5。
+ */
+const SEVEN_DAY_RESET_RATIO = 0.5;
+/**
+ * 7 天额度累计真实使用量：对一组事件取非 null `sevenDayUsagePct`、按时间升序，用**分段峰谷和**还原。
+ *
+ * 把曲线按 reset（样本跌破当前段峰值的 {@link SEVEN_DAY_RESET_RATIO}）切成若干上升段，
+ * 每段贡献「段内峰值 − 段内谷值」，累计 = 各段贡献之和。等价于「正增量累加，但忽略未跌破段峰一半的小回落」。
+ *
+ * 之所以不用朴素的 `Σ max(0, uᵢ − uᵢ₋₁)`：实测 7d 信号在同一档位反复 ±1 抖动（采样毛刺），
+ * 朴素累加会把每次上抖都计成真实增长，导致严重高估（实测 gaoshang 102 vs 分段 50）。
+ * 分段峰谷和对抖动 / aging 回落鲁棒，又能正确累计「涨到峰 → 归零 → 再涨」的多段真实使用。
+ *
+ * 无有效样本返回 null（区别于 0：0 表示有样本但无净增长）；单样本返回 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;
+    }
+    let cumulative = 0;
+    let segMin = values[0];
+    let segMax = values[0];
+    for (let index = 1; index < values.length; index += 1) {
+        const value = values[index];
+        if (value > segMax) {
+            segMax = value;
+        }
+        else if (segMax > 0 && value <= segMax * SEVEN_DAY_RESET_RATIO) {
+            // 跌破段峰一半：判定为额度重置，锁定上一段峰谷差，从该点开启新段。
+            cumulative += segMax - segMin;
+            segMin = value;
+            segMax = value;
+        }
+        else if (value < segMin) {
+            // 段内小回落（抖动 / aging）：只更新谷值，不分段、不重复计数。
+            segMin = value;
+        }
+    }
+    cumulative += segMax - segMin;
+    return (0, time_1.roundNumber)(cumulative, 1);
+}
+/** 7d 曲线读数去毛刺的最小持续时长：短于此的中间读数段视为 stale / 瞬时异常。 */
+const SEVEN_DAY_MIN_HOLD_MS = 2 * 60 * 1000;
+/**
+ * 7d 曲线读数去毛刺：真实 7d 信号变化慢、每个档位会被高频采样连续覆盖几十上百个样本，
+ * 而 stale 缓存读数 / 瞬时异常只会短暂出现（秒级，如 baseline 很低时偶发跳到 30 又落回）。
+ *
+ * 把**中间**持续短于 {@link SEVEN_DAY_MIN_HOLD_MS} 的读数段（下一段起始 − 本段起始）替换为最近的已保留前值，
+ * 抹掉这些尖峰；首尾段无条件保留（端点缺上下文判断持续性）。这等价于人眼在曲线图上自动忽略短毛刺。
+ *
+ * 仅对密集采样的真实曲线生效：稀疏数据（每个值只有一两个样本、间隔很大）的中间段持续时长通常远超阈值，
+ * 不会被误删，所以 spec 的稀疏示例与单样本段不受影响。输入须按 timestamp 升序。
+ */
+function deburrSevenDayEvents(events, minHoldMs = SEVEN_DAY_MIN_HOLD_MS) {
+    if (events.length <= 2) {
+        return events;
+    }
+    const runs = [];
+    let index = 0;
+    while (index < events.length) {
+        let end = index;
+        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() });
+        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;
+        if (isEdge || holdMs >= minHoldMs) {
+            lastKept = runs[k].value;
+            continue;
+        }
+        for (let idx = runs[k].startIdx; idx <= runs[k].endIdx; idx += 1) {
+            result[idx] = { ...result[idx], sevenDayUsagePct: lastKept };
+        }
+    }
+    return result;
+}
+/**
+ * 同一 personKey 的 7d 累计曲线：把该人**所有 bundle**（非仅 winner）的 rawEvents 计算成事件、
+ * 取非 null `sevenDayUsagePct`、按 timestamp 升序合并、对完全相同 timestamp 去重，再做读数去毛刺，
+ * 得到一条账号级曲线。
+ *
+ * 走全样本而非 winner，是因为累计指标是同一条共享额度曲线的密集采样：只取 winner 会漏掉非 winner
+ * 机器的样本（曲线稀疏、累计偏小），分机各自累计再相加又会翻倍。结果按 bundles 数组缓存复用。
+ */
+const personSevenDayCurveCache = new WeakMap();
+function buildPersonSevenDayCurve(bundles) {
+    const cached = personSevenDayCurveCache.get(bundles);
+    if (cached) {
+        return cached;
+    }
+    const collected = new Map();
+    for (const { bundle } of bundles) {
+        const personKey = bundlePersonKey(bundle);
+        for (const record of bundle.rawEvents.filter(isPersistedStatuslineEvent)) {
+            const event = (0, payload_1.computeStatuslineEvent)(record);
+            if (event.sevenDayUsagePct === null) {
+                continue;
+            }
+            const list = collected.get(personKey);
+            if (list) {
+                list.push(event);
+            }
+            else {
+                collected.set(personKey, [event]);
+            }
+        }
+    }
+    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));
+    }
+    personSevenDayCurveCache.set(bundles, curves);
+    return curves;
+}
+/** 从合并曲线里切出某自然日的子序列。 */
+function sliceCurveByDate(curve, date) {
+    return curve.filter((event) => localDateKey(new Date(event.timestamp)) === date);
+}
+/** 从合并曲线里切出某周（周起始日 key）的子序列。 */
+function sliceCurveByWeek(curve, week) {
+    return curve.filter((event) => weekKey(new Date(event.timestamp)) === week);
+}
 /** 从一组事件按真实时间戳重算 5h / 7d 的 peak（max）与 latest（时间戳最新非空）。 */
 function recomputeUsage(events) {
     const newestFirst = [...events].sort((left, right) => new Date(right.timestamp).getTime() - new Date(left.timestamp).getTime());
@@ -221,10 +369,13 @@ function buildAggregatedDetailRows(bundles) {
 /** 展开 daily.csv：同人同天取 winner bundle 的累加值，usage 从该 bundle 当天事件重算。 */
 function buildAggregatedDailyRows(bundles) {
     const winners = selectDailyWinners(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));
         rows.push({
             personKey: winner.personKey,
             date: day.date,
@@ -238,6 +389,7 @@ function buildAggregatedDailyRows(bundles) {
             fiveHourLatestUsagePct: usage.fiveHourLatestUsagePct ?? day.fiveHourLatestUsagePct,
             sevenDayPeakUsagePct: usage.sevenDayPeakUsagePct ?? day.sevenDayPeakUsagePct,
             sevenDayLatestUsagePct: usage.sevenDayLatestUsagePct ?? day.sevenDayLatestUsagePct,
+            sevenDayCumulativeUsagePct,
             uniqueSessions: day.uniqueSessions,
             uniqueWorkspaces: day.uniqueWorkspaces,
         });
@@ -263,6 +415,7 @@ function fallbackWeeklyUsage(days) {
  */
 function buildAggregatedWeeklyRows(bundles) {
     const dailyWinners = selectDailyWinners(bundles);
+    const curves = buildPersonSevenDayCurve(bundles);
     const groups = new Map();
     for (const winner of dailyWinners.values()) {
         const week = weekKey(new Date(winner.bundle.range.start));
@@ -301,6 +454,8 @@ function buildAggregatedWeeklyRows(bundles) {
     for (const acc of groups.values()) {
         const usage = recomputeUsage(acc.events);
         const fallback = fallbackWeeklyUsage(acc.days);
+        // 整周累计：在整周合并曲线上一次性求正增量，跨天边界增量被计入，故 weekly ≥ Σ daily。
+        const sevenDayCumulativeUsagePct = computeCumulativeSevenDay(sliceCurveByWeek(curves.get(acc.personKey) ?? [], acc.week));
         rows.push({
             personKey: acc.personKey,
             week: acc.week,
@@ -314,6 +469,7 @@ function buildAggregatedWeeklyRows(bundles) {
             fiveHourLatestUsagePct: usage.fiveHourLatestUsagePct ?? fallback.fiveHourLatestUsagePct,
             sevenDayPeakUsagePct: usage.sevenDayPeakUsagePct ?? fallback.sevenDayPeakUsagePct,
             sevenDayLatestUsagePct: usage.sevenDayLatestUsagePct ?? fallback.sevenDayLatestUsagePct,
+            sevenDayCumulativeUsagePct,
             uniqueSessions: acc.uniqueSessions,
             uniqueWorkspaces: acc.uniqueWorkspaces,
         });

package/dist/lib/export.js

@@ -214,6 +214,7 @@ function buildAggregatedDailyCsv(rows) {
         "fiveHourLatestUsagePct",
         "sevenDayPeakUsagePct",
         "sevenDayLatestUsagePct",
+        "sevenDayCumulativeUsagePct",
         "uniqueSessions",
         "uniqueWorkspaces",
     ];
@@ -230,6 +231,7 @@ function buildAggregatedDailyCsv(rows) {
         row.fiveHourLatestUsagePct,
         row.sevenDayPeakUsagePct,
         row.sevenDayLatestUsagePct,
+        row.sevenDayCumulativeUsagePct,
         row.uniqueSessions,
         row.uniqueWorkspaces,
     ]));
@@ -250,6 +252,7 @@ function buildAggregatedWeeklyCsv(rows) {
         "fiveHourLatestUsagePct",
         "sevenDayPeakUsagePct",
         "sevenDayLatestUsagePct",
+        "sevenDayCumulativeUsagePct",
         "uniqueSessions",
         "uniqueWorkspaces",
     ];
@@ -266,6 +269,7 @@ function buildAggregatedWeeklyCsv(rows) {
         row.fiveHourLatestUsagePct,
         row.sevenDayPeakUsagePct,
         row.sevenDayLatestUsagePct,
+        row.sevenDayCumulativeUsagePct,
         row.uniqueSessions,
         row.uniqueWorkspaces,
     ]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccus-cli",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Claude Code statusline usage logger and dashboard CLI",
   "type": "commonjs",
   "bin": {