@leonhardthust/dsh-decision-engine 1.12.0 → 1.14.0

package/config.example.yml

@@ -413,16 +413,19 @@ guardFallbackReasoningEffort: ""
 # ============================================================================
 # 匿名使用统计（可选）
 # ============================================================================
-# 只上报「装了多少台、每天有多少人在用」，用来改进插件。字段只有七个：
-# 匿名安装 id（首次运行随机生成的 UUIDv4，与账号无关）、插件版本、平台、
-# 架构、宿主版本、当日决策数、事件类型。
+# 用途只有一个：让作者知道还有多少人在用、哪些版本/平台在用、每天判了多少
+# 次，用来判断这个插件值不值得继续维护（以及优先修哪个平台的问题）。
 #
-# 绝不上报：API key、prompt / 工具参数、文件路径、provider 地址、会话内容、
-# 用户名；服务端也不记录 IP。删掉 analytics.json 即换新身份。
+# 上报字段（全部）：随机安装 id（首次运行生成的 UUIDv4，与账号无关）、插件版本、
+# 平台、架构、宿主版本、当天决策数、事件类型（install / daily heartbeat）。
 #
-#   off      完全联网都不做（连版本检查都没有）
-#   install  仅首次运行上报一次「装了」
-#   daily    每天上报一次，附带当日决策数（默认）
+# 绝不上报：API key、prompt / 工具参数、文件路径、provider 地址、模型名、会话
+# 内容、用户名；服务端也不记录 IP。删掉 analytics.json 即换新身份。
+#
+#   off      完全关闭：一个请求都不发
+#   install  仅首次运行上报一次「装了」，之后不再联网
+#   daily    每天上报一次**上一完整自然日**的决策数（默认；跨日由 6 小时一次
+#            的检查补报，长驻进程不会漏掉）
 #
 # telemetryLevel: daily
 # telemetryEndpoint: ""     # 留空用内置端点

package/docs/releasing.md

@@ -1,6 +1,6 @@
 # npm 发布
 
-发布目标：`@leonhardthust/dsh-decision-engine`，当前版本 `1.12.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.12.0` 包含 DEC-072 / DEC-073：新增阿里云百炼（workspace + 地域拼端点）与 TokenHub（tokenhub.com；腾讯云 TokenHub 无决策端点）预设，设置页暴露百炼的 Workspace ID / 地域；「免费模型」从独立开关合并为 provider 下拉第一项。`1.11.2` 的 never 回退、`1.11.1` 的 DEC-070、`1.11.0` 的审计修复、`1.10.0` 的五项改动依次见 DEC-062 ~ DEC-071。
+- 当前 `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.12.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.12.0`。安装和启用是另外的用户动作，发布工作流不会修改本机 DSH profile。
+DSH 插件管理中使用 `@leonhardthust/dsh-decision-engine` 或指定 `@leonhardthust/dsh-decision-engine@1.14.0`。安装和启用是另外的用户动作，发布工作流不会修改本机 DSH profile。

package/lib/client.js

@@ -144,11 +144,15 @@ window.__ModuleLoader__.load({
       "auto｜由服务端决定（实测约 7.2s，比 never 慢）": "auto | decided by the server (measured ~7.2s, slower than never)",
       "always｜总是思考（约 +5s，质量收益未实测）": "always | always think (about +5s; quality gain not measured)",
       // —— 匿名使用统计（DEC-020）——
-      "匿名统计": "Anonymous stats",
+      "匿名使用统计": "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 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",
+      "仅在第一次运行时上报一次「安装了」（字段同上），之后不再联网。": "Reports \"installed\" once on the first run (same fields as above), then never touches the network again.",
       "off（不联网）": "off (no network)",
+      "off（完全关闭）": "off (fully disabled)",
       "install（仅首次）": "install (first run only)",
       "daily（每天一次，默认）": "daily (once a day, default)",
       "auto（先 /decisions）": "auto (/decisions first)",
@@ -188,6 +192,10 @@ window.__ModuleLoader__.load({
       "重试": "Retry",
       "测试中…": "Testing…",
       "测试端点": "Test endpoint",
+      "连通性测试": "Connectivity test",
+      "分别向决策端点与回退语言模型各发一次最小请求；仅在你点击时发生，会消耗少量 token": "Sends one minimal request to the decision endpoint and to the fallback language model. Only when you click; uses a few tokens.",
+      "已跳过": "Skipped",
+      "详情": "Details",
       "未保存：密钥太短（至少 10 个字符）": "Not saved: the key is too short (at least 10 characters)",
       "测试端点失败": "Endpoint test failed",
       // —— 使用免费模型（DEC-030，原名「跟随服务端下发」，DEC-037 改名） ——
@@ -274,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.",
@@ -5498,7 +5511,7 @@ window.__ModuleLoader__.load({
         { key: "savedOutputTokens", label: "省 output" },
         { key: "observeDurationMs", label: "实际耗时（观察）", actual: true },
         { key: "savedDurationMs", label: "省耗时" },
-        { key: "savedRatio", label: "节省比例" },
+        { key: "savedRatio", label: "估算节省率" },
       ];
 
       /**
@@ -5521,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，混进分母会让这个
               // 数字随命中率变好看，读的人以为请求变快了。
@@ -5544,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(
@@ -5602,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",
@@ -6265,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」的原因。
                *
@@ -7273,10 +7319,11 @@ window.__ModuleLoader__.load({
         setProviderError("");
         try {
           const result = await call("/test", { method: "POST" });
-          // 服务端返回的整段诊断（provider / 端点 / HTTP 码 / 请求 id / 响应体）
-          // 原样展示：只报「失败」而不给细节，用户无法判断该改地址还是改 key。
+          // DEC-074：服务端现在返回分链路的 `results`（决策端点 / 回退模型），
+          // 界面优先渲染成两张卡片；`text` 只作为旧服务端的兜底与纯文本记录。
           setMsg({
             ok: result.ok === true,
+            results: Array.isArray(result.results) ? result.results : null,
             text: result.ok === true
               ? t("端点连通 ✅\n{text}", { text: result.text ?? "" })
               : tr(result.text ?? "") || t("端点返回失败"),
@@ -7865,6 +7912,109 @@ window.__ModuleLoader__.load({
           ),
           "endpoint",
         ),
+        // 4b2) 连通性测试：从页脚前移到它要验证的对象旁边（provider / 模型 /
+        //      端点 / key 都在上面几行）。一次点击同时测两条链路：决策端点
+        //      （自拼 System One）与回退语言模型（宿主 llm.stream）。结果就
+        //      显示在下面，不再需要滚到页脚找「测试」的结论。
+        row(
+          "连通性测试",
+          t("分别向决策端点与回退语言模型各发一次最小请求；仅在你点击时发生，会消耗少量 token"),
+          h(
+            "button",
+            {
+              type: "button",
+              onClick: runTest,
+              disabled: busy !== "",
+              style: { ...S.saveBtn, flexShrink: 0 },
+            },
+            busy === "test" ? "测试中…" : "测试端点",
+          ),
+          "connectivity",
+        ),
+        msg !== null
+          ? h(
+              "div",
+              {
+                style: { display: "flex", flexDirection: "column", gap: "8px", marginTop: "10px" },
+                key: "test-msg",
+              },
+              // 结构化结果（DEC-074）：每条链路一张小卡片——先给结论（通/不通/
+              // 跳过）+ 一行摘要，原始诊断折叠进「详情」。旧服务端只回 `text`
+              // 时退回整段文本，不至于空白。
+              ...(Array.isArray(msg.results)
+                ? msg.results.map((item) => {
+                    const tone = item.skipped === true ? "#fbbf24" : item.ok === true ? "#4ade80" : "#f87171";
+                    const icon = item.skipped === true ? "–" : item.ok === true ? "✓" : "✕";
+                    return h(
+                      "div",
+                      {
+                        key: `test-${item.key ?? item.label}`,
+                        style: {
+                          border: `1px solid ${tone}55`,
+                          borderRadius: "8px",
+                          padding: "8px 10px",
+                          background: `${tone}0d`,
+                        },
+                      },
+                      h(
+                        "div",
+                        { style: { display: "flex", alignItems: "center", gap: "8px" } },
+                        h("span", { style: { color: tone, fontWeight: 600 } }, icon),
+                        h("span", { style: { fontWeight: 600 } }, item.label),
+                        item.skipped === true
+                          ? h("span", { style: { ...S.meta, marginTop: 0, color: tone } }, t("已跳过"))
+                          : null,
+                      ),
+                      h(
+                        "div",
+                        { style: { ...S.meta, marginTop: "4px", whiteSpace: "pre-wrap", wordBreak: "break-all" } },
+                        item.summary ?? "",
+                      ),
+                      typeof item.detail === "string" && item.detail.length > 0 && item.detail !== item.summary
+                        ? h(
+                            "details",
+                            { style: { marginTop: "4px" } },
+                            h(
+                              "summary",
+                              { style: { cursor: "pointer", ...S.meta, marginTop: 0, opacity: 0.7 } },
+                              t("详情"),
+                            ),
+                            h(
+                              "pre",
+                              {
+                                style: {
+                                  margin: "6px 0 0",
+                                  whiteSpace: "pre-wrap",
+                                  wordBreak: "break-all",
+                                  fontSize: "12px",
+                                  opacity: 0.8,
+                                  fontFamily: "inherit",
+                                },
+                              },
+                              item.detail,
+                            ),
+                          )
+                        : null,
+                    );
+                  })
+                : [
+                    h(
+                      "div",
+                      {
+                        style: {
+                          ...S.meta,
+                          marginTop: 0,
+                          color: msg.ok ? "#4ade80" : "#f87171",
+                          whiteSpace: "pre-wrap",
+                          fontFamily: "inherit",
+                          fontSize: "13px",
+                        },
+                      },
+                      msg.text,
+                    ),
+                  ]),
+            )
+          : null,
         // 4c) 密钥保存位置：默认托管到 .credentials.yaml（DEC-037 从 API Key 紧邻处
         //     下移到这里：它讲的是「这把 key 存到哪个文件」，不是「怎么连上服务」，
         //     夹在连接组中间会打断 provider → 模型 → key → 端点这条阅读线；
@@ -8663,12 +8813,14 @@ window.__ModuleLoader__.load({
         // 放在「思考模式」之后：它同样是「一次性选择、改完即存」的下拉，
         // 与上面的开关/下拉一组，不与 provider 表格混在一起。
         row(
-          "匿名统计",
-          draft.telemetryLevel === "daily"
-            ? "每天上报一次：匿名安装 id、版本、平台与当日决策数"
+          "匿名使用统计",
+          // 与下拉的兜底保持一致：undefined 时下拉显示 daily，说明也必须说 daily，
+          // 否则首帧会出现「选中的是 daily、解释却写仅首次」的自相矛盾。
+          (draft.telemetryLevel ?? "daily") === "daily"
+            ? t("每天一次，只用于让作者判断插件还有多少人在用、值不值得继续维护：随机安装 ID、插件版本、平台/架构、宿主版本、上一完整自然日的决策次数。不含会话内容、文件路径、密钥、模型名或身份信息。")
             : draft.telemetryLevel === "off"
-              ? "已关闭：任何情况下都不联网"
-              : "仅首次运行上报一次「安装了」，之后不再联网",
+              ? t("完全关闭：不发送任何请求。")
+              : t("仅在第一次运行时上报一次「安装了」（字段同上），之后不再联网。"),
           h(
             "select",
             {
@@ -8689,10 +8841,10 @@ window.__ModuleLoader__.load({
                 "option",
                 { key: value, value },
                 value === "off"
-                  ? "off（不联网）"
+                  ? t("off（完全关闭）")
                   : value === "install"
-                    ? "install（仅首次）"
-                    : "daily（每天一次，默认）",
+                    ? t("install（仅首次）")
+                    : t("daily（每天一次，默认）"),
               ),
             ),
           ),
@@ -8701,8 +8853,10 @@ window.__ModuleLoader__.load({
       ];
 
       const footerItems = [
-        // 页脚常驻在所有分组之下：保存状态、测试端点、状态信息与诊断结果。
+        // 页脚常驻在所有分组之下：保存状态与状态信息。
         //   它回答的是「刚才那一下存没存」，与页面哪一组展开无关。
+        //   连通性测试已前移到「连接方式」组（DEC-074）——它要验证的对象都在
+        //   那里，结论也该贴着对象显示。
         // 4g) 自动保存状态行：**没有「保存」按钮**，改动即落盘。
         //    这一行回答的是「刚才那一下到底存没存」：进行中 / 已存 /
         //    失败原因（附重试）。原来那个按钮的「保存中…」搬到这里。
@@ -8755,16 +8909,6 @@ window.__ModuleLoader__.load({
                 "重试",
               )
             : null,
-          h(
-            "button",
-            {
-              type: "button",
-              disabled: busy !== "",
-              onClick: runTest,
-              style: { ...S.saveBtn, background: "transparent", color: "inherit" },
-            },
-            busy === "test" ? "测试中…" : "测试端点",
-          ),
         ),
         // 4h) 状态信息（紧凑）
         h(
@@ -8795,20 +8939,6 @@ window.__ModuleLoader__.load({
               }) + (activeKeyStatus.configured === true ? "" : t("（未读到）"))
             : null,
         ),
-        msg !== null
-          ? h(
-              "div",
-              {
-                style: {
-                  ...S.meta,
-                  marginTop: "10px",
-                  color: msg.ok ? "#4ade80" : "#f87171",
-                },
-                key: "msg",
-              },
-              msg.text,
-            )
-          : null,
       ];
 
       // 配置 tab 的全部内容。

package/lib/index.js

@@ -654,9 +654,10 @@ export const Config = z.object({
     .description("缓存存活时间；改策略或配置后旧裁决不应继续被复用"),
   telemetryLevel: z.union([...TELEMETRY_LEVELS]).default(DEFAULTS.telemetryLevel)
     .description(
-      "匿名使用统计：off 完全不联网 / install 仅首次运行报一次（默认）/ "
-        + "daily 每天报一次（含当日决策数）。只上报插件版本、平台、架构与计数，"
-        + "永不上报 prompt、密钥、路径或会话内容",
+      "匿名使用统计：off 完全不联网 / install 仅首次运行报一次 / daily 每天一次（默认，含当天决策数）。"
+        + "用途只有「判断还有多少人在用、哪些版本与平台在用、值不值得继续维护」；"
+        + "上报随机安装 ID、插件版本、平台/架构、宿主版本与决策计数，"
+        + "永不上报 prompt、密钥、路径、模型名或会话内容",
     ),
   telemetryEndpoint: z.string().default(DEFAULTS.telemetryEndpoint)
     .description("统计上报地址；留空用内置端点（https://dsh.zuos.us/api/e）"),
@@ -2220,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)",
@@ -2241,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,
     };
 
@@ -2279,6 +2283,7 @@ class StartluxClient {
       mode: call.pointMode ?? "unknown",
       inputTokens,
       outputTokens,
+      outputTokensMissing: apiOutputTokens === undefined,
       durationMs: result.latencyMs,
       inputSource,
       outputSource,
@@ -2599,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）。这里曾写成
@@ -2628,6 +2648,7 @@ export function apply(ctx, config) {
       // 宿主版本拿不到就留空，buildPayload 会整字段省略（不猜、不伪造）。
       hostVersion: "",
       decisions,
+      day,
     });
   };
   // 不 await：首次运行会真的发一次网络请求，绝不能拖住插件启动。
@@ -3150,6 +3171,108 @@ export function apply(ctx, config) {
     return { ok: false, text: `provider: ${provider.label}（${provider.id}）\nPOST ${usedEndpoint}\n请求失败（${Date.now() - started}ms）` };
   };
 
+  /**
+   * 探测回退语言模型（guardFallback = model 时）。
+   *
+   * 为什么要单独测：决策端点与回退模型是两条完全不同的链路——前者是自己拼的
+   * System One 请求，后者走宿主的 `llm.stream`。决策端点通、回退模型 401 的
+   * 情况完全可能发生；只测前者会让用户以为整套守卫都在工作，而真正需要兜底
+   * 时才发现回退模型不可用。
+   *
+   * 刻意只测「显式指定 provider/model」这一种策略：
+   *   - session 用的是当前会话模型，设置页没有会话上下文，测不了（也不该猜）；
+   *   - allow / deny 根本不调模型，没有可测的链路。
+   *
+   * 这是一次最小的真实模型调用（maxTokens 16），只在用户点「测试」时发生；
+   * 失败/超时都折叠成一段可读诊断，绝不让测试按钮本身抛错。
+   *
+   * @returns `{ ok: boolean|null, skipped?: boolean, text }`；null = 本策略不适用。
+   */
+  const probeFallbackModel = async () => {
+    const policy = cfg.guardFallback;
+    if (policy !== "model") {
+      return {
+        ok: null,
+        skipped: true,
+        text: `回退语言模型: 当前策略为 ${policy}，不调用独立模型（${policy === "session" ? "使用会话当前模型，设置页无法离线测试" : "没有可测的模型链路"}）`,
+      };
+    }
+    const provider = typeof cfg.guardFallbackProvider === "string" ? cfg.guardFallbackProvider.trim() : "";
+    const model = typeof cfg.guardFallbackModel === "string" ? cfg.guardFallbackModel.trim() : "";
+    if (provider.length === 0 || model.length === 0) {
+      return { ok: false, text: "回退语言模型: 策略为 model，但 provider / model 未填全" };
+    }
+    const llm = ctx.get?.("llm");
+    if (typeof llm?.stream !== "function") {
+      return { ok: false, text: "回退语言模型: 宿主未提供 llm.stream，无法测试（请确认 DSH 版本支持该服务）" };
+    }
+    const configuredTimeout = Number.isFinite(cfg.timeoutMs) ? cfg.timeoutMs : 20000;
+    const timeoutMs = Math.max(8000, Math.min(20000, configuredTimeout));
+    const effort = typeof cfg.guardFallbackReasoningEffort === "string" ? cfg.guardFallbackReasoningEffort.trim() : "";
+    const started = Date.now();
+    try {
+      const stream = llm.stream({
+        provider,
+        model,
+        ...(effort.length > 0 ? { reasoningEffort: effort } : {}),
+        // 只要求一个词：这是连通性测试，不是质量评测；输出越短越省钱。
+        messages: [{ role: "user", content: [{ type: "text", text: "Reply with the single word: pong" }] }],
+        tools: [],
+        maxTokens: 16,
+        signal: AbortSignal.timeout(timeoutMs),
+        purpose: "decision-engine-connectivity",
+      });
+      let finish = null;
+      let text = "";
+      for await (const chunk of stream) {
+        if (chunk?.type === "text-delta") text += chunk.text;
+        if (chunk?.type === "finish") finish = chunk.reason?.kind ?? "unknown";
+      }
+      // length 也算连通：模型确实回应了，只是 16 token 被截断（例如它先输出了
+      // 一段思考）。只有「没有 finish 或 finish 不是正常结束」才算失败。
+      const ok = finish === "stop" || finish === "length";
+      return {
+        ok,
+        text:
+          `回退语言模型: ${provider} / ${model}${effort.length > 0 ? `（effort ${effort}）` : ""}\n` +
+          `耗时 ${Date.now() - started}ms　finish: ${finish ?? "(无)"}\n` +
+          `响应: ${text.trim().slice(0, 120) || "(空)"}`,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        ok: false,
+        text: `回退语言模型: ${provider} / ${model}\n请求失败（${Date.now() - started}ms）: ${message}`,
+      };
+    }
+  };
+
+  /**
+   * 把 probe() 的多行诊断压成一句「人先看这个」的结论。
+   *
+   * 原始输出是给排查用的（request id、尝试过的路径、响应体），但测试按钮的
+   * 第一眼需要一个能判断「通没通、多快」的短句；详情仍然保留，折叠起来。
+   *
+   * @param text - probe() 返回的完整文本。
+   * @returns 一行摘要（不抛错，解析不出来就取前两行）。
+   */
+  const summarizeProbe = (text) => {
+    const lines = String(text ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const provider = lines.find((line) => line.startsWith("provider: "));
+    const post = lines.find((line) => line.startsWith("POST "));
+    const http = lines.find((line) => line.startsWith("HTTP "));
+    const failed = lines.find((line) => line.startsWith("请求失败"));
+    const reason = lines.find((line) => line.startsWith("失败原因: "));
+    const parts = [];
+    if (provider) parts.push(provider.slice("provider: ".length));
+    if (post) parts.push(post);
+    if (http) parts.push(http.replace(/\s+/g, " "));
+    else if (failed) parts.push(failed);
+    if (reason) parts.push(reason.slice("失败原因: ".length));
+    if (parts.length === 0) return lines.slice(0, 2).join(" · ") || "（无结果）";
+    return parts.join(" · ");
+  };
+
   // ---- 面板 API：给前端 UI 用（不经过 settings 服务）-------------------------
   ctx.inject?.(["connection"], () => {
     const connection = ctx.get?.("connection");
@@ -3847,8 +3970,42 @@ export function apply(ctx, config) {
       methods: ["POST"],
       requestBody: "buffered",
       fetch: async () => {
-        const result = await probe();
-        return json({ ok: result.ok, text: result.text });
+        // 两条链路各测一次：决策端点是自拼的 System One 请求，回退模型走宿主
+        // 的 llm.stream。只测前者会让「决策端点通、回退模型不可用」被误报成
+        // 整体健康——而回退模型恰好是审批通道不可用时的兜底裁判。
+        const decision = await probe();
+        await reloadOwnConfig();
+        const fallback = await probeFallbackModel();
+        // fallback.ok 为 null 表示该策略不适用（session / allow / deny），
+        // 不能把「没有这条链路」算成失败；但明确失败（false）必须让整体变红。
+        const ok = decision.ok === true && fallback.ok !== false;
+        // 给界面一份结构化结果：每条链路一个短摘要 + 可折叠的原始诊断。
+        // 摘要与详情分开，是因为用户第一眼只需要「通没通、多快」，排查时才
+        // 展开 request id / 响应体。
+        const results = [
+          {
+            key: "decision",
+            label: "决策端点",
+            ok: decision.ok === true,
+            skipped: false,
+            summary: summarizeProbe(decision.text),
+            detail: decision.text,
+          },
+          {
+            key: "fallback",
+            label: "回退语言模型",
+            ok: fallback.ok,
+            skipped: fallback.skipped === true,
+            summary: fallback.text,
+            detail: fallback.detail ?? null,
+          },
+        ];
+        return json({
+          ok,
+          // `text` 保留给旧前端/日志：纯文本仍然可读。
+          text: [decision.text, fallback.text].filter((line) => typeof line === "string" && line.length > 0).join("\n\n"),
+          results,
+        });
       },
     });
 
@@ -4041,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.12.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",