@master0071/dsh-systemone 0.6.1 → 0.7.0

package/README.md

@@ -128,7 +128,7 @@ systemone_decide(
 - **提供商无关**：所有工具只依赖统一的 `provider.decide()` 接口。切换厂商只改一行配置，业务工具零改动。
 - **图形配置页**：侧栏「插件 → @master0071/dsh-systemone → systemone」里可直接改提供商、Key、模型与自动决策参数，保存即生效（volatile 热更新，无需重启）。
 - **场景可扩展**：内置 11 大场景（含软件开发与需求预检），并可在配置页里用 JSON 追加或覆盖场景，**无需改代码、无需重启**
-- **可自动决策**：开启后挂 `agent/pre-step`，每一步推理前自动捕获上下文并注入判断（fail-open、硬超时、可缓存）。
+- **可自动决策**：开启后挂 `agent/pre-step`，每一步推理前自动捕获上下文并注入判断（fail-open、硬超时、可缓存、路由复用、失败熔断）。
 - **概率化输出**：返回每个选项的概率分布与置信度，而非单一答案。
 - **复核兜底（分布平坦度）**：`needs_human_review` 的**主要判据是概率分布是否平坦**——最大概率相对均匀分布不足 1.5 倍即视为"模型在猜"（不依赖标定，跨后端可比）。`minConfidence`（默认 0.6）保留为**次要**信号以兼容既有配置。判定理由放在 `review_reasons` 字段与摘要里，不只给一个布尔值（见「复核判定」）。
 - **可编程调用**：注册 `ctx.systemone` 服务，其他插件可直接 `ctx.systemone.decide({ state, questions })`。
@@ -271,7 +271,7 @@ const decision = await waterfall('agent/pre-step', {         // ③ 再跑瀑布
 场景：金融风控 · 交易异常与风险等级（来源：自动路由，路由置信度 87.0%）
 结论：异常评分=高度可疑；风险等级=高风险；人工复核=是
 建议：交易异常评分 3，风险等级「高风险」。需转人工复核
-注意：本次判断置信度偏低，请人工确认后再执行。
+注意：本次判断的可能分布不够集中（风险等级：最大概率 0.52，相对均匀仅 1.56 倍），请人工确认后再执行。
 ```
 
 ### 安全约束
@@ -283,6 +283,7 @@ const decision = await waterfall('agent/pre-step', {         // ③ 再跑瀑布
 | 默认关闭 | `autoDecide: false`，需显式开启 |
 | 硬超时 | `autoTimeoutMs`（默认 8s）。既给上游传 `AbortSignal`，也用 Promise race 兜底——**即使提供商忽略 signal 也不会阻塞推理** |
 | 失败放行 | 任何错误只记 warning，原样返回宿主决策 |
+| 失败熔断 | 连续 **2 次真失败**（请求异常/超时/场景执行失败）后暂停 `autoFailureCooldownMs`（默认 60s）：期间直接放行、不再请求上游。没有它，上游故障时每条消息都要等满 `autoTimeoutMs` 才继续。成功一次即清零，`0` 关闭 |
 | 结果缓存 | 相同 state **且决策参数未变**时命中 `autoCacheTtlMs`（默认 60s）缓存，不重复请求；并发相同 state 自动合并。决策参数（固定场景 / provider / model / 两个置信度门槛）变化会使缓存立即失效 |
 | 注入去重 | `message` 通道对同一决策文本只注入一次，避免每步重复追加 |
 | 精准触发 | 仅当本轮有新用户消息时触发；工具结果步骤不触发 |
@@ -296,6 +297,9 @@ const decision = await waterfall('agent/pre-step', {         // ③ 再跑瀑布
 - **近期对话**：从 `agent.session.log` 倒序取最近 `autoMaxMessages`（默认 6）条 user/assistant 消息，单条截断 2000 字符；
 - **当前请求**：本轮 `pre-step` 的新用户消息。
 
+自动**路由**用的 state 只带最近 2 条历史：路由只回答"这句话属于哪个业务域"，
+不值得为一次分类付决策级的 token（默认 6×2000 + 8000 字符会随路由请求再发一遍）。
+
 ### 配置
 
 | 配置项 | 默认值 | 说明 |
@@ -307,6 +311,8 @@ const decision = await waterfall('agent/pre-step', {         // ③ 再跑瀑布
 | `autoTimeoutMs` | `8000` | 自动决策硬超时（毫秒） |
 | `autoMaxMessages` | `6` | 捕获的历史消息条数 |
 | `autoCacheTtlMs` | `60000` | 相同内容的结果缓存时长，`0` 表示不缓存。缓存键含决策参数，改场景/模型/门槛会立即失效 |
+| `autoRouteCacheTtlMs` | `180000` | 同一会话内复用上次自动路由结果的时长。复用时只发场景决策请求（少一次上游调用、少一份 state），注入文本标成「自动路由·复用」；决策参数一变立即失效，`0` 表示每条消息都重新路由 |
+| `autoFailureCooldownMs` | `60000` | 连续 2 次失败后的熔断时长（毫秒），期间直接放行、不再请求上游；`0` 关闭熔断 |
 | `autoMinConfidence` | `0.6` | 自动决策的置信度阈值 |
 | `autoRouteMinConfidence` | `0.35` | 自动路由的置信度门槛，低于该值宁可不注入 |
 | `autoMinChars` | `4` | **寒暄判定的长度上界**：只有"短于此长度**且**整体是寒暄"才跳过。`退款`/`报错`/`闪退` 这类中文短请求是完整业务请求，会正常触发；设为 `0` 表示不做长度限制、只按寒暄名单判定 |
@@ -319,7 +325,8 @@ const decision = await waterfall('agent/pre-step', {         // ③ 再跑瀑布
 | **`message` 通道仍会写入会话历史** | `dsh-agent-loop` 对 `pre-step` 返回的 messages 执行无条件 `session.append('user/message', …, {surfaceOp:'append'})`。插件已做**内容去重**：同一决策文本只注入一次，把「每步一条」降为「每个不同决策一条」；但长对话中决策多次变化时仍会累积。需要绝对零历史写入时请用 `autoInject: "context"`。 |
 | **注入消息用自己的 `source.kind`** | 注入消息标记为 `source.kind = "systemone-decision"`，**不复用宿主的 `runtime-context`**。宿主 `RuntimeContextProjection` 仅凭该 kind 认定"这是我自己写的快照"并维护去重状态，复用会让宿主每步多追加一条冗余的自身快照。副作用（正向）：读历史时现在会排除自己的决策消息、但**保留**宿主真实的动态上下文快照。 |
 | **`context` 通道第一步通常看不到结论** | `systemPrompt.context` 的 `text` 是同步求值，而决策是异步 HTTP 调用，第一步装配时通常尚未返回。插件在 `agent/inbox/inserted` 时预计算，因此**第二步起稳定可见**；单步问答（模型不调工具）时，结论会落到下一轮。 |
-| **自动路由会多一次请求** | 场景数 >1 且 `autoScenario` 为空时，需先路由再决策。固定场景可省掉。场景数超过 26 时自动拆成多道 choice 并行问出（每题仍在限制内），仍只是一次请求。 |
+| **自动路由会多一次请求** | 场景数 >1 且 `autoScenario` 为空时，需先路由再决策；同一会话内 `autoRouteCacheTtlMs`（默认 3 分钟）内复用上次路由结果，连续追问只多第一次。固定场景可完全省掉。场景数超过 26 时自动拆成多道 choice 并行问出（每题仍在限制内），仍只是一次请求。 |
+| **路由复用会沿用上一次的场景判定** | 复用窗口内话题切换（从「订单没到账」跳到「看看这段代码」）仍会用旧场景做决策，可能注入一条不相关的参考。介意就把 `autoRouteCacheTtlMs` 设为 `0`；注入本身标着"仅供参考"，低置信度还会附人工复核提示。 |
 | **延迟直接叠加** | 自动决策在关键路径上同步等待，SystemOne 延迟会加到首字延迟。`autoTimeoutMs` 是硬上限，超时即放行。 |
 
 建议：先用 `autoScenario` 固定场景省掉路由请求；把 `autoTimeoutMs` 设成你能接受的最大延迟；若只是想让模型"知道该用哪个场景"，用提示词引导即可，不必开自动决策。
@@ -352,7 +359,7 @@ const decision = await waterfall('agent/pre-step', {         // ③ 再跑瀑布
 | --- | --- | --- | --- |
 | `provider` | `unisound` | 热更新 | `unisound`（官方）/ `http`（SystemOne 兼容端点）/ `mock`（本地模拟） |
 | `apiKeyRef` | 空 | 热更新 | **推荐的凭证方式**：从 `$DSH_HOME/.credentials.yaml` 的 `refs.<名字>` 读密钥，配置文件里只留这个名字。留空时依次尝试 `SYSTEMONE_API_KEY` → `UNISOUND_API_KEY` → `TYPESAFE_API_KEY` |
-| `apiKey` | 空 | 热更新 | 明文密钥（备用）。声明为 secret，**已保存的值不会回显到界面**，但仍以明文落在 profile 的 `cordis.patch.yml` 里——不想落明文就用 `apiKeyRef` 或环境变量 |
+| `apiKey` | 空 | 热更新 | 明文密钥（备用）。声明为 secret，**已保存的值不会回显到界面**；要移除它用配置页的「清除已保存的 Key」（走 schema 的 `unset`，而不是写入空串）。仍以明文落在 profile 的 `cordis.patch.yml` 里——不想落明文就用 `apiKeyRef` 或环境变量 |
 | `baseUrl` | `https://maas-api.unisound.com/v1` | 热更新 | Unisound API 基础地址 |
 | `endpoint` | 空 | 热更新 | `provider=http` 时的完整请求端点；留空回退到 `baseUrl` |
 | `model` | `u2-decision` | 热更新 | 决策模型名 |
@@ -362,7 +369,7 @@ const decision = await waterfall('agent/pre-step', {         // ③ 再跑瀑布
 | `customScenarios` | 空 | 热更新 | 自定义场景 JSON 数组（见下）。保存后**场景库立即重建**，无需重启 |
 | `autoDecide` | `false` | 需重启 | 是否开启自动决策（挂载 `agent/pre-step`） |
 | `auto*` | 见「自动决策」 | 热更新 | 自动决策的运行参数（钩子挂载后实时生效） |
-| `usageLogPath` | 空 | 热更新 | 用量台账文件路径；留空则用 `$DSH_HOME/dsh-systemone/usage.jsonl` |
+| `usageLogPath` | 空 | 热更新 | 台账文件路径；留空则用 `$DSH_HOME/dsh-systemone/usage.jsonl`。保存后**立即切换**：新台账从新文件恢复当日累计，不会把旧文件的账带过去 |
 
 > 为什么 `autoDecide` 需要重启：它决定「要不要挂钩子」，属于装配期决定。其余字段每次请求/每次事件都会重新读取，所以可以热更新。
 
@@ -378,6 +385,7 @@ $DSH_HOME/dsh-systemone/usage.jsonl
 
 - `source` 区分 `tool`（模型主动调用工具）与 `auto-route`（自动决策的路由请求）；目标场景的那次决策也记 `tool`，**不会重复计数**。
 - 计数按**本地日**切分，跨日自动归零，不需要定时任务。
+- 进程启动时从文件尾部（最多 2 MB）**恢复当日累计**：宿主重启不是新的一天，重启后的「今日用量」与将来的日限判定都接着算；半行/坏行会被跳过，读盘失败就退回全 0。
 - 台账写盘失败会**降级为仅内存统计**并只告警一次——记账失败绝不让决策失败。
 
 查看今日用量：`systemone_scenario(action: "list")` 的 `### 用量` 小节与 `usage_today` 字段，例如 `今日：7 次判断 · 12.3k input tokens（2026-10-05），其中失败 1 次`。
@@ -578,24 +586,28 @@ SystemOne 是「结构化问题 → 概率分布」的决策模型，**不是开
 
 ```powershell
 npm run check   # 9 个 lib/*.js 语法检查通过
-npm run test    # 179 项测试：
+npm run test    # 195 项测试：
                 # - 场景库完整性、11 大场景端到端（有断言强制 sample 覆盖全部内置场景）、
                 #   自定义场景合并/覆盖/patch/非法跳过
                 # - params 覆盖语义、确定性、失败路径（无网络、无 Key）
                 # - 插件入口装配（临时桩实例化：工具注册、降级、卸载）
                 # - 自动决策（开关、注入形状与自有 source.kind、fail-open、硬超时、
-                #   缓存与"改配置即失效"、去重、跳过规则、历史捕获、自动路由、卸载）
+                #   缓存与"改配置即失效"、去重、跳过规则、历史捕获、自动路由、
+                #   路由复用与热失效、失败熔断、卸载）
+                # - 用量台账（累计、跨日、重启后从文件恢复、坏行容错、日限判定）
+                # - 配置页（场景 JSON 校验、数字范围、保存被拒的冲突/校验区分、
+                #   加载态与"为什么不能保存"的渲染冒烟）
 ```
 
 ## 发布（CI / CD）
 
-仓库用 GitHub Actions 做持续集成与发布，两个工作流：
+仓库用 GitHub Actions 做持续集成与发布，三个工作流：
 
 | 工作流 | 触发 | 做什么 |
 |---|---|---|
-| [`ci.yml`](.github/workflows/ci.yml) | push / PR 到 `master`、`main`，或手动 | Node **22.19 / 24** 双版本跑 `npm run check` + `npm test`，再跑一次 `npm pack --dry-run` 确认产物完整 |
-| [`release.yml`](.github/workflows/release.yml) | push `v*` tag，或手动（默认演练） | 校验 tag ↔ 版本 → 校验 npm 上未重名 → 测试 → `npm publish --provenance` → 创建 GitHub Release |
-| [`probe.yml`](.github/workflows/probe.yml) | push / PR、每日定时、或手动 | **接缝探针**：对着三档真实宿主（peer 区间下限哨兵 / 当前基线 / master 预警档）跑 `npm run probe`，在隔离的临时 profile 里真装一次本包并断言组合后的 `id: systemone` 恰好一行；master 档只告警不挡合并 |
+| [`ci.yml`](.github/workflows/ci.yml) | push / PR 到 `master`、`main`，或手动 | Ubuntu 上 Node **22.19 / 24** 双版本 + **Windows / Node 24**（产品面向 Windows 桌面端）跑 `npm run check` + `npm test` + 文档数字校验，再跑 `npm pack --dry-run` 确认产物完整 |
+| [`release.yml`](.github/workflows/release.yml) | push `v*` tag，或手动（`dry_run` 默认开） | 校验 tag ↔ 版本（仅 tag 触发；手动触发按 `package.json` 版本走）→ 校验 npm 上未重名 → 测试 → `npm publish --provenance`（`dry_run=true` 时只 `--dry-run`）→ 创建 GitHub Release（仅 tag 触发） |
+| [`probe.yml`](.github/workflows/probe.yml) | push / PR、每日定时、或手动 | **接缝探针**：对着三档真实宿主（peer 区间下限哨兵 / 当前基线 / npm `alpha` 预发布预警档）跑 `npm run probe`，在隔离的临时 profile 里真装一次本包并断言组合后的 `id: systemone` 恰好一行；预警档只告警不挡合并 |
 
 ### 发一个版本
 

package/lib/auto.js

@@ -73,11 +73,22 @@ export const AUTO_DEFAULTS = {
   autoMaxMessages: 6,
   autoTimeoutMs: 8000,
   autoCacheTtlMs: 60000,
+  autoRouteCacheTtlMs: 180000,
+  autoFailureCooldownMs: 60000,
   autoRouteMinConfidence: 0.35,
   autoMinConfidence: 0.6,
   autoMinChars: 4,
 }
 
+/**
+ * 连续失败多少次触发熔断。
+ *
+ * 取 2 而不是 1：单次超时/网络抖动很常见，立刻暂停 60s 会让"偶发失败"变成
+ * "一段时间完全没有自动决策"，对用户是更难解释的行为。2 次连续失败已经
+ * 足以说明上游不可用。
+ */
+const FAILURE_TRIP_COUNT = 2
+
 /** fail-closed 档判定：closed 只对"本应得到决策却没有"的真失败生效（见各调用点）。 */
 function isFailClosed(config) {
   return readString(config, 'autoFailMode', 'open') === 'closed'
@@ -107,6 +118,22 @@ export function installAutoDecide(ctx, deps) {
   const inFlight = new Map()
   /** 已告警过的无效固定场景 id：同一错误只提示一次，避免每步刷日志。 */
   const warnedScenarios = new Set()
+  /** 已告警过的一次性提示（如"上游没给路由置信度"）：同样只提示一次。 */
+  const warnedFlags = new Set()
+  /**
+   * agentId → { scenarioId, confidence, at, fingerprint }。
+   *
+   * 自动路由是"每条新消息一次"的固定开销（多一次上游请求）。同一话题连续追问时
+   * 复用它，把"每条消息两次请求"降为一次。决策指纹（固定场景 / provider / model /
+   * 门槛 / 场景库）一变就失效，改配置不会被旧结果粘住。
+   */
+  const routeMemo = new Map()
+  /** 连续失败次数；成功一次即清零。 */
+  let consecutiveFailures = 0
+  /** 熔断截止时间戳；0 表示未熔断。 */
+  let breakerOpenUntil = 0
+  /** 已提示过的熔断窗口，避免冷区期间每条消息都刷一行日志。 */
+  let breakerLoggedUntil = 0
 
   const log = (level, message) => {
     try {
@@ -117,12 +144,48 @@ export function installAutoDecide(ctx, deps) {
     }
   }
 
+  /**
+   * 熔断是否打开。打开期间直接放行，绝不请求上游——
+   * 上游持续故障时，每条消息都等满 autoTimeoutMs 才是真正的用户伤害。
+   */
+  function breakerOpen() {
+    const now = Date.now()
+    if (breakerOpenUntil <= now) return false
+    if (breakerLoggedUntil !== breakerOpenUntil) {
+      breakerLoggedUntil = breakerOpenUntil
+      log('info', `自动决策熔断中（剩余 ${Math.ceil((breakerOpenUntil - now) / 1000)}s），本轮跳过；调小 autoFailureCooldownMs 或等待冷却`)
+    }
+    return true
+  }
+
+  /**
+   * 记一次**真失败**（请求异常 / 超时 / 场景执行失败）。
+   *
+   * 只统计失败、不统计"主动不注入"（寒暄、低置信度、斜杠命令）——后者说明
+   * 上游是好的，不能让它们参与熔断。
+   */
+  function recordFailure() {
+    consecutiveFailures += 1
+    const cooldown = readNumber(config, 'autoFailureCooldownMs', AUTO_DEFAULTS.autoFailureCooldownMs)
+    if (cooldown > 0 && consecutiveFailures >= FAILURE_TRIP_COUNT && breakerOpenUntil <= Date.now()) {
+      breakerOpenUntil = Date.now() + cooldown
+      log('warn', `自动决策连续 ${consecutiveFailures} 次失败，熔断 ${Math.round(cooldown / 1000)}s（配置 autoFailureCooldownMs，0 表示关闭）`)
+    }
+  }
+
+  /** 成功一次就清零：熔断只针对"持续失败"，不能让历史失败一直卡着后面的消息。 */
+  function recordSuccess() {
+    consecutiveFailures = 0
+    breakerOpenUntil = 0
+  }
+
   // agent 销毁时清理状态与 per-agent 监听器，避免长会话内存泄漏
   disposers.push(ctx.on('agent/disposed', (payload) => {
     const id = payload?.agent?.id
     if (id !== undefined) {
       perAgent.delete(id)
       lastInjected.delete(id)
+      routeMemo.delete(id)
       const list = agentDisposers.get(id)
       if (list) {
         for (const dispose of list) {
@@ -210,6 +273,10 @@ export function installAutoDecide(ctx, deps) {
       throw error
     }
 
+    // 别的监听器已经否决了这一步：无论决策算出什么都不可能注入，
+    // 先返回可以省掉一次路由 + 一次决策（上游是要计费的）。
+    if (decision?.kind === 'reject') return decision
+
     // context 通道：不在这里计算（会晚于 assembly），由入箱预计算 + 动态上下文负责
     if (readString(config, 'autoInject', 'message') !== 'message') return decision
 
@@ -219,6 +286,7 @@ export function installAutoDecide(ctx, deps) {
     if (!newText) return decision                       // 工具结果步骤 / 无新用户消息
     if (newText.trimStart().startsWith('/')) return decision  // 斜杠命令
     if (isTrivialInput(newText, readNumber(config, 'autoMinChars', AUTO_DEFAULTS.autoMinChars))) return decision     // 寒暄/致谢等无业务含义的输入
+    if (breakerOpen()) return decision                  // 上游刚连续失败过：冷却期内直接放行
 
     let injected = null
     try {
@@ -236,9 +304,13 @@ export function installAutoDecide(ctx, deps) {
             scenarios,
             cache,
             inFlight,
+            routeMemo,
+            onFailure: recordFailure,
+            onSuccess: recordSuccess,
             signal: timeout.signal,
             log,
             warnedScenarios,
+            warnedFlags,
             usage,
           }),
           timeoutMs,
@@ -247,6 +319,8 @@ export function installAutoDecide(ctx, deps) {
         timeout.dispose()
       }
     } catch (error) {
+      // 用户/宿主主动取消不算上游失败：两次中断不该把自动决策熔断 60s
+      if (!payload?.signal?.aborted) recordFailure()
       // fail-closed 档：决策管线失败 = 本轮没有可用决策，按 closed 语义否决
       // （宿主把 turn 记为 blocked）。open 档维持注入语义：记 warning 放行。
       if (isFailClosed(config)) {
@@ -281,6 +355,7 @@ export function installAutoDecide(ctx, deps) {
 
   /** 入箱预计算：异步算好并存进 perAgent，供 context 通道渲染。 */
   async function computeAndStore(agent, newText) {
+    if (breakerOpen()) return
     try {
       const timeoutMs = readNumber(config, 'autoTimeoutMs', AUTO_DEFAULTS.autoTimeoutMs)
       const timeout = combineSignal(undefined, timeoutMs)
@@ -294,9 +369,13 @@ export function installAutoDecide(ctx, deps) {
             scenarios,
             cache,
             inFlight,
+            routeMemo,
+            onFailure: recordFailure,
+            onSuccess: recordSuccess,
             signal: timeout.signal,
             log,
             warnedScenarios,
+            warnedFlags,
             usage,
           }),
           timeoutMs,
@@ -306,6 +385,7 @@ export function installAutoDecide(ctx, deps) {
         timeout.dispose()
       }
     } catch (error) {
+      recordFailure()
       log('warn', `入箱预计算失败（忽略）：${messageOf(error)}`)
     }
   }
@@ -388,13 +468,69 @@ function scenariosFingerprint(scenarios) {
   return `${list.length}:${parts.join(',')}`
 }
 
+/**
+ * 选出本次要用的场景：固定绑定优先；否则走自动路由，并在 TTL 内复用上次结果。
+ *
+ * 为什么要复用：自动路由是"每条新消息一次"的固定开销（多一次请求、多一份
+ * state），而同一话题的连续追问几乎必然落在同一个场景里。复用把"每条消息
+ * 两次请求"降为一次。决策指纹（固定场景 / provider / model / 两个门槛 /
+ * 场景库）一变立刻失效，改配置不会被旧结果粘住。
+ *
+ * 复用时来源标成「自动路由·复用」，注入文本与日志都能看出这不是新判定；
+ * 想每条消息都重新路由，把 autoRouteCacheTtlMs 设为 0。
+ */
+async function resolveRoute({ agent, newText, state, fingerprint, routeMemo, provider, config, scenarios, signal, log, warnedScenarios, usage }) {
+  // 固定场景是一次本地查找，没有请求，也就没有可复用的东西
+  if (readString(config, 'autoScenario', '').trim()) {
+    return resolveScenario({ state, provider, config, scenarios, signal, log, warnedScenarios, usage })
+  }
+
+  const ttl = readNumber(config, 'autoRouteCacheTtlMs', AUTO_DEFAULTS.autoRouteCacheTtlMs)
+  const agentId = agent?.id ?? 'unknown'
+  if (ttl > 0 && routeMemo) {
+    const memo = routeMemo.get(agentId)
+    if (memo && memo.fingerprint === fingerprint && Date.now() - memo.at < ttl) {
+      const scenario = findScenario(scenarios, memo.scenarioId)
+      if (scenario) {
+        log('info', `复用 ${Math.round((Date.now() - memo.at) / 1000)}s 前的路由结果：${scenario.id}`)
+        // autoRouted 是结构性标记：`autoRouteMinConfidence` 只对"真的路由过"的结果有意义，
+        // 固定绑定/唯一场景的 confidence 恒为 null，不能拿去和门槛比。
+        return { scenario, source: '自动路由·复用', confidence: memo.confidence, autoRouted: true }
+      }
+      // 场景被删掉了（自定义场景热更新）：丢掉这份记忆，走真路由
+      routeMemo.delete(agentId)
+    }
+  }
+
+  const routed = await resolveScenario({
+    state: captureRouteState(agent, newText),
+    provider,
+    config,
+    scenarios,
+    signal,
+    log,
+    warnedScenarios,
+    usage,
+  })
+  if (routed && ttl > 0 && routeMemo) {
+    routeMemo.set(agentId, {
+      scenarioId: routed.scenario.id,
+      confidence: routed.confidence,
+      at: Date.now(),
+      fingerprint,
+    })
+  }
+  return routed
+}
+
 /**
  * 计算决策（带并发去重）。相同 state 且决策参数未变时只发一次上游请求。
  */
-async function computeDecision({ agent, newText, provider, config, scenarios, cache, inFlight, signal, log, warnedScenarios, usage }) {
+async function computeDecision({ agent, newText, provider, config, scenarios, cache, inFlight, routeMemo, onFailure, onSuccess, signal, log, warnedScenarios, warnedFlags, usage }) {
   const state = captureState(agent, newText, readNumber(config, 'autoMaxMessages', AUTO_DEFAULTS.autoMaxMessages))
   // key = state 文本 + 决策指纹：state 决定"问什么"，指纹决定"按什么配置问"
-  const key = hashString(`${state}\u0000${decisionFingerprint(config, provider, scenariosFingerprint(scenarios))}`)
+  const fingerprint = decisionFingerprint(config, provider, scenariosFingerprint(scenarios))
+  const key = hashString(`${state}\u0000${fingerprint}`)
   const existing = inFlight.get(key)
   if (existing) return existing
   const promise = decide({
@@ -402,6 +538,10 @@ async function computeDecision({ agent, newText, provider, config, scenarios, ca
     newText,
     state,
     key,
+    fingerprint,
+    routeMemo,
+    onFailure,
+    onSuccess,
     provider,
     config,
     scenarios,
@@ -409,6 +549,7 @@ async function computeDecision({ agent, newText, provider, config, scenarios, ca
     signal,
     log,
     warnedScenarios,
+    warnedFlags,
     usage,
   }).finally(() => {
     if (inFlight.get(key) === promise) inFlight.delete(key)
@@ -417,23 +558,53 @@ async function computeDecision({ agent, newText, provider, config, scenarios, ca
   return promise
 }
 
-async function decide({ agent, newText, state, key, provider, config, scenarios, cache, signal, log, warnedScenarios, usage }) {
+async function decide({ agent, newText, state, key, fingerprint, routeMemo, onFailure, onSuccess, provider, config, scenarios, cache, signal, log, warnedScenarios, warnedFlags, usage }) {
   const ttl = readNumber(config, 'autoCacheTtlMs', AUTO_DEFAULTS.autoCacheTtlMs) || 0
   if (ttl > 0) {
     const hit = cache.get(key)
     if (hit && Date.now() - hit.at < ttl) return hit.result
   }
 
-  // 1) 选场景：固定绑定，或让模型做一次自动路由
-  const routed = await resolveScenario({ state, provider, config, scenarios, signal, log, warnedScenarios, usage })
+  // 1) 选场景：固定绑定，或（可能复用上次结果的）自动路由
+  const routed = await resolveRoute({
+    agent,
+    newText,
+    state,
+    fingerprint,
+    routeMemo,
+    provider,
+    config,
+    scenarios,
+    signal,
+    log,
+    warnedScenarios,
+    usage,
+  })
   if (!routed) return null
 
-  // 路由置信度不足：宁可不注入，也不要塞一个瞎猜的结论
+  // 路由置信度不足：宁可不注入，也不要塞一个瞎猜的结论。
+  //
+  // 只对**自动路由**生效：固定场景没有"路由置信度"这个概念（confidence 恒为 null），
+  // 早期用 `Number.isFinite(confidence)` 做前置判断，副作用是"上游没返回 confidence"
+  // 也会被当成"无法判定 → 放行"，等于悄悄绕过了用户设的门槛。现在缺失按 0 处理，
+  // 并提示一次该怎么恢复（把门槛设为 0，或改用固定场景）。
   const floor = readNumber(config, 'autoRouteMinConfidence', AUTO_DEFAULTS.autoRouteMinConfidence)
-  if (Number.isFinite(floor) && floor > 0
-    && Number.isFinite(routed.confidence) && routed.confidence < floor) {
-    log?.('info', `路由置信度 ${(routed.confidence * 100).toFixed(1)}% 低于阈值 ${(floor * 100).toFixed(0)}%，跳过注入`)
-    return null
+  if (routed.autoRouted === true && Number.isFinite(floor) && floor > 0) {
+    const confidenceKnown = Number.isFinite(routed.confidence)
+    if (!confidenceKnown) {
+      const flag = `route-confidence-missing:${readString(provider, 'name', 'unknown')}`
+      if (!warnedFlags?.has(flag)) {
+        warnedFlags?.add(flag)
+        log?.('warn', '上游没有返回路由置信度，已按 0 处理（不注入）；若该后端本就不返回 confidence，把 autoRouteMinConfidence 设为 0，或改用固定场景 autoScenario')
+      }
+    }
+    const confidence = confidenceKnown ? routed.confidence : 0
+    if (confidence < floor) {
+      // 这次上游是好的（路由拿到了回答）：算健康的"主动不注入"
+      onSuccess?.()
+      log?.('info', `路由置信度 ${(confidence * 100).toFixed(1)}% 低于阈值 ${(floor * 100).toFixed(0)}%，跳过注入`)
+      return null
+    }
   }
 
   // 2) 执行目标场景
@@ -448,11 +619,13 @@ async function decide({ agent, newText, state, key, provider, config, scenarios,
     usage,
   })
   if (!result?.ok) {
-    // 上游明确回答"决策失败"：closed 档必须上抛，让 pre-step 的 catch 按语义拦截；
-    // open 档维持原行为：warn + 不注入（= 放行）。
+    // 上游明确回答"决策失败"：closed 档必须上抛，让 pre-step 的 catch 按语义拦截
+    // （失败也由那个 catch 计数，这里不能重复计一次）；
+    // open 档维持原行为：计入熔断 + warn + 不注入（= 放行）。
     if (isFailClosed(config)) {
       throw new Error(`场景 ${routed.scenario.id} 执行失败：${result?.error || '未知错误'}`)
     }
+    onFailure?.()
     log?.('warn', `场景 ${routed.scenario.id} 执行失败，已放行：${result?.error || '未知错误'}`)
     return null
   }
@@ -465,6 +638,7 @@ async function decide({ agent, newText, state, key, provider, config, scenarios,
     headline: result.recommendation || routed.scenario.title,
     at: Date.now(),
   }
+  onSuccess?.()
   if (ttl > 0) {
     // 缓存上限：先清过期，再按插入序淘汰最旧，防止长会话无限增长
     if (cache.size >= MAX_AUTO_CACHE) {
@@ -579,7 +753,7 @@ async function resolveScenario({ state, provider, config, scenarios, signal, log
     return bc - ac
   })
   const best = candidates[0]
-  return { scenario: best.scenario, source: '自动路由', confidence: best.confidence }
+  return { scenario: best.scenario, source: '自动路由', confidence: best.confidence, autoRouted: true }
 }
 
 /** 把决策结果渲染成注入文本。 */
@@ -660,6 +834,30 @@ function captureState(agent, newText, maxMessages) {
   return parts.join('\n\n')
 }
 
+/** 路由用的历史条数：只为接住「那这个呢」这类短追问，不付整段历史的 token。 */
+const ROUTE_HISTORY_MESSAGES = 2
+
+/**
+ * 路由用的 state：最近两条历史 + 本轮请求。
+ *
+ * 自动路由只回答"这句话属于哪个业务域"，却和场景决策共用同一份 state——
+ * 默认 6 条 × 2000 字的历史被发两次。分类不需要那么多上下文，砍到两条历史，
+ * 路由请求的体积就从「决策级」降到「分类级」。
+ */
+function captureRouteState(agent, newText) {
+  const history = readHistory(agent, ROUTE_HISTORY_MESSAGES)
+  const current = truncate(newText, MAX_CURRENT_CHARS)
+  // 当前消息通常已写进 session.log，会被 readHistory 取到：去掉这份重复
+  const tailText = truncate(current, HISTORY_CHARS_PER_MESSAGE)
+  const tail = history[history.length - 1]
+  if (tail && tail.endsWith(`：${tailText}`)) history.pop()
+
+  const parts = []
+  if (history.length > 0) parts.push(`【近期对话】\n${history.join('\n')}`)
+  parts.push(`【当前请求】\n${current}`)
+  return parts.join('\n\n')
+}
+
 function readHistory(agent, limit) {
   const events = agent?.session?.log
   if (!Array.isArray(events)) return []

package/lib/client.js

@@ -71,6 +71,8 @@ window.__ModuleLoader__.load({
       endpointHint: '仅在「自建 / 兼容端点」时使用；留空则回退到基础地址',
       model: '模型名',
       modelHint: '默认 u2-decision',
+      usageLogPath: '用量台账路径',
+      usageLogPathHint: '留空则用 $DSH_HOME/dsh-systemone/usage.jsonl；保存后立即切换（新文件从当天记录恢复累计）',
       timeoutMs: '请求超时（毫秒）',
       timeoutMsHint: '单次决策请求的最长等待时间',
       minConfidence: '置信度阈值',
@@ -95,22 +97,34 @@ window.__ModuleLoader__.load({
       autoMaxMessagesHint: '自动决策时参考的最近消息数',
       autoCacheTtlMs: '结果缓存时长（毫秒）',
       autoCacheTtlMsHint: '相同内容在此时长内复用结果，0 表示不缓存',
+      autoRouteCacheTtlMs: '路由复用时长（毫秒）',
+      autoRouteCacheTtlMsHint: '同一会话内复用上次自动路由结果，期间只发场景决策请求；0 = 每条消息都重新路由',
+      autoFailureCooldownMs: '失败熔断时长（毫秒）',
+      autoFailureCooldownMsHint: '自动决策连续失败 2 次后暂停该时长（期间直接放行、不再请求上游）；0 = 关闭熔断',
       autoMinConfidence: '自动决策置信度阈值',
       autoMinConfidenceHint: '低于该值时结论会附带「请人工确认」提示',
       autoRouteMinConfidence: '自动路由置信度门槛',
       autoRouteMinConfidenceHint: '低于该值时宁可不注入，避免塞入瞎猜的结论',
-      autoMinChars: '最小触发长度（字符）',
-      autoMinCharsHint: '低于该长度、或整体就是寒暄/致谢时跳过',
+      autoMinChars: '寒暄判定上界（字符）',
+      autoMinCharsHint: '只有「短于该长度 且 整体是寒暄/致谢」才跳过；短业务请求（如「退款」）照常触发。0 = 不做长度限制',
       save: '保存',
       saving: '保存中…',
       revert: '撤销修改',
+      saveBlocked: '有 {count} 处填写问题，先修正才能保存：{reason}',
+      clearApiKey: '清除已保存的 Key',
+      clearApiKeyOn: '将清除（保存后生效）',
       saved: '已保存，立即生效',
       saveFailed: '保存失败，请检查填写内容',
       numberInvalid: '必须是有效数字',
       numberRequired: '数字字段不能为空',
+      numberRange: '超出允许范围（需 {bounds}）',
       conflict: '配置已被其他地方改动，已刷新为最新值，请重新修改',
+      saveRefused: '保存被宿主拒绝：有字段没通过校验（如超出允许范围或枚举值不合法），请修正后重试',
       readOnly: '当前不可编辑',
       noForm: '宿主要求该条目声明 volatile 配置字段后才会显示表单。',
+      loadingConfig: '正在读取配置…',
+      unavailableConfig: '宿主没有向该页面提供这份配置（unavailable）',
+      unknownOption: '未知值',
       summary: 'SystemOne 决策模型配置',
       current: '当前：{provider} · {model}',
       expand: '展开',
@@ -152,6 +166,8 @@ window.__ModuleLoader__.load({
       endpointHint: 'Used only by the custom/compatible provider; falls back to the base URL',
       model: 'Model',
       modelHint: 'Defaults to u2-decision',
+      usageLogPath: 'Usage ledger path',
+      usageLogPathHint: 'Empty means $DSH_HOME/dsh-systemone/usage.jsonl; changing it applies immediately (today totals are restored from the new file)',
       timeoutMs: 'Request timeout (ms)',
       timeoutMsHint: 'Longest wait for one decision request',
       minConfidence: 'Confidence threshold',
@@ -176,22 +192,34 @@ window.__ModuleLoader__.load({
       autoMaxMessagesHint: 'How many recent messages the automatic decision reads',
       autoCacheTtlMs: 'Result cache TTL (ms)',
       autoCacheTtlMsHint: 'Reuse a result for identical input; 0 disables caching',
+      autoRouteCacheTtlMs: 'Route reuse window (ms)',
+      autoRouteCacheTtlMsHint: 'Reuse the previous auto-route result within a session — only the scenario request is sent; 0 re-routes every message',
+      autoFailureCooldownMs: 'Failure cooldown (ms)',
+      autoFailureCooldownMsHint: 'Pause auto decisions for this long after 2 consecutive failures (steps proceed untouched); 0 disables the breaker',
       autoMinConfidence: 'Auto decision confidence threshold',
       autoMinConfidenceHint: 'Below this value the conclusion carries a human-review note',
       autoRouteMinConfidence: 'Auto routing confidence floor',
       autoRouteMinConfidenceHint: 'Below this value nothing is injected rather than guessing',
-      autoMinChars: 'Minimum trigger length (chars)',
-      autoMinCharsHint: 'Skipped when shorter than this, or when it is a bare greeting',
+      autoMinChars: 'Greeting length bound (chars)',
+      autoMinCharsHint: 'Skipped only when shorter than this AND it is a bare greeting; short real requests (e.g. "refund") still trigger. 0 disables the length check',
       save: 'Save',
       saving: 'Saving…',
       revert: 'Revert changes',
+      saveBlocked: '{count} field issue(s) must be fixed before saving: {reason}',
+      clearApiKey: 'Clear the saved key',
+      clearApiKeyOn: 'Will be cleared on save',
       saved: 'Saved — applied immediately',
       saveFailed: 'Save failed — check the values',
       numberInvalid: 'Must be a valid number',
       numberRequired: 'Number fields cannot be empty',
+      numberRange: 'Out of range (allowed: {bounds})',
       conflict: 'The configuration changed elsewhere; the newest values were reloaded',
+      saveRefused: 'The Host rejected the save: a field failed validation (range or enum). Fix it and try again',
       readOnly: 'Read-only right now',
       noForm: 'The host exposes a form only when the entry declares volatile config fields.',
+      loadingConfig: 'Loading configuration…',
+      unavailableConfig: 'The Host does not expose this configuration to the page (unavailable)',
+      unknownOption: 'unknown',
       summary: 'SystemOne decision model configuration',
       current: 'Current: {provider} · {model}',
       expand: 'Expand',
@@ -315,9 +343,13 @@ window.__ModuleLoader__.load({
       { key: 'baseUrl', kind: 'text' },
       { key: 'endpoint', kind: 'text' },
       { key: 'model', kind: 'text' },
-      { key: 'timeoutMs', kind: 'number' },
-      { key: 'minConfidence', kind: 'number' },
+      // min/max 必须与 lib/index.js 的 z.number().min().max() 一致：
+      // 越界值会被宿主在保存/热更新链路里拒绝，界面不提前拦就会「显示已保存、实际不生效」。
+      { key: 'timeoutMs', kind: 'number', min: 1000 },
+      { key: 'minConfidence', kind: 'number', min: 0, max: 1 },
       { key: 'redact', kind: 'select', options: ['false', 'true'] },
+      // 台账路径也是 volatile：保存后宿主重建台账（新文件从当天记录恢复累计）
+      { key: 'usageLogPath', kind: 'text' },
     ]
 
     /** 自定义场景编辑区（JSON）。 */
@@ -419,12 +451,14 @@ window.__ModuleLoader__.load({
       { key: 'autoScenario', kind: 'datalist', options: SCENARIO_OPTIONS },
       { key: 'autoInject', kind: 'select', options: ['message', 'context'] },
       { key: 'autoFailMode', kind: 'select', options: ['open', 'closed'] },
-      { key: 'autoTimeoutMs', kind: 'number' },
-      { key: 'autoMaxMessages', kind: 'number' },
-      { key: 'autoCacheTtlMs', kind: 'number' },
-      { key: 'autoMinConfidence', kind: 'number' },
-      { key: 'autoRouteMinConfidence', kind: 'number' },
-      { key: 'autoMinChars', kind: 'number' },
+      { key: 'autoTimeoutMs', kind: 'number', min: 500 },
+      { key: 'autoMaxMessages', kind: 'number', min: 1, max: 50 },
+      { key: 'autoCacheTtlMs', kind: 'number', min: 0 },
+      { key: 'autoRouteCacheTtlMs', kind: 'number', min: 0 },
+      { key: 'autoFailureCooldownMs', kind: 'number', min: 0 },
+      { key: 'autoMinConfidence', kind: 'number', min: 0, max: 1 },
+      { key: 'autoRouteMinConfidence', kind: 'number', min: 0, max: 1 },
+      { key: 'autoMinChars', kind: 'number', min: 0 },
     ]
 
     /** 选项字段的显示名走字典，例如 provider 的 unisound → 「云知声（官方）」。 */
@@ -454,6 +488,50 @@ window.__ModuleLoader__.load({
       return String(value)
     }
 
+    /**
+     * 数字字段的客户端校验：空值 / 非数字 / 超出宿主 schema 的范围。
+     *
+     * 范围校验是必须的：schema 的范围约束在宿主侧才生效，界面如果只查"是不是数字"，
+     * 越界值会先显示「已保存，立即生效」，随后要么被拒、要么静默不生效。
+     * 返回 undefined 表示通过。
+     *
+     * @param {{key:string, min?:number, max?:number}} field - 字段元数据
+     * @param {unknown} rawValue - 草稿里的原始值（字符串）
+     * @param {(key:string, params?:object) => string} t - 翻译函数
+     * @returns {string|undefined}
+     */
+    function numberErrorFor(field, rawValue, t) {
+      const raw = String(rawValue ?? '').trim()
+      if (raw === '') return t('numberRequired')
+      const value = Number(raw)
+      if (!Number.isFinite(value)) return t('numberInvalid')
+      const min = Number.isFinite(field?.min) ? field.min : undefined
+      const max = Number.isFinite(field?.max) ? field.max : undefined
+      const tooSmall = min !== undefined && value < min
+      const tooLarge = max !== undefined && value > max
+      if (!tooSmall && !tooLarge) return undefined
+      const bounds = min !== undefined && max !== undefined
+        ? `${min}~${max}`
+        : min !== undefined ? `≥ ${min}` : `≤ ${max}`
+      return t('numberRange', { bounds })
+    }
+
+    /**
+     * 保存被宿主拒绝时的提示文案。
+     *
+     * 宿主对 `mutate()` 返回 false 有两种含义：revision 被别人推进了（并发冲突，
+     * 草稿已过期），或值本身没通过 schema 校验。一律报「配置已被其他地方改动」
+     * 会把输入错误误导成并发问题，所以按 revision 是否变化区分。
+     *
+     * @param {{ok:boolean, revision?:number, latestRevision?:number}} outcome
+     * @param {(key:string) => string} t
+     * @returns {string|undefined} ok 为真时无文案
+     */
+    function saveResultText({ ok, revision, latestRevision }, t) {
+      if (ok) return undefined
+      return latestRevision !== revision ? t('conflict') : t('saveRefused')
+    }
+
     /* ────────────────────────────── 组件 ────────────────────────────── */
 
     /**
@@ -491,15 +569,25 @@ window.__ModuleLoader__.load({
       let control
       if (field.kind === 'select') {
         // 注意：jsx(type, props, key) 的第三个参数是 key，children 必须放进 props
+        // 值不在候选里时（例如手改 cordis.patch.yml 写成 provider: openai），
+        // 浏览器会把 select 显示成第一项，形成"看起来是云知声、实际是 openai"的脏回显。
+        // 补一个显式的"未知值"选项，让界面说的是真话。
+        const text = String(value ?? '')
+        const unknown = text !== '' && !field.options.includes(text)
         control = h('select', {
           id: controlId,
           style: inputStyle,
           value: value,
           disabled,
           onChange: (event) => onChange(field.key, event.target.value),
-          children: field.options.map((option) =>
-            h('option', { key: option, value: option, children: optionLabel(t, field.key, option) }),
-          ),
+          children: [
+            ...(unknown
+              ? [h('option', { key: '__unknown__', value: text, children: `${text}（${t('unknownOption')}）` })]
+              : []),
+            ...field.options.map((option) =>
+              h('option', { key: option, value: option, children: optionLabel(t, field.key, option) }),
+            ),
+          ],
         })
       } else if (field.kind === 'datalist') {
         // 带候选的输入框：可直接点选内置场景，也能手填自定义场景 id / 别名
@@ -606,6 +694,8 @@ window.__ModuleLoader__.load({
       const [draft, setDraft] = react.useState(null)
       const [busy, setBusy] = react.useState(false)
       const [notice, setNotice] = react.useState(null)
+      // apiKey 是 secret：宿主快照里拿不到它，所以「清空」只能是独立意图，不能靠输入框清空（空值代表"不修改"）
+      const [clearApiKey, setClearApiKey] = react.useState(false)
 
       const live = form?.state?.value ?? {}
       const revision = form?.state?.revision
@@ -627,6 +717,16 @@ window.__ModuleLoader__.load({
         return h('p', { style: statusStyle, children: t('noForm') })
       }
 
+      // 快照还没到（loading）或本部署不提供该命名空间（unavailable）时，别把空表单渲染成
+      // 一片"数字字段不能为空 + 保存按钮全灰"——那看起来像用户填错了。
+      const status = form?.state?.status
+      if (status !== undefined && status !== 'ready') {
+        return h('p', {
+          style: statusStyle,
+          children: status === 'loading' ? t('loadingConfig') : t('unavailableConfig'),
+        })
+      }
+
       const ALL_FIELDS = [...SERVICE_FIELDS, ...CUSTOM_FIELDS, ...AUTO_FIELDS]
       const current = {}
       for (const field of ALL_FIELDS) current[field.key] = toDraft(live[field.key])
@@ -642,18 +742,27 @@ window.__ModuleLoader__.load({
       const numberErrors = {}
       for (const field of ALL_FIELDS) {
         if (field.kind !== 'number') continue
-        const raw = String(values[field.key] ?? '').trim()
-        if (raw === '') numberErrors[field.key] = t('numberRequired')
-        else if (!Number.isFinite(Number(raw))) numberErrors[field.key] = t('numberInvalid')
+        const error = numberErrorFor(field, values[field.key], t)
+        if (error) numberErrors[field.key] = error
       }
       const numberExtras = {}
       for (const [key, error] of Object.entries(numberErrors)) {
         numberExtras[key] = { error }
       }
 
-      const dirty = draft !== null && Object.keys(draft).some((key) => draft[key] !== current[key])
+      const dirty = clearApiKey || (draft !== null && Object.keys(draft).some((key) => draft[key] !== current[key]))
       const canSave = dirty && !busy && writable && customCheck.ok && Object.keys(numberErrors).length === 0
 
+      // 保存按钮为什么是灰的，必须写在界面上：三张卡共用一个 canSave，
+      // 而错误只出现在出问题的那张卡里（「自定义场景」卡还默认折叠）。
+      // 否则用户看到的是一个没有任何解释的灰按钮。
+      const blockers = []
+      if (!customCheck.ok && customErrorText) blockers.push(`${t('tabCustom')}：${customErrorText}`)
+      for (const [key, error] of Object.entries(numberErrors)) blockers.push(`${t(key)}：${error}`)
+      const blockedText = blockers.length > 0
+        ? t('saveBlocked', { count: blockers.length, reason: blockers[0] })
+        : undefined
+
       // 「固定场景」候选 = 11 个内置 + 当前生效的自定义场景 id（patch 条目指向已有 id，去重避免重复项）
       const scenarioOptions = [
         ...SCENARIO_OPTIONS,
@@ -666,6 +775,8 @@ window.__ModuleLoader__.load({
 
       const onFieldChange = (key, value) => {
         setNotice(null)
+        // 用户开始输入新 Key 时，「清除」这个意图就作废了——否则会先 set 再 unset。
+        if (key === 'apiKey' && clearApiKey) setClearApiKey(false)
         setDraft((previous) => ({ ...(previous ?? {}), [key]: value }))
       }
 
@@ -691,6 +802,9 @@ window.__ModuleLoader__.load({
             if (key === 'redact') next = value === 'true'
             ops.push({ op: 'set', path: [key], value: next })
           }
+          // 「清除已保存的 Key」是独立意图：schema 的 unset 才是"取消覆盖、回到默认"，
+          // 用空字符串 set 只会写进一个空值。
+          if (clearApiKey) ops.push({ op: 'unset', path: ['apiKey'] })
           if (ops.length === 0) {
             setDraft(null)
             return
@@ -698,9 +812,13 @@ window.__ModuleLoader__.load({
           const ok = await form.mutate(ops, revision)
           if (ok) {
             setDraft(null)
+            setClearApiKey(false)
             setNotice({ kind: 'ok', text: t('saved') })
           } else {
-            setNotice({ kind: 'error', text: t('conflict') })
+            setNotice({
+              kind: 'error',
+              text: saveResultText({ ok, revision, latestRevision: form?.state?.revision }, t),
+            })
           }
         } catch {
           setNotice({ kind: 'error', text: t('saveFailed') })
@@ -732,6 +850,9 @@ window.__ModuleLoader__.load({
           notice !== null
             ? h('span', { key: 'notice', style: notice.kind === 'ok' ? statusStyle : errorStyle, children: notice.text })
             : null,
+          blockedText !== undefined
+            ? h('span', { key: 'blocked', style: errorStyle, children: blockedText })
+            : null,
           !writable ? h('span', { key: 'ro', style: statusStyle, children: t('readOnly') }) : null,
         ],
       })
@@ -742,7 +863,7 @@ window.__ModuleLoader__.load({
         style: footerStyle,
         children: [
           h('button', { key: 'save', type: 'button', style: { ...primaryButton, opacity: canSave ? 1 : 0.5 }, disabled: !canSave, onClick: onSave, children: busy ? t('saving') : t('save') }),
-          ...(showRevert ? [h('button', { key: 'revert', type: 'button', style: ghostButton, disabled: !dirty || busy, onClick: () => { setDraft(null); setNotice(null) }, children: t('revert') })] : []),
+          ...(showRevert ? [h('button', { key: 'revert', type: 'button', style: ghostButton, disabled: !dirty || busy, onClick: () => { setDraft(null); setNotice(null); setClearApiKey(false) }, children: t('revert') })] : []),
           ...(extra ? [extra] : []),
           statusLine,
         ],
@@ -760,7 +881,23 @@ window.__ModuleLoader__.load({
             // 注意：jsx(type, props, key) 的第三个参数是 key，正文必须作为 children 放进 props
             children: hs(Fragment, {
               children: [
-                ...renderFields(SERVICE_FIELDS, numberExtras),
+                ...renderFields(SERVICE_FIELDS, {
+                  ...numberExtras,
+                  apiKey: {
+                    // 已保存的 Key 不回显（secret 被宿主剔除），所以只能给一个显式的"清除"动作
+                    extra: h('button', {
+                      key: 'clear-key',
+                      type: 'button',
+                      style: { ...ghostButton, height: 24, padding: '0 8px', fontSize: 12 },
+                      disabled: !writable || busy,
+                      onClick: () => {
+                        setClearApiKey((value) => !value)
+                        setDraft((previous) => ({ ...(previous ?? {}), apiKey: '' }))
+                      },
+                      children: clearApiKey ? t('clearApiKeyOn') : t('clearApiKey'),
+                    }),
+                  },
+                }),
                 renderFooter({ showRevert: true }),
               ],
             }),
@@ -892,7 +1029,17 @@ window.__ModuleLoader__.load({
     exports.inject = inject
     exports.apply = apply
     // 仅供测试：暴露纯函数（宿主只读 name/inject/apply，多余导出对宿主无影响）
-    exports.__internals = { validateCustomScenarios, describeCustomError }
+    exports.__internals = {
+      // 组件也导出：UI 没有 DOM 测试环境，但「渲染一次不抛错 + 走对分支」是能测的冒烟底线
+      SystemOneConfigPage,
+      validateCustomScenarios,
+      describeCustomError,
+      numberErrorFor,
+      saveResultText,
+      SERVICE_FIELDS,
+      CUSTOM_FIELDS,
+      AUTO_FIELDS,
+    }
     return module.exports
   },
 })

package/lib/index.d.ts

@@ -40,15 +40,19 @@ export interface Config {
   /** 自动决策固定使用的场景 id；留空则自动路由 */
   autoScenario?: string
   /** 注入通道：message=同一步生效并去重；context=宿主动态上下文（不写历史） */
-  autoInject?: string
+  autoInject?: 'message' | 'context'
   /** 自动决策失败语义：open=放行（默认）；closed=决策失败时否决本轮（供将来做闸门用，仅 message 通道） */
-  autoFailMode?: string
+  autoFailMode?: 'open' | 'closed'
   /** 自动决策超时（毫秒） */
   autoTimeoutMs?: number
   /** 捕获的历史消息条数 */
   autoMaxMessages?: number
   /** 相同内容的结果缓存时长（毫秒），0 表示不缓存 */
   autoCacheTtlMs?: number
+  /** 自动路由结果的复用时长（毫秒）：0 = 每条消息都重新路由 */
+  autoRouteCacheTtlMs?: number
+  /** 连续 2 次失败后的熔断时长（毫秒）：0 = 关闭熔断 */
+  autoFailureCooldownMs?: number
   /** 自动决策使用的置信度阈值 */
   autoMinConfidence?: number
   /** 自动路由的置信度门槛 */
@@ -125,10 +129,27 @@ declare module '@deepseek-ai/cordis' {
 
 export default class SystemOneService extends Service {
   static Config: any
+  /**
+   * 插件配置的原始对象。
+   *
+   * **注意**：标了 `.volatile()` 的字段在这里是 cosmokit 的引用对象，不是字符串/数字；
+   * 直接读类型是骗人的（`config.model` 会得到一个对象）。需要值时用 `lib/volatile.js`
+   * 的 `unwrap()` 解壳——插件内部所有读取都走它。
+   */
   readonly config: Config
+  /** 当前提供商（热切换时由代理转发到新实例，可长期持有）。 */
   readonly provider: {
     name: string
     decide(options: DecideOptions): Promise<Record<string, unknown>>
+    /** 解析出的请求端点（外发声明用）。 */
+    resolveEndpoint(): string
+  }
+  /** 用量台账的转发对象；`usageLogPath` 变化时内部会换到新台账。 */
+  readonly usageLedger: {
+    record(entry: Record<string, unknown>): unknown
+    today(now?: number): { day: string, calls: number, tokens: number, failures: number }
+    check(limits?: { dailyCallLimit?: number, dailyTokenLimit?: number }): { allowed: boolean, reason?: string }
+    formatToday(now?: number): string
   }
 
   constructor(ctx: Context, config: Config)

package/lib/index.js

@@ -142,6 +142,16 @@ const Config = z.object({
   autoMaxMessages: z.number().min(1).max(50).default(AUTO_DEFAULTS.autoMaxMessages).volatile(),
   /** 相同内容的结果缓存时长（毫秒），0 表示不缓存 */
   autoCacheTtlMs: z.number().min(0).default(AUTO_DEFAULTS.autoCacheTtlMs).volatile(),
+  /**
+   * 自动路由结果的复用时长（毫秒）：同一会话内同话题连续消息只路由一次。
+   * 0 = 每条消息都重新路由（多一次上游请求）。
+   */
+  autoRouteCacheTtlMs: z.number().min(0).default(AUTO_DEFAULTS.autoRouteCacheTtlMs).volatile(),
+  /**
+   * 连续失败 2 次后的熔断时长（毫秒）：期间自动决策直接放行、不再请求上游。
+   * 0 = 关闭熔断。
+   */
+  autoFailureCooldownMs: z.number().min(0).default(AUTO_DEFAULTS.autoFailureCooldownMs).volatile(),
   /** 自动决策使用的置信度阈值 */
   autoMinConfidence: z.number().min(0).max(1).default(AUTO_DEFAULTS.autoMinConfidence).volatile(),
   /** 自动路由的置信度门槛：低于该值宁可不注入，避免塞入瞎猜的结论 */
@@ -200,7 +210,18 @@ export default class SystemOneService extends Service {
 
     // 用量台账：工具路径与自动路径都记账（含路由请求），让花销可见。
     // 台账写盘失败会降级为仅内存统计，绝不影响决策。
-    this.usageLedger = createUsageLedger({ path: readString(config, 'usageLogPath', ''), logger: ctx.logger })
+    //
+    // usageLogPath 是 volatile 字段：路径一变就换一个台账实例（新实例会从新文件
+    // 里恢复当日累计）。调用方拿到的是一个**转发对象**而不是台账本身，
+    // 所以装配期就持有它的工具/自动决策不需要重新装配——与 provider 代理同一原则。
+    this._ledgerPath = readString(config, 'usageLogPath', '')
+    this._ledger = createUsageLedger({ path: this._ledgerPath, logger: ctx.logger })
+    this.usageLedger = {
+      record: (entry) => this.currentLedger().record(entry),
+      today: (now) => this.currentLedger().today(now),
+      check: (limits) => this.currentLedger().check(limits),
+      formatToday: (now) => this.currentLedger().formatToday(now),
+    }
 
     // inject 保证 ctx.tools 存在；注册失败必须显式抛出，绝不静默降级
     const tools = ctx.get('tools') ?? ctx.tools
@@ -317,6 +338,22 @@ export default class SystemOneService extends Service {
     return this._provider
   }
 
+  /**
+   * 当前用量台账；`usageLogPath` 变化时重建。
+   *
+   * 台账不是无状态服务（它持有当日累计），所以不能像 provider 那样只换引用：
+   * 换路径要造一个新实例，让新实例从**新文件**里恢复当日累计（见 usage.js 的
+   * restoreDay），否则换路径后「今日用量」会凭空归零或串到旧文件上。
+   */
+  currentLedger() {
+    const path = readString(this.config, 'usageLogPath', '')
+    if (path !== this._ledgerPath) {
+      this._ledgerPath = path
+      this._ledger = createUsageLedger({ path, logger: this.ctx?.logger })
+    }
+    return this._ledger
+  }
+
   /** 未知 provider 值会在 provider.js 里静默回退到 unisound，这里负责告警（每个未知值只提示一次）。 */
   _warnUnknownProvider(kind) {
     if (KNOWN_PROVIDERS.includes(kind) || this._warnedProviders.has(kind)) return

package/lib/usage.js

@@ -9,17 +9,27 @@
  *   - 每次调用**追加**一行 JSONL，包括失败/超时的调用（失败也可能已计费）；
  *   - 日限在**发请求之前**判定并拒绝，附上该改哪个配置项；
  *   - 台账不可写时降级为「仅内存」，绝不因为记账失败而让决策失败（fail-open 记账）；
- *   - 计数按**本地日**切分，跨日自动归零，不需要定时任务。
+ *   - 计数按**本地日**切分，跨日自动归零，不需要定时任务；
+ *   - 进程启动时从文件尾部**恢复当日累计**：重启不是新的一天，重启后的「今日用量」
+ *     与日限必须接着算（早期版本只累加内存，重启即归零）。
  *
  * 模块无第三方依赖，使用 node:fs / node:os / node:path。
  */
-import { appendFileSync, mkdirSync } from 'node:fs'
+import { appendFileSync, closeSync, mkdirSync, openSync, readSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
 /** token 数缺失时的兜底（上游不保证返回 usage）。 */
 const UNKNOWN_TOKENS = 0
 
+/**
+ * 重启后恢复当日累计时最多回读的字节数。
+ *
+ * 台账是旁路设施，不能为了恢复它把一个长年累月只追加的大文件整个读进内存；
+ * 2 MB 约等于上万次调用，足够覆盖"同一天内的重启"。
+ */
+const RESTORE_MAX_BYTES = 2 * 1024 * 1024
+
 /** 本地日键，形如 2026-10-05。 */
 function localDayKey(now = Date.now()) {
   const d = new Date(now)
@@ -54,6 +64,63 @@ export function usageLogPath(dir) {
   return join(base, 'usage.jsonl')
 }
 
+/**
+ * 从台账文件尾部恢复某个本地日的累计。
+ *
+ * 为什么需要：`totals` 是进程内状态，宿主一重启就归零——而用户看到的「今日用量」
+ * 以及将来的日限判定都基于它。重启不是新的一天，账必须接着算。
+ *
+ * 三条容错：文件不存在 → 全 0；行是半截/坏 JSON → 跳过该行；读盘本身失败 → 全 0。
+ * 台账坏了绝不能让插件起不来，也不能让决策失败。
+ *
+ * @param {string} file - 台账文件绝对路径
+ * @param {string} day - 本地日键（与写入时的 `day` 同源）
+ * @returns {{calls:number, tokens:number, failures:number}}
+ */
+function restoreDay(file, day) {
+  const zero = { calls: 0, tokens: 0, failures: 0 }
+  let text = ''
+  let partialHead = false
+  try {
+    const stat = statSync(file, { throwIfNoEntry: false })
+    if (!stat || stat.size === 0) return zero
+    const start = Math.max(0, stat.size - RESTORE_MAX_BYTES)
+    partialHead = start > 0
+    const length = stat.size - start
+    const buffer = Buffer.alloc(length)
+    const fd = openSync(file, 'r')
+    try {
+      const read = readSync(fd, buffer, 0, length, start)
+      text = buffer.subarray(0, read).toString('utf8')
+    } finally {
+      closeSync(fd)
+    }
+  } catch {
+    return zero
+  }
+
+  const lines = text.split('\n')
+  // 从文件中段开始读时，第一行几乎必然是被截断的半条记录
+  if (partialHead) lines.shift()
+
+  const totals = { ...zero }
+  for (const line of lines) {
+    if (!line.trim()) continue
+    let entry
+    try {
+      entry = JSON.parse(line)
+    } catch {
+      continue // 写到一半的坏行：忽略，不因它丢掉整天的账
+    }
+    if (!entry || entry.day !== day) continue
+    totals.calls += 1
+    const tokens = Number(entry.input_tokens)
+    if (Number.isFinite(tokens) && tokens > 0) totals.tokens += Math.floor(tokens)
+    if (entry.ok === false) totals.failures += 1
+  }
+  return totals
+}
+
 /** 从任意形态的 usage 字段里取 input_tokens（容忍缺字段与字符串）。 */
 function inputTokensOf(usage) {
   const value = Number(usage?.input_tokens)
@@ -74,8 +141,12 @@ export function createUsageLedger(options = {}) {
     : usageLogPath('')
   const logger = options.logger
 
-  /** 内存累计：{ day, calls, tokens, failures, refused } —— 读取时先按天校验再复用 */
-  let totals = { day: localDayKey(), calls: 0, tokens: 0, failures: 0 }
+  /**
+   * 内存累计：{ day, calls, tokens, failures } —— 读取时先按天校验再复用。
+   * 构造时从文件尾部恢复当日累计，让「今日用量」与日限跨进程重启依然连续。
+   */
+  const initialDay = localDayKey()
+  let totals = { day: initialDay, ...restoreDay(file, initialDay) }
   /** 写盘是否失败过（只告警一次，避免每一步刷日志） */
   let writeFailed = false
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@master0071/dsh-systemone",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "DeepSeek Harness 插件：将 SystemOne 决策模型（默认云知声 u2-decision，可切换提供商）接入软件开发、需求预检、客服、内容审核、路由、销售线索、风控、招聘、数据治理、教育、需求变更等 11 大业务场景，为 Agent 返回带概率分布的决策与处置建议。",
   "license": "MIT",
   "type": "module",