@leonhardthust/dsh-decision-engine 1.13.0 → 1.14.0

package/config.example.yml

@@ -424,7 +424,8 @@ guardFallbackReasoningEffort: ""
 #
 #   off      完全关闭：一个请求都不发
 #   install  仅首次运行上报一次「装了」，之后不再联网
-#   daily    每天上报一次，附带当日决策数（默认）
+#   daily    每天上报一次**上一完整自然日**的决策数（默认；跨日由 6 小时一次
+#            的检查补报，长驻进程不会漏掉）
 #
 # telemetryLevel: daily
 # telemetryEndpoint: ""     # 留空用内置端点

package/docs/releasing.md

@@ -1,6 +1,6 @@
 # npm 发布
 
-发布目标：`@leonhardthust/dsh-decision-engine`，当前版本 `1.13.0`，公开包。
+发布目标：`@leonhardthust/dsh-decision-engine`，当前版本 `1.14.0`，公开包。
 
 本分支基于 `zuosus/dsh-decision-engine` 的 MIT 代码，保留原作者与许可证；npm scope、源码仓库、bundle 引用和浏览器主模块 / charts chunk 标识已同步为本分支身份。内部 API、样式标识和用户数据目录保留旧名称以兼容已有配置。不要同时启用原包与本 scoped fork，它们提供相同的服务与页面。
 
@@ -9,7 +9,7 @@
 - `.github/workflows/ci.yml`：main push、PR、手动运行或发布工作流复用；Ubuntu 24.04 + Node.js 24 + Vite+ 1.6.0。执行 frozen install、完整测试与接线、隔离情景、实际打包和 tarball 检查。失败不会被忽略。
 - `.github/workflows/publish.yml`：每次 `main` push 自动检测版本。先比较整个 push 的 `before` 与当前 manifest，拒绝错误包名、非法或倒退版本；再只读查询 npmjs。当前版本已上传则跳过；当前版本高于 npmjs latest 且未上传则进入完整验证及发布。多提交 push 比较整个 push 前后，不仅比较 HEAD 的父提交。
 - 后续发版只需修改 `package.json` 版本并提交到 main；无需创建 tag 或手动点运行。发布依赖检测和本次提交的完整 CI 均成功，不跳过测试。稳定版本发布到 `latest`，预发布版本自动进入 `next`。
-- 当前 `1.13.0` 包含 DEC-074：匿名使用统计的用途/字段/边界重写；连通性测试从页脚前移到连接方式组，同时探测决策端点与回退语言模型，结果按链路分卡展示（摘要 + 可折叠详情）。`1.12.0` 的 DEC-072 / DEC-073、`1.11.2` 的 never 回退、`1.11.1` 的 DEC-070、`1.11.0` 的审计修复、`1.10.0` 的五项改动依次见 DEC-062 ~ DEC-073。
+- 当前 `1.14.0` 包含 DEC-075：统计账本修复——output token 未知值单独计数（不再当 0）、attempts/requests/degraded 分桶与汇总对账、匿名心跳改报上一完整自然日并按 `day` 归档、删除缓存基线的区间均值插补、节省量明确为「决策请求层估算」、安全拦截只按 authorize 统计。`1.13.0` 的 DEC-074、`1.12.0` 的 DEC-072/073、`1.11.2` 的 never 回退、`1.11.1` 的 DEC-070、`1.11.0` 的审计修复、`1.10.0` 的五项改动依次见 DEC-062 ~ DEC-074。
 - checkout 与 setup-vp Action 固定到已核对的 commit SHA；不通过 `pull_request_target` 运行不可信 PR。
 - 验证任务只有 `contents: read`；只有发布 job 有 `id-token: write`。发布 step 只使用 OIDC（trusted publishing），不再读取任何 npm token secret。代码 checkout 不保留 Git 凭据。此工作流不会自动修改版本、提交源码或推送 Git。
 
@@ -58,7 +58,7 @@ Windows 全量测试最近仍有 3 个既有 POSIX 文件权限断言失败；
 授权及完整验证均满足后：
 
 ```powershell
-npm publish ./release-artifacts/leonhardthust-dsh-decision-engine-1.13.0.tgz --registry "https://registry.npmjs.org/" --access public --tag latest
+npm publish ./release-artifacts/leonhardthust-dsh-decision-engine-1.14.0.tgz --registry "https://registry.npmjs.org/" --access public --tag latest
 npm view @leonhardthust/dsh-decision-engine version --registry "https://registry.npmjs.org/" --json
 ```
 
@@ -66,4 +66,4 @@ npm view @leonhardthust/dsh-decision-engine version --registry "https://registry
 
 ## 安装
 
-DSH 插件管理中使用 `@leonhardthust/dsh-decision-engine` 或指定 `@leonhardthust/dsh-decision-engine@1.13.0`。安装和启用是另外的用户动作，发布工作流不会修改本机 DSH profile。
+DSH 插件管理中使用 `@leonhardthust/dsh-decision-engine` 或指定 `@leonhardthust/dsh-decision-engine@1.14.0`。安装和启用是另外的用户动作，发布工作流不会修改本机 DSH profile。

package/lib/client.js

@@ -146,7 +146,7 @@ window.__ModuleLoader__.load({
       // —— 匿名使用统计（DEC-020）——
       "匿名使用统计": "Anonymous usage stats",
       "每天上报一次：匿名安装 id、版本、平台与当日决策数": "Reports once a day: anonymous install id, version, platform, and today's decision count",
-      "每天一次，只用于让作者判断插件还有多少人在用、值不值得继续维护：随机安装 ID、插件版本、平台/架构、宿主版本、当天决策次数。不含会话内容、文件路径、密钥、模型名或身份信息。": "Once a day, used only so the author can tell how many people still use the plugin and whether it is worth maintaining: a random install ID, plugin version, platform/arch, host version, and today's decision count. No conversation content, file paths, keys, model names, or identity information.",
+      "每天一次，只用于让作者判断插件还有多少人在用、值不值得继续维护：随机安装 ID、插件版本、平台/架构、宿主版本、上一完整自然日的决策次数。不含会话内容、文件路径、密钥、模型名或身份信息。": "Once a day, used only so the author can tell how many people still use the plugin and whether it is worth maintaining: a random install ID, plugin version, platform/arch, host version, and the previous complete day's decision count. No conversation content, file paths, keys, model names, or identity information.",
       "已关闭：任何情况下都不联网": "Off: never touches the network",
       "完全关闭：不发送任何请求。": "Fully off: no request is ever sent.",
       "仅首次运行上报一次「安装了」，之后不再联网": "Reports \"installed\" once on first run, then never again",
@@ -282,6 +282,11 @@ window.__ModuleLoader__.load({
       "节省比例（观察）": "Savings ratio (observe)",
       // —— 页面标题与说明 ——
       "用量统计与对比": "Usage & comparison",
+      "估算节省率": "Estimated savings rate",
+      "尝试 / 回答 / 降级": "Attempts / answered / degraded",
+      "决策请求估算节省率（观察）": "Estimated decision-request savings rate (observe)",
+      "口径：决策请求层面的估算（缓存去重 + 输入处理），不含主 Agent、子代理、工具调用与上下文压缩的成本变化；完整 Agent 净节省需要同任务配对 A/B，本页不提供。": "Scope: an estimate at the decision-request layer (cache dedupe + input processing). It excludes cost changes in the main agent, subagents, tool calls and context compaction; full agent net savings require a paired A/B and are not shown here.",
+      "安全口径：拦截率只按 authorize 点统计（本区间拒绝 {n} 次）；其它点的 reject {m} 次属于流程优化，未计入。": "Safety scope: the block rate counts only the authorize point ({n} rejections here). The {m} rejections from other points are workflow optimizations and are not counted.",
       "重新读取": "Reload",
       "按 provider × model 独立统计；区间为左闭右开，相邻范围不会重复计入。": "Counted separately per provider × model; ranges are half-open, so adjacent ranges never double-count.",
       "节省量只统计「观察」模式。": "Savings count only \"observe\" mode.",
@@ -5506,7 +5511,7 @@ window.__ModuleLoader__.load({
         { key: "savedOutputTokens", label: "省 output" },
         { key: "observeDurationMs", label: "实际耗时（观察）", actual: true },
         { key: "savedDurationMs", label: "省耗时" },
-        { key: "savedRatio", label: "节省比例" },
+        { key: "savedRatio", label: "估算节省率" },
       ];
 
       /**
@@ -5529,10 +5534,19 @@ window.__ModuleLoader__.load({
         totals === null
           ? []
           : [
-              { label: "请求次数", value: groupDigits(totals.requests) },
+              { label: "尝试 / 回答 / 降级", value: `${groupDigits(totals.attempts ?? totals.requests)} / ${groupDigits(totals.requests)} / ${groupDigits(totals.degraded)}` },
               { label: "命中缓存", value: groupDigits(totals.cached) },
               { label: "input token", value: groupDigits(totals.inputTokens) },
-              { label: "output token", value: groupDigits(totals.outputTokens) },
+              {
+                label: "output token",
+                // 未知值不进入总量（详见 lib/stats.js）：这里必须把未计量条数
+                // 说出来，否则读者会把「已知部分」当成全部。
+                value:
+                  groupDigits(totals.outputTokens) +
+                  ((totals.outputTokensUnmeasured ?? 0) > 0
+                    ? `（${groupDigits(totals.outputTokensUnmeasured)} 条未计量）`
+                    : ""),
+              },
               { label: "总耗时", value: formatMs(totals.durationMs) },
               // 写清「真实请求」：缓存命中的耗时是 0，混进分母会让这个
               // 数字随命中率变好看，读的人以为请求变快了。
@@ -5552,7 +5566,7 @@ window.__ModuleLoader__.load({
                 saved: true,
               },
               { label: "省时间（观察）", value: formatMs(totals.savedDurationMs), saved: true },
-              { label: "节省比例（观察）", value: formatRatio(totals.savedRatio), saved: true },
+              { label: "决策请求估算节省率（观察）", value: formatRatio(totals.savedRatio), saved: true },
             ];
 
       return h(
@@ -5610,6 +5624,20 @@ window.__ModuleLoader__.load({
                 h("strong", null, "节省量只统计「观察」模式。"),
                 " 观察模式下决策模型只记录、不改变行为，于是同一批工作既有普通 LLM 的实际消耗，也有决策模型「本该怎么跑」的结果——两者比的是同一批活，这个对比才成立。「生效」模式下普通 LLM 路径并没有真的发生，「省了多少」只能是事后估算，因此不计入。",
               ),
+              // 口径边界（审计 P1）：这是「决策请求层面」的估算，不是 Agent
+              // 端到端净节省。不写清楚，读者会把 80% 当成「整个任务省了 80%」。
+              h(
+                "div",
+                { style: { marginTop: "4px" } },
+                "口径：决策请求层面的估算（缓存去重 + 输入处理），不含主 Agent、子代理、工具调用与上下文压缩的成本变化；完整 Agent 净节省需要同任务配对 A/B，本页不提供。",
+              ),
+              Number(stats?.estimatedBaselineMissing ?? 0) > 0
+                ? h(
+                    "div",
+                    { style: { marginTop: "4px" } },
+                    `另有 ${groupDigits(stats.estimatedBaselineMissing)} 条历史缓存命中缺少基线，未计入节省（不再用同区间均值插补，避免时间泄漏与结果不可加）。`,
+                  )
+                : null,
               savingsUnavailable
                 ? h(
                     "div",
@@ -6273,6 +6301,16 @@ window.__ModuleLoader__.load({
                 { style: { marginTop: "6px" } },
                 "基线 = 不启用本插件的缓存与上下文压缩时，同样的工作本应消耗的 token 与时间。节省量相对基线计算（比例的分母是基线）；没有可归因的优化时节省量为 0。平均耗时按**真实请求**计算，不含缓存命中（那一次根本没发请求）。思考模式（think_mode）是用户配置而非插件优化，刻意不计入节省。",
               ),
+              stats.safety !== undefined
+                ? h(
+                    "div",
+                    { style: { marginTop: "6px" } },
+                    t("安全口径：拦截率只按 authorize 点统计（本区间拒绝 {n} 次）；其它点的 reject {m} 次属于流程优化，未计入。", {
+                      n: groupDigits(stats.safety.reject ?? 0),
+                      m: groupDigits(stats.safety.otherPointRejects ?? 0),
+                    }),
+                  )
+                : null,
               /**
                * 模式分账：让用户一眼看出「节省为 0」的原因。
                *
@@ -8779,7 +8817,7 @@ window.__ModuleLoader__.load({
           // 与下拉的兜底保持一致：undefined 时下拉显示 daily，说明也必须说 daily，
           // 否则首帧会出现「选中的是 daily、解释却写仅首次」的自相矛盾。
           (draft.telemetryLevel ?? "daily") === "daily"
-            ? t("每天一次，只用于让作者判断插件还有多少人在用、值不值得继续维护：随机安装 ID、插件版本、平台/架构、宿主版本、当天决策次数。不含会话内容、文件路径、密钥、模型名或身份信息。")
+            ? t("每天一次，只用于让作者判断插件还有多少人在用、值不值得继续维护：随机安装 ID、插件版本、平台/架构、宿主版本、上一完整自然日的决策次数。不含会话内容、文件路径、密钥、模型名或身份信息。")
             : draft.telemetryLevel === "off"
               ? t("完全关闭：不发送任何请求。")
               : t("仅在第一次运行时上报一次「安装了」（字段同上），之后不再联网。"),

package/lib/index.js

@@ -2221,9 +2221,11 @@ class StartluxClient {
     const apiInputTokens = typeof usage.input_tokens === "number" ? usage.input_tokens : undefined;
     const apiOutputTokens = typeof usage.output_tokens === "number" ? usage.output_tokens : undefined;
     const inputSource = apiInputTokens === undefined ? "estimated" : "api";
-    const outputSource = apiOutputTokens === undefined ? "estimated" : "api";
+    // output token 没有估算器：缺了就是**未知**，不能写成 0 还标 estimated。
+    // 写成 0 会把「不知道」伪装成「测得 0」，总量被系统性低估（审计 P0-1）。
+    const outputSource = apiOutputTokens === undefined ? "missing" : "api";
     const inputTokens = apiInputTokens ?? estimateRequestTokens(bodyText);
-    const outputTokens = apiOutputTokens ?? 0;
+    const outputTokens = apiOutputTokens ?? null;
     const result = {
       answers,
       model: typeof body.model === "string" ? body.model : model || "(server-default)",
@@ -2242,10 +2244,11 @@ class StartluxClient {
       outputTokens: apiOutputTokens,
       inputSource,
       outputSource,
-      // 统计用的 token 数（含估算）。与上面的「API 原始值」分开存：
-      // 前者进遥测（审计记录），后者进统计与缓存基线。
+      // 统计用的 token 数（含估算）。input 有估算器；output 没有——缺了
+      // 就是 null + missing，聚合时不进入总量，只计「未计量条数」。
       statInputTokens: inputTokens,
       statOutputTokens: outputTokens,
+      outputTokensMissing: apiOutputTokens === undefined,
       cached: false,
     };
 
@@ -2280,6 +2283,7 @@ class StartluxClient {
       mode: call.pointMode ?? "unknown",
       inputTokens,
       outputTokens,
+      outputTokensMissing: apiOutputTokens === undefined,
       durationMs: result.latencyMs,
       inputSource,
       outputSource,
@@ -2600,12 +2604,27 @@ export function apply(ctx, config) {
     const level = cfg.telemetryLevel ?? DEFAULTS.telemetryLevel;
     // off 时连读取都省掉：这是「关掉就是真的不联网」的执行点之一。
     if (level === "off") return;
+    /**
+     * 统计**上一完整自然日**，而不是「今天到目前为止」。
+     *
+     * 审计 P0-3：旧实现取启动时的「今天」计数，上午启动时只看到当天前几次
+     * 决策，随后全天几百次都不会再更新；服务端按收到日期归档，于是这一天
+     * 的 decisions 被系统性低估。改为日终口径：本次上报的是昨天 00:00 到
+     * 今天 00:00 的完整计数，并用 `day` 明确告诉服务端它属于哪一天。
+     */
+    const now = new Date();
+    const end = new Date(now);
+    end.setHours(0, 0, 0, 0);
+    const start = new Date(end);
+    start.setDate(start.getDate() - 1);
+    const pad = (value) => String(value).padStart(2, "0");
+    const localStamp = (date) =>
+      `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}T${pad(date.getHours())}:${pad(date.getMinutes())}`;
+    const day = `${start.getFullYear()}-${pad(start.getMonth() + 1)}-${pad(start.getDate())}`;
     let decisions = 0;
     try {
-      // 只统计「今天」的决策数：心跳的语义是「今天用没用、用多少」。
-      // 聚合失败就当 0（不上报该字段），不影响上报本身。
       const rows = await statsStore.read();
-      const range = resolveRange({ preset: "today" });
+      const range = resolveRange({ preset: "custom", start: localStamp(start), end: localStamp(end) });
       if (range.valid === true) {
         const result = aggregate(rows, range);
         // 字段名是 `requests`（见 stats.js 的 emptyBucket）。这里曾写成
@@ -2629,6 +2648,7 @@ export function apply(ctx, config) {
       // 宿主版本拿不到就留空，buildPayload 会整字段省略（不猜、不伪造）。
       hostVersion: "",
       decisions,
+      day,
     });
   };
   // 不 await：首次运行会真的发一次网络请求，绝不能拖住插件启动。
@@ -4178,6 +4198,16 @@ export function apply(ctx, config) {
     .catch((err) => {
       ctx.logger?.warn?.(`dsh-decision-engine: 匿名统计跳过（不影响插件）：${String(err?.message ?? err)}`);
     });
+  // 跨日补报（审计 P0-3）：长驻进程不会重新启动，只在启动时上报就永远
+  // 只有第一天的心跳。每 6 小时检查一次；`decideKind` 用「今天是否已上报」
+  // 去重，所以同一天不会重复发，跨日后会补报刚结束的那一天。
+  const telemetryTimer = setInterval(() => {
+    void reloadOwnConfig()
+      .catch(() => {})
+      .then(() => startTelemetry())
+      .catch(() => {});
+  }, 6 * 60 * 60 * 1000);
+  telemetryTimer.unref?.();
 
 }
 

package/lib/stats.js

@@ -74,6 +74,14 @@ export const TOKEN_SOURCES = {
   estimated: "estimated",
   /** 拿不到任何值（0）。 */
   unknown: "unknown",
+  /**
+   * 服务端明确没有返回这个计量值。
+   *
+   * 与 `unknown` 的区别：`unknown` 是「老记录没带来源字段」，`missing` 是
+   * 「这次请求确实没有 output token 可用」。两者都不能当成 0 参与总量，
+   * 但 `missing` 需要单独计数以便报告覆盖率。
+   */
+  missing: "missing",
 };
 
 /**
@@ -149,7 +157,8 @@ export function buildRecord(options = {}) {
   const num = (value) => (typeof value === "number" && Number.isFinite(value) ? value : 0);
   const source = (value) =>
     TOKEN_SOURCES[value] === TOKEN_SOURCES.api ||
-    TOKEN_SOURCES[value] === TOKEN_SOURCES.estimated
+    TOKEN_SOURCES[value] === TOKEN_SOURCES.estimated ||
+    TOKEN_SOURCES[value] === TOKEN_SOURCES.missing
       ? value
       : TOKEN_SOURCES.unknown;
   const inputTokens = num(options.inputTokens);
@@ -187,6 +196,15 @@ export function buildRecord(options = {}) {
     baseDurationMs,
     inputSource: source(options.inputSource),
     outputSource: source(options.outputSource),
+    /**
+     * output token 未知。
+     *
+     * 此前 `outputTokens` 缺失时被写成 0、来源却标 estimated——等于把一个
+     * 「不知道」伪装成「测得 0」，总量被系统性低估。现在显式带一个标记，
+     * 聚合时**不把未知值加进已知总量**，只累计未计量条数，界面再报覆盖率。
+     */
+    outputTokensMissing:
+      options.outputTokensMissing === true || options.outputSource === "missing",
   };
 }
 
@@ -414,6 +432,10 @@ function normalizeRecord(raw) {
     baseDurationMs: num(raw?.baseDurationMs),
     inputSource: typeof raw?.inputSource === "string" ? raw.inputSource : "unknown",
     outputSource: typeof raw?.outputSource === "string" ? raw.outputSource : "unknown",
+    outputTokensMissing:
+      raw?.outputTokensMissing === true || raw?.outputSource === "missing",
+    /** 缓存命中的基线是否来自历史插补（审计 P1：不再插补，只标记）。 */
+    baselineEstimated: raw?.baselineEstimated === true,
     // 预拼的「provider\0model」组合键：aggregate 过去每条记录拼一次、
     // 基线补齐再拼一次，两次结果必然相同。放在归一化时算一次即可。
     // 前缀 `\u0000` 保证它不会与被当作记录字段读取的键撞名。
@@ -454,6 +476,10 @@ export function isInRange(record, range) {
  * @param record - 已规范化的记录。
  */
 function accumulate(bucket, record) {
+  // 「尝试」= 发出去（或准备发出去）的每一次，含降级；「请求」= 拿到回答的
+  // 那部分。两者分开后，趋势图与汇总表可以用同一个分母对账：
+  //   attempts = requests + degraded
+  bucket.attempts += 1;
   if (record.degraded === true) {
     bucket.degraded += 1;
     bucket.degradedDurationMs += record.durationMs;
@@ -462,7 +488,12 @@ function accumulate(bucket, record) {
   bucket.requests += 1;
   if (record.cached === true) bucket.cached += 1;
   bucket.inputTokens += record.inputTokens;
-  bucket.outputTokens += record.outputTokens;
+  if (record.outputTokensMissing === true) {
+    // 未知值不进入已知总量，只计数；界面据此报「N 条未计量」。
+    bucket.outputTokensUnmeasured += 1;
+  } else {
+    bucket.outputTokens += record.outputTokens;
+  }
   bucket.durationMs += record.durationMs;
   /**
    * 节省量只认**观察模式**的记录。
@@ -483,10 +514,13 @@ function accumulate(bucket, record) {
   if (!contributesSavings(record.mode)) return;
   bucket.observeRequests += 1;
   bucket.observeInputTokens += record.inputTokens;
-  bucket.observeOutputTokens += record.outputTokens;
+  // output 未知时基线也无从复核：只跳过 output 这一对，不把 0 当实测。
+  if (record.outputTokensMissing !== true) {
+    bucket.observeOutputTokens += record.outputTokens;
+    bucket.observeBaseOutputTokens += record.baseOutputTokens;
+  }
   bucket.observeDurationMs += record.durationMs;
   bucket.observeBaseInputTokens += record.baseInputTokens;
-  bucket.observeBaseOutputTokens += record.baseOutputTokens;
   bucket.observeBaseDurationMs += record.baseDurationMs;
 }
 
@@ -510,6 +544,8 @@ function resetBucket(bucket) {
  */
 function emptyBucket() {
   return {
+    /** 尝试次数 = requests + degraded；对账用。 */
+    attempts: 0,
     requests: 0,
     cached: 0,
     degraded: 0,
@@ -517,7 +553,11 @@ function emptyBucket() {
     degradedDurationMs: 0,
     inputTokens: 0,
     outputTokens: 0,
+    /** output token 未知的记录数（不进入 outputTokens，见 accumulate）。 */
+    outputTokensUnmeasured: 0,
     durationMs: 0,
+    /** 缓存命中却缺基线、无法估计节省的记录数（不插补，只计数）。 */
+    estimatedBaselineMissing: 0,
     /**
      * 观察模式专属的累加桶。
      *
@@ -602,7 +642,10 @@ function finalizeBucket(bucket) {
    * 这段过程，所以它不该出现在分母里。
    */
   const realRequests = Math.max(0, bucket.requests - bucket.cached);
+  /** 有 output 计量的真实请求：平均 output 的分母不能把未知值当 0。 */
+  const measuredRequests = Math.max(0, realRequests - bucket.outputTokensUnmeasured);
   return {
+    attempts: bucket.attempts,
     requests: bucket.requests,
     realRequests,
     cached: bucket.cached,
@@ -611,6 +654,12 @@ function finalizeBucket(bucket) {
     degradedDurationMs: bucket.degradedDurationMs,
     inputTokens: bucket.inputTokens,
     outputTokens: bucket.outputTokens,
+    /** output token 未能计量的记录数；>0 时总量是「已知部分」。 */
+    outputTokensUnmeasured: bucket.outputTokensUnmeasured,
+    /** 有 output 计量的真实请求数（= realRequests - 未计量）。 */
+    measuredRequests,
+    /** 缓存命中的历史记录里缺基线、无法估计节省的条数。 */
+    estimatedBaselineMissing: bucket.estimatedBaselineMissing,
     totalTokens: bucket.inputTokens + bucket.outputTokens,
     durationMs: bucket.durationMs,
     /**
@@ -635,7 +684,14 @@ function finalizeBucket(bucket) {
     savedTimeRatio,
     avgDurationMs: realRequests === 0 ? 0 : Math.round(bucket.durationMs / realRequests),
     avgInputTokens: realRequests === 0 ? 0 : Math.round(bucket.inputTokens / realRequests),
-    avgOutputTokens: realRequests === 0 ? 0 : Math.round(bucket.outputTokens / realRequests),
+    avgOutputTokens: measuredRequests === 0 ? 0 : Math.round(bucket.outputTokens / measuredRequests),
+    /**
+     * 节省量的**口径**。`decision_request` = 只看决策请求这一层：
+     * 缓存去重 + 输入处理，不含主 Agent / 子代理 / 工具开销。
+     * 完整 Agent 净节省只能靠配对 A/B（尚未实现），界面文案必须按这个
+     * 口径解释，不能把它说成「总体省了多少」。
+     */
+    savedRatioScope: "decision_request",
   };
 }
 
@@ -948,10 +1004,20 @@ export function buildSeries(records, range, now = new Date()) {
   buckets.forEach((key, index) => indexOf.set(key, index));
 
   const series = {
+    /** 尝试次数（含降级）；与 totals.attempts 同口径。 */
+    attempts: new Array(buckets.length).fill(0),
+    /** 拿到回答的请求数（不含降级）；与 totals.requests 同口径。 */
     requests: new Array(buckets.length).fill(0),
+    /** 降级次数；与 totals.degraded 同口径。 */
+    degraded: new Array(buckets.length).fill(0),
     inputTokens: new Array(buckets.length).fill(0),
     outputTokens: new Array(buckets.length).fill(0),
+    /** 该桶里 output token 未知的记录数（不进入 outputTokens）。 */
+    outputTokensUnmeasured: new Array(buckets.length).fill(0),
+    /** 已回答请求的耗时（不含降级）；与 totals.durationMs 同口径。 */
     durationMs: new Array(buckets.length).fill(0),
+    /** 降级累计等待耗时；与 totals.degradedDurationMs 同口径。 */
+    degradedDurationMs: new Array(buckets.length).fill(0),
     allow: new Array(buckets.length).fill(0),
     ask: new Array(buckets.length).fill(0),
     reject: new Array(buckets.length).fill(0),
@@ -964,11 +1030,21 @@ export function buildSeries(records, range, now = new Date()) {
     // 落在区间外的记录（理论上已被筛掉）直接跳过：宁少一个点，
     // 也不要把它的值塞进错误的桶里——那会让图与表对不上。
     if (index === undefined) continue;
+    series.attempts[index] += 1;
+    if (record.degraded === true) {
+      // 与 accumulate 完全同口径：降级只进 attempts / degraded，
+      // 不进 requests / token / 回答耗时，否则「分桶之和」又对不上汇总。
+      series.degraded[index] += 1;
+      series.degradedDurationMs[index] += record.durationMs;
+      series.none[index] += 1;
+      continue;
+    }
     series.requests[index] += 1;
     series.inputTokens[index] += record.inputTokens;
-    series.outputTokens[index] += record.outputTokens;
+    if (record.outputTokensMissing === true) series.outputTokensUnmeasured[index] += 1;
+    else series.outputTokens[index] += record.outputTokens;
     series.durationMs[index] += record.durationMs;
-    const hasVerdict = record.action.length > 0 && record.degraded !== true;
+    const hasVerdict = record.action.length > 0;
     const outcome = hasVerdict ? outcomeOf(record.point, record.action) : "none";
     series[outcome === "none" ? "none" : outcome][index] += 1;
   }
@@ -1115,59 +1191,27 @@ export function aggregate(records, range) {
    * 而历史记录里缓存命中的占比往往不低（实测 telemetry.jsonl 里 678/2029
    * 条是缓存命中），只补耗时会让节省量看起来偏小。
    */
-  const realSamples = new Map();
-  for (const record of scoped) {
-    if (record.cached === true || record.degraded === true) continue;
-    if (record.durationMs <= 0) continue;
-    const comboKey = `${record.provider}\u0000${record.model}`;
-    const sample = realSamples.get(comboKey) ?? { duration: 0, input: 0, output: 0, count: 0 };
-    sample.duration += record.durationMs;
-    sample.input += record.inputTokens;
-    sample.output += record.outputTokens;
-    sample.count += 1;
-    realSamples.set(comboKey, sample);
-  }
-  let needsRecount = false;
-  for (const record of scoped) {
-    if (record.cached !== true) continue;
-    const sample = realSamples.get(record.comboKey);
-    if (sample === undefined || sample.count === 0) continue;
-    /**
-     * 缺哪个补哪个，而不是「有一个就不补」。
-     *
-     * 回填出来的历史命中记录是有 input 基线的（老遥测记了被复用的那份
-     * token 数），但**耗时**基线老遥测确实没有。若按「任一基线存在就跳过」
-     * 判断，这批记录的耗时节省会永远是 0——而缓存命中省下的时间恰恰是
-     * 用户最想看到的数字。
-     */
-    if (record.baseInputTokens === 0) {
-      record.baseInputTokens = Math.round(sample.input / sample.count);
-      needsRecount = true;
-    }
-    if (record.baseOutputTokens === 0) {
-      record.baseOutputTokens = Math.round(sample.output / sample.count);
-      needsRecount = true;
-    }
-    if (record.baseDurationMs === 0) {
-      record.baseDurationMs = Math.round(sample.duration / sample.count);
-      needsRecount = true;
-    }
-  }
-
-  // 基线补齐后要重新累加一遍：上面的 accumulate 发生在补齐之前，
-  // 补出来的基线不会自动进桶。重新累加的代价是一次 O(n) 遍历，
-  // 与统计本身相比可忽略。
-  if (needsRecount) {
-    for (const bucket of [totals, ...byCombo.values(), ...byProvider.values(), ...byPoint.values()]) {
-      resetBucket(bucket);
-    }
-    for (const record of scoped) {
-      accumulate(totals, record);
-      accumulate(byCombo.get(record.comboKey), record);
-      accumulate(byProvider.get(record.provider), record);
-      accumulate(byPoint.get(record.point), record);
-    }
-  }
+  /**
+   * 历史缓存命中的基线缺失——**不再用查询区间的均值插补**。
+   *
+   * 均值插补有三个确认的问题：
+   *   1. 同一模型同时处理很短与很长的请求，按模型分组的均值不保证
+   *      与被插补请求同分布；
+   *   2. 较早的命中可以借用同窗口内较晚发生的请求作基线（时间泄漏）；
+   *   3. 同一记录在不同查询窗口会得到不同基线，节省量不可加
+   *      （S(A∪B) ≠ S(A)+S(B)）。
+   *
+   * 现在只计数并上报：节省量只用「写入时已持久化」的精确基线（新记录
+   * 携带 baseInput/baseDuration），缺基线的历史命中不计入节省，但
+   * `estimatedBaselineMissing` 让界面明确告诉用户有多少条无法估计。
+   */
+  const estimatedBaselineMissing = scoped.filter(
+    (record) =>
+      record.cached === true
+      && record.baseInputTokens === 0
+      && record.baseOutputTokens === 0
+      && record.baseDurationMs === 0,
+  ).length;
 
   const rows = [...byCombo.entries()].map(([comboKey, bucket]) => {
     const [provider, model] = comboKey.split("\u0000");
@@ -1185,6 +1229,26 @@ export function aggregate(records, range) {
     point,
     ...bucket,
   }));
+  /**
+   * 安全口径（审计 P1）：`authorize` 的 reject 才是「安全拒绝」。
+   *
+   * retrieval.skip / skillPick.redirect / route.switch / compact.prune 都是
+   * 流程优化，它们也会产生 reject/allow，但与「有没有放行一次危险调用」
+   * 不是同一件事。把所有点的 reject 合成一个「拦截率」，启用越多优化
+   * 拦截率越高，而安全策略可能一点没变。这里单独给出 authorize 的分账，
+   * 其它点的 reject 只计数、不进入安全拦截率。
+   */
+  const authorizeOutcome = outcomeByPoint.get("authorize") ?? emptyOutcomeBucket();
+  const safety = {
+    point: "authorize",
+    allow: authorizeOutcome.allow,
+    ask: authorizeOutcome.ask,
+    reject: authorizeOutcome.reject,
+    /** 其它决策点产生的 reject（流程优化，不计入安全拦截率）。 */
+    otherPointRejects: Math.max(0, outcomeTotals.reject - authorizeOutcome.reject),
+    note:
+      "安全拦截率只统计 authorize 点；retrieval / skillPick / route / compact 的 reject 属于流程优化，不计入。",
+  };
   /**
    * 裁决总览：三格 + 未裁决 + 未分类明细。
    *
@@ -1244,6 +1308,10 @@ export function aggregate(records, range) {
      */
     series,
     recordCount: scoped.length,
+    /** 缺基线、无法估计节省的历史缓存命中条数（不插补，见上）。 */
+    estimatedBaselineMissing,
+    /** 安全分账：只有 authorize 点算安全拦截（见上）。 */
+    safety,
     /**
      * 节省量的**来源说明**。
      *

package/lib/telemetry.js

@@ -172,6 +172,17 @@ function shortField(value, max = 24) {
   return String(value ?? "").trim().replace(/[^0-9A-Za-z._+-]/g, "").slice(0, max);
 }
 
+/**
+ * 规范化上报的日期（`YYYY-MM-DD`）。
+ *
+ * @param value - 原始值。
+ * @returns 合法日期串；非法返回空串（字段省略，服务端按收到时间归档）。
+ */
+export function normalizeDay(value) {
+  const text = String(value ?? "").trim();
+  return /^\d{4}-\d{2}-\d{2}$/.test(text) ? text : "";
+}
+
 /**
  * 插件标识（npm 包名的合法形态）：小写，字母数字与 `-` / `.` / `_`，最长 48。
  *
@@ -201,7 +212,8 @@ export function normalizePluginId(value) {
  * @param input.platform - `process.platform`。
  * @param input.arch - `process.arch`。
  * @param input.hostVersion - 宿主版本（拿不到时为空串）。
- * @param input.decisions - 当天决策数（0 表示没有，不上报该字段）。
+ * @param input.decisions - 上一完整自然日的决策数（0 表示没有，不上报该字段）。
+ * @param input.day - 这组计数属于哪一天（`YYYY-MM-DD`，可选）；服务端据此归档。
  * @returns 可直接 `JSON.stringify` 的对象。
  */
 export function buildPayload(input = {}) {
@@ -218,6 +230,11 @@ export function buildPayload(input = {}) {
   };
   const host = normalizeVersion(input.hostVersion);
   if (host.length > 0) payload.host = host;
+  // 客户端声明的「这组决策数属于哪一天」。日终/次日上报上一完整自然日时，
+  // 服务端必须按这个日期落库，而不是按收到请求的日期——否则昨天的计数会
+  // 被记到今天（审计 P0-3）。非法值不带，服务端退回收到时间。
+  const day = normalizeDay(input.day);
+  if (day.length > 0) payload.day = day;
   const decisions = Number(input.decisions);
   if (Number.isFinite(decisions) && decisions > 0) payload.d = Math.min(Math.trunc(decisions), 100000);
   return payload;
@@ -386,6 +403,7 @@ export class TelemetryReporter {
       arch: input.arch,
       hostVersion: input.hostVersion,
       decisions: input.decisions,
+      day: input.day,
     });
     return { state: next, payload, today, kind };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leonhardthust/dsh-decision-engine",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "dsh-decision-engine: a cheap judgement layer for DeepSeek Harness — a small decision model answers structured questions before the main model acts, so calls can be allowed, escalated, rerouted to a cheaper model, or skipped. All eight decision points (tool authorization, model routing, delegation, compaction, turn continuation, retrieval, skill pick, COT translation) are implemented and individually switchable. Works against any service exposing a decision endpoint: built-in presets (system one, bamboonode, SiliconFlow, Silicon Flow) or a custom base URL.",
   "icon": "./icon.svg",
   "type": "module",