@leonhardthust/dsh-decision-engine 1.9.2 → 1.11.0

package/README.md

@@ -32,10 +32,11 @@ main model acts.
 **Providers**: system one · bamboonode · 硅基流动 SiliconFlow (CN / Global) ·
 Perplexity · OpenRouter · custom base URL
 
-**Review tolerance**: autonomous · relaxed · default · cautious
+**Safety level (how often to ask)**: Don't ask · Ask less · Default · Ask more
+(none of the four changes permission-mandated approval or denial)
 
 **UI**: config page with collapsible sections · Decisions tab · stats ·
-readable approval card
+readable approval card · sharded decision logs (by date / session / workspace) with retention
 
 | Config page | Decisions tab |
 |---|---|

package/README.zh.md

@@ -31,10 +31,10 @@
 **决策服务**：system one · bamboonode · 硅基流动 SiliconFlow（国内 / 国际）·
 Perplexity · OpenRouter · 自定义 base URL
 
-**人工审核比例**：自治 · 轻松 · 默认 · 谨慎
+**安全档位（询问频率）**：不问 · 少问 · 默认 · 多问（四档都不改变权限强制的人工批准与拒绝）
 
 **界面**：配置页（四个可折叠分组）· 决策历史标签页 · 统计与对比 ·
-审批卡正文可读化
+审批卡正文可读化 · 决策日志分文件（按日期 / 会话 / 工作区）与自动清理
 
 | 配置页 | 决策历史 |
 |---|---|

package/config.example.yml

@@ -232,11 +232,14 @@ cooldownProbeMs: 10000
 # cooldownMs: 60000         # 首轮冷却时长（上限为其 10 倍）
 # failureThreshold: 3       # 连续失败多少次进入冷却
 
-# 思考模式（startlux 的 think_mode），三档：
-#   never  不思考——最省延迟（实测约 1.9s vs 7.2s），默认值，热路径首选
-#   auto   仅在模型自己判断需要时思考——折中
-#   always 总是思考——判断更充分，但每次工具调用约多等 5 秒
-# 该端点 output_tokens 恒为 0，思考开销不计入计量，所以省的主要是延迟。
+# 决策模型思考（startlux / System One 的 think_mode），三档：
+#   never  跳过思考——最省延迟（bamboonode 实测约 1.9s），默认值，热路径首选
+#   auto   由服务端决定——实测比 never 慢（约 7.2s），“按需”在实践中常常等于思考
+#   always 总是思考——每次约多等 5 秒；质量收益尚未实测
+# 它**只影响本插件发给决策端点的请求**，不改宿主主模型的推理档位（那个在
+# 「自动审查回退 › 推理档位」）。bamboonode/startlux 已实测支持；systemone、
+# 两个 SiliconFlow 与 custom 未实测（会照常发送，可能被忽略、不报错）；
+# Perplexity / OpenRouter 的公开 API 没有这个字段。
 thinkMode: never
 
 # ============================================================================
@@ -254,7 +257,8 @@ pointAuthorize: auto
 
 # ---- 2. 模型路由：机械步骤下沉到便宜模型 -----------------------------------
 # 热路径。三道闸控量：每轮最多 routeMaxStepsPerTurn 步、路由未变不问、
-# 新用户输入后的步骤不问。
+# 最近一条是用户消息就不问（**含每轮第一步**——新任务开局没有「下一步是
+# 机械活」的证据，不该一上来就下沉）。
 # 必须同时配好 routeCheapProvider + routeCheapModel 才会真的换模型；
 # 两者留空时即便打开此点也只会记录「本该换」。
 pointRoute: off
@@ -266,7 +270,8 @@ routeCheapModel: ""
 # routeRiskFloor: 0.3       # 风险达线一律保留强模型
 
 # ---- 3. 子任务分派：接着做 / 开 subagent / 组 agent team -------------------
-# 热路径。只在每轮第一步且带新用户输入时判断（分派只在这一刻可能改变）。
+# 热路径。只在每轮第一步、且本步带**真正来自用户**的消息时判断。插件自己
+# 注入的 [decision-engine-*] 提示不算用户任务（否则会对着自己的建议再判一次）。
 # 生效时注入一条提示，不替模型决定——工具选择仍归模型。
 pointDelegate: off
 # delegateConfidenceFloor: 0.5  # 三选项均分 0.33，实测需 ≥0.5 才算有倾向
@@ -275,18 +280,23 @@ pointDelegate: off
 
 # ---- 4. 上下文压缩：摘要 vs 只丢陈旧工具结果 -------------------------------
 # 非热路径。只在实测 token 达触发线（compactThresholdRatio × 窗口）才问。
-# 生效方式：先跑宿主的确定性工具结果裁剪；compaction-basic 随后重新测压，
-# 低于阈值就跳过摘要——这才是真正省下的那一次调用。
+# 默认**不会**只裁剪：state 里只有「有几条超长结果」，看不到它们是什么、
+# 哪些结论真的保住了，而裁剪不可逆。默认一律交给宿主的摘要压缩；只有
+# compactAllowPrune: true 才允许「只丢陈旧工具结果、跳过摘要」。
 pointCompact: off
 # compactContextWindow: 0     # 0 = 用 compactTriggerTokens 绝对阈值
 # compactThresholdRatio: 0.7  # 提前于 compaction-basic 的 0.8 介入
 # compactTriggerTokens: 100000
 # compactToolResultChars: 8192
-# compactDistilledFloor: 0.6  # 结论已落地 → 允许只裁剪
+# compactDistilledFloor: 0.6  # 结论已落地 → 才考虑只裁剪（仍需 compactAllowPrune）
 # compactVerbatinFloor: 0.6   # 仍需逐字原文 → 一律摘要（安全否决优先）
+# compactAllowPrune: false    # 运维旋钮：允许不可逆裁剪，默认关；不在设置页
 
 # ---- 5. 轮次延续：再来一轮有没有增量价值 -----------------------------------
 # 非热路径。生效方式是用 agent.steer() 续一轮，每轮最多 turnStopMaxSteers 次。
+# 判断依据包含：用户最初的要求、最近一条助手文本、**真实的未完成工具调用数**、
+# 以及「是否在等用户」。最后一项缺席（旧端点不认识）时**保守收束不续轮**——
+# 边界未知时续轮等于替用户把选择顶掉。
 pointTurnStop: off
 # turnStopMaxSteers: 1
 # turnStopClosedFloor: 0.6
@@ -300,6 +310,9 @@ pointTurnStop: off
 
 # ---- 6. 检索必要性：这条信息是不是已经知道 ---------------------------------
 # 非热路径。只对检索类工具生效，其余工具零开销。
+# 确定性保护（不问模型，直接放行）：web_fetch、查询里带 URL、以及命中
+# 时效性关键词（最新/今天/当前/版本/发布/价格/新闻/实时/latest/today/…）。
+# 模型只用于「明显的重复检索」，不会单独拦下明确要求的实时查询。
 pointRetrieval: off
 # retrievalTools: [web_search, web_fetch, research, multi_search, advanced_search]
 # retrievalCoveredFloor: 0.5     # 上下文已覆盖该事实
@@ -308,13 +321,16 @@ pointRetrieval: off
 # ---- 7. 技能选择：该装哪个技能 ---------------------------------------------
 # 非热路径。只对 skill 工具、且候选 ≥2 时判断。
 # 生效时拦下不匹配的加载并指路，避免「装错再换」付两遍正文 token。
+# 模型建议的技能名必须属于候选集，否则视为无效建议直接放行；当前请求的
+# 技能即使排在候选上限之外也会被保留。
 pointSkillPick: off
 # skillPickCandidates: 8      # 送给模型挑选的候选上限（只带名称+描述）
 # skillPickConfidenceFloor: 0.5
 
 # ---- 8. 思维链翻译门槛：这条内容真的需要翻译吗 -----------------------------
-# 热路径（每条消息）。本地先做免费预筛（去代码块/URL 后判断有无正文），
-# 预筛不过的直接跳过，不发请求。生效时判为「不需要」则返回原文。
+# 热路径（每条消息）。本地先做免费预筛（去代码块/URL 后判断有无正文）。
+# 只有 **enforce** 时预筛才会真的跳过；observe 模式下预筛只记录「本该跳过」，
+# 原文照常交给翻译器——观察模式绝不改变行为。
 pointCotTranslate: off
 # cotProseFloor: 0.5
 # cotSameLanguageFloor: 0.8
@@ -352,12 +368,20 @@ guardFallbackProvider: ""
 guardFallbackModel: ""
 guardFallbackReasoningEffort: ""
 
-# 四档只调整软审核摩擦。mandatory deny 全档不变；requires_approval 必须
-# 获得当前调用的宿主 allowed-once，无审批通道时拒绝，模型不能代批。
-# autonomous 将软 ask 交给上述 Fallback，不等于直接放行。
-# relaxed / default / cautious 保留既有软摩擦档位行为；旧默认裁决函数
-# decideGuardLegacy 仅用于回放，不接入生产权限路径。
-# severity 是排序分数，分位数就绪不代表危险概率已校准。
+# 安全档位（tolerance）：只调整**软性审查**多频繁地升级为询问。
+#   autonomous 不问  软性询问不弹窗、不按比例；权限强制的人工批准与拒绝照旧
+#   relaxed    少问  只按严重度尾部（校准后约最前 1%，校准前固定分 0.60）；
+#                    **替换**默认判断，因此同一次调用可能比默认多问也可能少问
+#   default    默认  沿用决策模型自己的判断（中/高风险、疑似注入、
+#                    不可逆且与任务无关会问）
+#   cautious   多问  默认判断之上再叠加严重度靠前一批（校准后约 25%，
+#                    校准前固定分 0.30），逐调用一定是默认的超集
+#
+# 四档都不改变权限边界：mandatory deny 全档不变；requires_approval 必须拿到
+# 本次调用的宿主 allowed-once，没有审批通道时拒绝，模型不能代批。
+# autonomous 也不是「关掉审查」：在宿主 auto 审查或本档下，软性 ask 会交给
+# 上面的 guardFallback 裁决（失败即拒绝），因此它可能比 default 更严。
+# severity 是排序分数，分位数就绪不代表危险概率已校准；冷启动比校准后更安静。
 # tolerance: default
 
 # ============================================================================
@@ -385,31 +409,47 @@ guardFallbackReasoningEffort: ""
 # model、裁决、耗时、token，展开还能看到发给决策模型的现场（state）、
 # 问题（questions）与它回来的回答（answers）。
 #
-# 数据只落在本机 $DSH_HOME/dsh-decision-engine/decisions.jsonl，
-# **不经过任何网络请求**，也**不进**上面的匿名统计。
+# 数据只落在本机 $DSH_HOME/dsh-decision-engine/logs/，**不经过任何网络请求**，
+# 也**不进**上面的匿名统计。
 #
-# 关掉之后**完全不写这个文件**（不采集内容、不占磁盘，标签页也随之消失）
+# 关掉之后**完全不写任何日志**（不采集内容、不占磁盘，标签页也随之消失）
 # ——不是「写了藏起来」。明细里可能有会话正文与命令片段，用户说不记录
 # 就该真的不落盘。
 #
 # decisionsTabEnabled: true      # 默认开启；**这是唯一的开关**（DEC-026 / DEC-029）：
 #                                开 = 记录明细，且**一定记录决策内容**；
-#                                关 = 完全不写 decisions.jsonl（见上），
+#                                关 = 完全不写日志（见上），
 #                                没有「只存元数据」的中间档。
 #
-# 下面两项是**高级档位**，配置页上没有对应的开关：需要时手改本文件。
-# （一个开关管「这个功能要不要用」就够了；「记多细、最多占多大」是要主动
-# 去调的旋钮，不该天天摆在配置页上。）
+# 日志怎么分文件（默认 date）。四选一：
+#   date       logs/date/2026-11-15.log        一天一个文件（默认；日期跟随本机时区）
+#   session    logs/session/<会话名>__<id 前 8>.log  一个会话一个文件
+#   workspace  logs/workspace/<工作区名>.log    同一工作区的会话写在一起
+#   single     logs/decisions.jsonl             全部追加到一个文件（升级前的行为）
+# 文件名会包含会话名或工作区名（先脱敏再截断）。
+# decisionsSplitMode: date
+# 日期分隔符（只在 date 模式生效）：- / _ / .
+# decisionsDateSeparator: "-"
 #
-# 单条内容的上限（字符）。超出时依次裁剪：工具参数预览 → 最近对话摘要 →
-# 整个 state；只有连「问题 + 回答」都装不下时才退回只留元数据。
+# 老旧日志自动删除：启动时与每 6 小时清理一次。
+# 保留天数（0 = 不按天删，只受总量上限约束）；绝不删今天与正在写的分片。
+# decisionsRetentionDays: 30
 #
-# decisionsMaxContentChars: 4000
+# 下面几项是**高级档位**，配置页上没有对应的控件：需要时手改本文件。
 #
-# 明细文件体积上限（字节）。到顶轮转成 decisions.jsonl.1（只留一代），
-# 因此磁盘占用最多约两倍上限。
+# logs/ 目录的总量上限（字节，默认 64 MB）；按 mtime 从最旧的删起。
+# decisionsTotalMaxBytes: 67108864
 #
+# 单个分片的体积上限（字节）。到顶轮转成 <分片>.1（只留一代），
+# 因此磁盘占用最多约两倍单文件上限。
 # decisionsMaxBytes: 8388608   # 8 MB
+#
+# 单条内容的上限（字符）。超出时依次裁剪：工具参数预览 → 最近对话摘要 →
+# 整个 state；只有连「问题 + 回答」都装不下时才退回只留元数据。
+# decisionsMaxContentChars: 4000
+#
+# 升级时旧 decisions.jsonl（与 .1）会被一次性迁移进 logs/date/ 并改名
+# .migrated 保留；迁移失败时旧文件仍可读，下次启动重试。
 
 # ============================================================================
 # 审批卡正文可读化（DEC-043）——审批卡上那块命令怎么显示

package/docs/releasing.md

@@ -1,6 +1,6 @@
 # npm 发布
 
-发布目标：`@leonhardthust/dsh-decision-engine`，当前版本 `1.9.2`，公开包。
+发布目标：`@leonhardthust/dsh-decision-engine`，当前版本 `1.11.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.9.2` 包含实录 MCP 误拒、附加元数据校验和 actor/preset 服务解析修复；边界见 `docs/auto-review-hotfix.md`。
+- 当前 `1.11.0` 包含第二轮代码审计修复：`cotTranslate` observe 语义与缓存键、`skillPick` 候选校验、`retrieval` 时效性保护、`turnStop` 证据与缺省边界、`delegate` 来源过滤、`compact` 默认不做不可逆裁剪、`route` 机械闸收紧。设计记录见 `DECISIONS.md` 的 DEC-067 ~ DEC-069；`1.10.0` 的五项改动见 DEC-062 ~ DEC-066。
 - 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.9.2.tgz --registry "https://registry.npmjs.org/" --access public --tag latest
+npm publish ./release-artifacts/leonhardthust-dsh-decision-engine-1.11.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.9.2`。安装和启用是另外的用户动作，发布工作流不会修改本机 DSH profile。
+DSH 插件管理中使用 `@leonhardthust/dsh-decision-engine` 或指定 `@leonhardthust/dsh-decision-engine@1.11.0`。安装和启用是另外的用户动作，发布工作流不会修改本机 DSH profile。

package/lib/adapters/agent.js

@@ -86,19 +86,21 @@ export function mountAgentPoints(ctx, deps) {
       // ---- 子任务分派 ------------------------------------------------
       // 只在「每轮第一步 + 这一步确实带着新的用户输入」时判断：
       // 分派决策只在这个时刻可能改变，后续步骤再问必然是 inline。
-      if (runner.participates("delegate") && payload.step === 1 && payload.messages.length > 0) {
-        const incoming = payload.messages
-          .map((message) => textOf(message))
-          .filter((text) => text.length > 0)
-          .join("\n")
-          .slice(0, 1200);
-        if (incoming.length > 0) {
+      //
+      // 只认**用户来源**的消息。修之前这里把 `payload.messages` 全部拼接：
+      // 插件自己注入的 `[decision-engine-*]` 提示也是 `role: 'user'`，于是
+      // 「插件建议开 subagent」会被当成一条新的用户任务，让分派判断对着
+      // 自己的建议再判一次——模型很容易把建议读成用户要求，滚成自我确认。
+      if (runner.participates("delegate") && payload.step === 1 && Array.isArray(payload.messages)) {
+        const userInput = collectUserInput(payload.messages);
+        if (userInput !== undefined) {
           const result = await runner.ask(
             "delegate",
             {
               turn: payload.turn,
               step: payload.step,
-              incoming,
+              origin: userInput.origin,
+              incoming: userInput.incoming,
               recent: digestRecent(agent.session, cfg.recentMessages, cfg.recentMessageChars),
             },
             // session / turn / step 只给「决策历史」明细用，不参与裁决。
@@ -151,8 +153,14 @@ export function mountAgentPoints(ctx, deps) {
         "turnStop",
         {
           turn: payload.turn,
+          // 用户最初要什么。修之前 state 里没有它，模型只能从最后一句助手
+          // 文本反推「还有没有活没干完」——没有对照物，判断退化成猜测。
+          goal: firstUserText(agent.session, cfg.recentMessageChars * 4),
           last,
-          pendingTools: 0,
+          // 真实未完成计数。修之前这里是硬编码的 0：模型永远看到「没有
+          // 未完成的工具调用」，卡在工具执行上的轮次与正常收束的轮次在
+          // 证据上一模一样（详见 countPendingToolCalls）。
+          pendingTools: countPendingToolCalls(agent.session),
           steered: steersThisTurn(agent.session, payload.turn),
         },
         // session / turn 只给「决策历史」明细用，不参与裁决。
@@ -195,6 +203,156 @@ function textOf(message) {
     .join(" ");
 }
 
+/**
+ * 插件自己注入的合成消息统一带这个文本前缀。
+ *
+ * 只用于**老宿主**兜底（那时消息没有 `source`）：新宿主上 `source.kind`
+ * 已经能确定性区分，不需要猜文本。
+ */
+const SYNTHETIC_PREFIX = "[decision-engine-";
+
+/**
+ * 判断一条消息是不是用户亲手输入的。
+ *
+ * 为什么需要它：`role: 'user'` 不代表「用户说的」——插件通过 `agent.steer()`
+ * 注入的提示、宿主注入的运行时上下文都是 role=user。把它们当成新任务，
+ * 会让分派判断对着自己的建议做决策（见 pre-step 里的注释）。
+ *
+ * 判定顺序（从严到宽）：
+ *   1. 有 `source` → 只认 `source.kind === 'user'`（宿主自己声明的来源）；
+ *   2. 没有 `source`（老宿主）→ `role === 'user'` 且文本不带插件前缀。
+ *
+ * @param message - 一条消息（Message 或 Message-like 对象）。
+ * @returns `'user'` / `'legacy'`（老宿主兜底）/ undefined（不是用户输入）。
+ */
+function userOriginOf(message) {
+  const source = message?.source;
+  if (source !== undefined && source !== null && typeof source === "object") {
+    return source.kind === "user" ? "user" : undefined;
+  }
+  if (message?.role !== "user") return undefined;
+  return textOf(message).startsWith(SYNTHETIC_PREFIX) ? undefined : "legacy";
+}
+
+/**
+ * 从本次 pre-step 的 messages 里收出真正来自用户的文本。
+ *
+ * 修之前：把所有消息（包括插件注入的 `[decision-engine-*]` 提示）拼成一段
+ * 当作「新的用户任务」，于是每一轮都可能对着自己的提示重新分派。
+ *
+ * @param messages - pre-step 载荷里的消息数组。
+ * @returns `{ incoming, origin }`；没有可归因的用户文本时返回 undefined
+ *   （→ 整个分派点不判断，而不是拿空串去问模型）。
+ */
+function collectUserInput(messages) {
+  const parts = [];
+  let sawUser = false;
+  let sawLegacy = false;
+  for (const message of messages) {
+    const origin = userOriginOf(message);
+    if (origin === undefined) continue;
+    if (origin === "user") sawUser = true;
+    else sawLegacy = true;
+    const text = textOf(message);
+    if (text.length > 0) parts.push(text);
+  }
+  if (parts.length === 0) return undefined;
+  return {
+    incoming: parts.join("\n").slice(0, 1200),
+    origin: sawUser ? (sawLegacy ? "user+legacy" : "user") : "legacy",
+  };
+}
+
+/**
+ * 取会话里**第一条真实用户消息**，作为这一轮的原始目标（截断）。
+ *
+ * 只认 `source.kind === 'user'`（老宿主按 role 兜底并排除插件前缀）：
+ * 插件注入的 `[decision-engine-*]` 提示如果参与了 goal，目标就会从
+ * 「用户要什么」漂移到「继续把没做完的部分做完」，续轮判断失去基准。
+ *
+ * @param session - 宿主 Session。
+ * @param chars - 截断长度（超出部分用省略号标记）。
+ * @returns 目标文本；找不到返回空串。
+ */
+function firstUserText(session, chars) {
+  for (const event of sessionEventsOf(session)) {
+    if (event?.type !== "user/message") continue;
+    // 新宿主把消息放在 data.message 里，老宿主/兼容层可能直接放 data。
+    const message = event.data?.message ?? event.data;
+    if (userOriginOf(message) === undefined) continue;
+    const text = textOf(message);
+    if (text.length === 0) continue;
+    return text.length > chars ? `${text.slice(0, chars)}…` : text;
+  }
+  return "";
+}
+
+/**
+ * 数「已经发出 tool/call 但还没有对应 tool/result」的数量。
+ *
+ * 修之前 `state.pendingTools` 是硬编码的 0：模型永远看到「没有未完成的
+ * 工具调用」，于是「卡在工具执行上的一轮」与「正常收束的一轮」在证据上
+ * 完全一样。
+ *
+ * 宿主的事件是可直接配对的**数据**（不是猜意图）：
+ *   tool/call   的 `data.callId`
+ *   tool/result 的 `data.message.toolCallId`
+ * 配不上对的就是还没回来。老格式两侧都可能缺 id，此时按先进先出配一对。
+ *
+ * 只统计**最近一条用户消息之后**的调用：被中断的轮次会留下永远没有结果的
+ * 历史调用，若跨轮累计，`pendingTools` 会永久 ≥1——那不是在报告事实，而是
+ * 在给模型制造「还有活没干完」的假证据。
+ *
+ * @param session - 宿主 Session。
+ * @returns 最近一段里未完成的工具调用数。
+ */
+function countPendingToolCalls(session) {
+  /** callId → 仍在等待结果的调用。 */
+  const open = new Map();
+  /** 两侧都没有 id 的老格式调用：只能按数量配。 */
+  let anonymous = 0;
+  const reset = () => {
+    open.clear();
+    anonymous = 0;
+  };
+  for (const event of sessionEventsOf(session)) {
+    // 新的用户输入 = 新的一段工作：之前没回来的调用不再属于「现在」。
+    if (event?.type === "user/message") {
+      reset();
+      continue;
+    }
+    if (event?.type === "tool/call") {
+      const callId = callIdOf(event);
+      if (callId === undefined) anonymous += 1;
+      else open.set(callId, true);
+      continue;
+    }
+    if (event?.type !== "tool/result") continue;
+    const callId = callIdOf(event);
+    if (callId !== undefined && open.has(callId)) {
+      open.delete(callId);
+    } else if (anonymous > 0) {
+      anonymous -= 1;
+    } else if (callId === undefined) {
+      // 两侧都缺 id：按先进先出配最早那个未完成调用。
+      const oldest = open.keys().next();
+      if (!oldest.done) open.delete(oldest.value);
+    }
+    // 有 id 但找不到对应 call（例如日志被截断）：忽略，不虚构一个待办。
+  }
+  return open.size + anonymous;
+}
+
+/**
+ * 从 tool 事件里取调用 id（兼容两种宿主形状）。
+ * @param event - tool/call 或 tool/result 事件。
+ * @returns 调用 id，或 undefined（老格式没有 id）。
+ */
+function callIdOf(event) {
+  const id = event?.data?.callId ?? event?.data?.message?.toolCallId;
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+
 /**
  * 上下文压缩：判断「现在只丢陈旧工具结果够不够」。
  *

package/lib/adapters/route.js

@@ -8,8 +8,8 @@
  *                一个任务的「要不要强模型」在开头就定了，逐步重问是浪费。
  *   闸2 路由闸    提议的 config 与上一次实际使用的不同才问。同一 provider/model
  *                连续多步时，裁决已经生效，不必再问。
- *   闸3 机械闸    只有本地判定「看起来机械」的步骤才问：上一步有工具结果、
- *                且最近没有用户新输入。新推理多半需要强模型，问了也是 keep。
+ *   闸3 机械闸    最近一条相关事件不是用户新输入才问。带新用户输入的步骤
+ *                （尤其是新任务的第一步）是新推理，问了也是 keep，还白等一步。
  *
  * 生效方式：返回替换后的 LlmCallConfig。observe 只记录「本该换成什么」。
  *
@@ -46,15 +46,24 @@ export function mountRoutePoint(ctx, deps) {
     return state;
   };
 
-  /** 最近一条 user 消息是否比最近一条工具结果更新（= 有新推理进入）。 */
-  const hasFreshUserInput = (session) => {
+  /**
+   * 最近一条相关事件的**归类**：用户新输入、工具结果，还是什么都没有。
+   *
+   * 为什么不是一个布尔（旧的 `hasFreshUserInput`）：闸3 要回答的不是
+   * 「有没有新输入」，而是「这一步有没有机械延续的证据」。三态才分得清
+   * 「明确是新推理」「明确是工具结果之后」「事件读不到」——第三种不能
+   * 当成前两种中的任何一个（详见闸3 的注释）。
+   *
+   * @returns `"after-user-message"` / `"after-tool-result"` / undefined（读不到）。
+   */
+  const lastRelevantKind = (session) => {
     const events = sessionEventsOf(session);
     for (let index = events.length - 1; index >= 0; index -= 1) {
-      const event = events[index];
-      if (event?.type === "tool/result") return false;
-      if (event?.type === "user/message") return true;
+      const type = events[index]?.type;
+      if (type === "tool/result") return "after-tool-result";
+      if (type === "user/message") return "after-user-message";
     }
-    return false;
+    return undefined;
   };
 
   const listener = async (payload, next) => {
@@ -89,8 +98,23 @@ export function mountRoutePoint(ctx, deps) {
         if (state.askedSteps.size > 0) return proposed;
       }
 
-      // 闸3：新用户输入带来的步骤通常是新推理，问了也多半 keep。
-      if (hasFreshUserInput(agent.session) && state.askedSteps.size > 0) return proposed;
+      // 闸3 机械闸：最近一条相关事件是用户新输入，就不判断。
+      //
+      // 修之前这里还要求 `state.askedSteps.size > 0`——「本轮问过步了才拦」。
+      // 于是**新用户任务的第一步**（本轮还没问过任何一步）会照常问模型要不要
+      // 下沉，而那恰恰是最不该下沉的一步：用户刚提出目标，后文还没展开，
+      // `state` 里只有 current/recent、没有任何「下一步是机械活」的证据。
+      // 问出来的多半是 keep（白付一次 ~2 秒 / ~1.9k token），**万一**判成机械，
+      // 整个新任务就从开局跑在便宜模型上——第一步走偏，后面全在错的前提上继续。
+      //
+      // 因此去掉「本轮问过步」这个前提：只要最近一条相关事件是 user/message，
+      // 这一步就是新推理，一律不判断。剩下的两种事件才允许继续往下走：
+      //   tool/result       明确的机械延续（读结果、改格式、重试）；
+      //   读不到事件        保持旧行为（问）。读不到 ≠ 有用户新输入，把它当成
+      //                     「不判断」会让老宿主上的路由**静默失效**——这正是
+      //                     lib/session-events.js 顶部记的那个坑，不能再踩一次。
+      const basis = lastRelevantKind(agent.session);
+      if (basis === "after-user-message") return proposed;
 
       // 已经在用便宜模型了，再往下沉没有意义。
       if (
@@ -109,6 +133,14 @@ export function mountRoutePoint(ctx, deps) {
           step: payload.step,
           current: { provider: proposed.provider, model: proposed.model },
           recent: digestRecent(agent.session, cfg.recentMessages, cfg.recentMessageChars),
+          // 闸3 凭什么放行这一步：`after-tool-result` = 上一条相关事件是工具
+          // 结果；读不到事件时不给这个字段（不编造依据）。
+          //
+          // 注意：route 规格的 build 目前只取 turn/step/current/recent，
+          // 所以它暂时不会出现在决策历史页上——留在这里是为了让「为什么问了
+          // 这一步」在请求里可核对（测试按它断言），规格一旦把它纳入 state
+          // 就自动生效，不必再改这里。
+          ...(basis === undefined ? {} : { basis }),
         },
         // session / turn / step 只给「决策历史」明细用：tab 按会话归属，
         // 轮次与步号让每行能定位到会话里的具体位置。它们不改任何裁决。