@leonhardthust/dsh-decision-engine 1.9.2 → 1.11.0

package/lib/index.js

@@ -25,7 +25,7 @@
 
 import { appendFile, mkdir, readFile } from "node:fs/promises";
 import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import z from "@deepseek-ai/schemastery";
 
 import { DecisionCache } from "./decision-cache.js";
@@ -46,7 +46,19 @@ import { resolveDshHome } from "./home-paths.js";
 import { applyRefUpdates, listRefNames, pickRefValue } from "./credentials.js";
 import { RANGE_LABELS, RANGE_PRESETS, aggregate, buildRecord, resolveRange, sortRows } from "./stats.js";
 import { StatsStore } from "./stats-store.js";
-import { buildDecisionRecord, DecisionStore, MAX_ENTRIES_PER_QUERY } from "./decision-store.js";
+import { buildDecisionRecord, DecisionStore, MAX_ENTRIES_PER_QUERY, maskSecrets } from "./decision-store.js";
+// 日志分片命名与紧凑格式：纯函数（零 I/O），放在独立模块里才能单测到
+// 时区、Windows 保留名、截断哈希这些边界。
+import {
+  DATE_SEPARATORS,
+  DEFAULT_DATE_SEPARATOR,
+  DEFAULT_RETENTION_DAYS,
+  DEFAULT_SPLIT_MODE,
+  DEFAULT_TOTAL_MAX_BYTES,
+  SPLIT_MODES,
+  normalizeDateSeparator,
+  normalizeSplitMode,
+} from "./decision-log.js";
 // 作用域边界（DEC-045）：越出工作区的写入、模型给用户挑方案、模型等用户
 // 澄清——这三类决定不属于本插件，遇到时让位给用户。
 import { GUARD_FALLBACKS, guardModelCatalog } from "./guard/fallback.js";
@@ -257,6 +269,18 @@ const DEFAULTS = {
   compactDistilledFloor: 0.6,
   // 安全否决：仍需逐字原文时绝不裁剪（实测两类均 0.26，故门槛取高）。
   compactVerbatinFloor: 0.6,
+  /**
+   * 是否允许 compact 点用「只丢工具结果」替代摘要（默认 **false**）。
+   *
+   * 为什么默认关：`distilled` 只是模型对「结论是否已落进对话」的一个概率，
+   * 而 state 里只有「有几条超长结果」这个数字——那几条结果是什么、哪些结论
+   * 真的保住了，都没有证据。而 prune **不可逆**：中间段被换成标记之后，
+   * 后续轮次再也拿不回原文。相比之下 compaction-basic 的摘要至少把信息
+   * 保成一段话。所以默认一律 summarize；需要极致省钱的部署再手改
+   * config.yml 打开它——与 `decisionsMaxBytes` 同类的**运维旋钮**，
+   * 刻意不进 `/config` 白名单。
+   */
+  compactAllowPrune: false,
   // ---- 轮次延续（pointTurnStop）-----------------------------------------
   turnStopMaxSteers: 1,
   // 实测：已完成 → closed 0.74 / unfin 0.09 / value 0.09；
@@ -354,8 +378,41 @@ const DEFAULTS = {
   approvalDetailReadable: true,
   /** 单条内容的序列化长度上限；超了按「参数 → 摘要 → 整个 state」依次裁剪。 */
   decisionsMaxContentChars: 4000,
-  /** 明细文件体积上限（字节）；到顶轮转成 `decisions.jsonl.1`（只留一代）。 */
+  /** 单个分片的体积上限（字节）；到顶轮转成 `<分片>.1`（只留一代）。 */
   decisionsMaxBytes: 8 * 1024 * 1024,
+  /**
+   * 决策日志的分文件方式（T3）。
+   *
+   * 默认 **date**：单文件在体量上来之后有两个硬问题——按会话查历史要扫全文件，
+   * 体积轮转还会把同一个会话的记录切开。按日期分片最贴合「今天的日志」这个
+   * 问法，也是清理（按保留天数删）最自然的单位。
+   *
+   * 其余三档给不同习惯的用户：session 按会话隔离、workspace 按项目归档、
+   * single 保留旧行为（一个文件，升级不改体验）。
+   */
+  decisionsSplitMode: DEFAULT_SPLIT_MODE,
+  /**
+   * 日期分片的日期分隔符：`-` / `_` / `.`。
+   *
+   * 三档都是「同一种信息的三种写法」，纯粹为了兼容用户已有的脚本/别名
+   * （有人用 `2026-11-15`，也有人拿 `2026_11_15` 当搜索词）。
+   */
+  decisionsDateSeparator: DEFAULT_DATE_SEPARATOR,
+  /**
+   * 日志保留天数：`0` = 不按天删（只受总量上限约束）。
+   *
+   * 默认 30 天：够回答「上个月这个问题出现过没有」，又不会让磁盘无限长。
+   * 清理只删**今天之前的**分片，绝不碰正在写的那个。
+   */
+  decisionsRetentionDays: DEFAULT_RETENTION_DAYS,
+  /**
+   * `logs/` 的总量上限（字节，默认 64 MB）。
+   *
+   * 与 `decisionsMaxBytes`（单分片上限）是两个维度：前者约束整体磁盘占用，
+   * 后者约束「一个文件多大就开始轮转」。这是**运维旋钮**，刻意不进
+   * `/config` 白名单——用户日常不需要拨它，需要时手改 config.yml 即可。
+   */
+  decisionsTotalMaxBytes: DEFAULT_TOTAL_MAX_BYTES,
   /**
    * 人工审核比例（tolerance，DEC-035）。
    *
@@ -464,7 +521,7 @@ export const Config = z.object({
   retryAttempts: z.number().step(1).min(0).max(3).default(DEFAULTS.retryAttempts)
     .description("仅对超时与网络错误重试的次数；4xx/5xx 不重试（配置错与服务端故障，重发只会多烧额度）"),
   thinkMode: z.union(["never", "auto", "always"]).default(DEFAULTS.thinkMode)
-    .description("never 最省 token；auto 仅在不确定时思考"),
+    .description("never 最省延迟；auto 由服务端决定；always 总是思考"),
   cooldownMs: z.number().step(1).min(1000).default(DEFAULTS.cooldownMs),
   cooldownProbeMs: z.number().step(1).min(1000).default(DEFAULTS.cooldownProbeMs)
     .description("冷却期内每隔这么久放行一次试探请求；试探成功即彻底解除冷却"),
@@ -515,6 +572,12 @@ export const Config = z.object({
     .description("判定「工具结果的信息已落地」的门槛；达线才允许只裁剪"),
   compactVerbatinFloor: z.number().min(0).max(1).default(DEFAULTS.compactVerbatinFloor)
     .description("仍需逐字原文的门槛；达线一律改走摘要"),
+  compactAllowPrune: z.boolean().default(DEFAULTS.compactAllowPrune)
+    .description(
+      "允许 compact 点只裁剪超长工具结果、跳过摘要（默认 false，始终交给宿主摘要）。"
+        + "风险：裁剪不可逆，模型仅凭「结论已落地」的概率，误判会永久丢掉工具结果中间段。"
+        + "运维旋钮，不在设置页提供",
+    ),
   // ---- 轮次延续 --------------------------------------------------------
   turnStopMaxSteers: z.number().step(1).min(0).max(5).default(DEFAULTS.turnStopMaxSteers),
   turnStopClosedFloor: z.number().min(0).max(1).default(DEFAULTS.turnStopClosedFloor),
@@ -572,11 +635,22 @@ export const Config = z.object({
   decisionsMaxContentChars: z.number().step(1).min(200).default(DEFAULTS.decisionsMaxContentChars)
     .description("单条决策内容的字符上限；超出时依次裁剪工具参数、对话摘要、整个 state"),
   decisionsMaxBytes: z.number().step(1).min(1024 * 1024).default(DEFAULTS.decisionsMaxBytes)
-    .description("明细文件体积上限（字节）；到顶轮转成 decisions.jsonl.1，只留一代"),
+    .description("单个日志分片的体积上限（字节）；到顶轮转成 <分片>.1，只留一代"),
+  decisionsSplitMode: z.union([...SPLIT_MODES]).default(DEFAULTS.decisionsSplitMode)
+    .description(
+      "日志分文件：single 单一文件 / date 按日期（默认）/ session 按会话 / workspace 按工作区。"
+        + "文件名可能包含会话名或工作区名",
+    ),
+  decisionsDateSeparator: z.union([...DATE_SEPARATORS]).default(DEFAULTS.decisionsDateSeparator)
+    .description("date 模式的日期分隔符：- / _ / .；只影响文件名"),
+  decisionsRetentionDays: z.number().step(1).min(0).max(3650).default(DEFAULTS.decisionsRetentionDays)
+    .description("日志保留天数（0 = 不按天删）；每 6 小时清理一次，绝不删今天与正在写的分片"),
+  decisionsTotalMaxBytes: z.number().step(1).min(1024 * 1024).default(DEFAULTS.decisionsTotalMaxBytes)
+    .description("logs 目录的总量上限（字节，默认 64 MB）；运维旋钮，不在设置页提供"),
   tolerance: z.union([...TOLERANCE_LEVELS]).default(DEFAULTS.tolerance)
     .description(
-      "人工审核比例（模型无关）：autonomous 从不问用户 / relaxed 只问最前 1% / "
-        + "default 按决策模型自己的判断（当前默认）/ cautious 在默认之外再问最前 25%",
+      "安全档位（模型无关的打扰频率）：autonomous 不问（软性审查不弹窗）/ relaxed 少问（只按严重度尾部）/ "
+        + "default 默认（沿用决策模型判断）/ cautious 多问（默认判断之上再加严重度带）；四档都不改变权限强制的人工批准与拒绝",
     ),
 });
 
@@ -748,6 +822,33 @@ export function validateProviderPatch(patch, current) {
     };
   }
 
+  // 日志分文件（T3）：三档之外的值一律拒在落盘前。
+  //
+  // 为什么必须拦在这里：这些键直接决定**文件往哪写**。收到一个拼错的
+  // 模式名后若放行，`normalizeSplitMode()` 会静默退回 date——用户以为切到了
+  // 「按会话」，实际仍在按日期写，文件名里也不会出现会话名。这种静默降级
+  // 只能靠落盘前的校验暴露出来。
+  if (Object.hasOwn(patch, "decisionsSplitMode") && !SPLIT_MODES.includes(patch.decisionsSplitMode)) {
+    return {
+      ok: false,
+      error: `未知的日志分文件方式: ${String(patch.decisionsSplitMode)}（可选 ${SPLIT_MODES.join(" / ")}）`,
+    };
+  }
+  if (Object.hasOwn(patch, "decisionsDateSeparator") && !DATE_SEPARATORS.includes(patch.decisionsDateSeparator)) {
+    return {
+      ok: false,
+      error: `未知的日期分隔符: ${String(patch.decisionsDateSeparator)}（可选 ${DATE_SEPARATORS.join(" / ")}）`,
+    };
+  }
+  if (Object.hasOwn(patch, "decisionsRetentionDays")) {
+    const days = patch.decisionsRetentionDays;
+    // 只认整数：`"30"` 这样字符串落盘后会被 Number() 读成 30，但界面的数字
+    // 输入框会把它当成非法值显示成空——两边对不上比直接拒绝更难排查。
+    if (typeof days !== "number" || !Number.isInteger(days) || days < 0 || days > 3650) {
+      return { ok: false, error: `日志保留天数必须是 0–3650 的整数: ${String(days)}` };
+    }
+  }
+
   // 变量名必须能当环境变量用，否则凭据永远读不到。
   // 逐个预设取它自己的变量名覆盖字段，而不是写死三个名字——否则新增预设时
   // 漏加这一项，用户填的变量名会被原样写进 yml，然后永远读不到 key
@@ -1805,7 +1906,18 @@ class StartluxClient {
     // 这样即便服务商将来换模型名，留空配置也不会因此 400。
     const model = (provider.model ?? "").trim();
 
-    const exactKey = DecisionCache.exactKey([endpoint, model, call.state, call.questions]);
+    /**
+     * 精确键必须包含 `thinkMode`：它改变**请求体**（`think_mode` 字段），
+     * 同一份 state 在 `never` 与 `always` 下拿到的裁决可能不同。不把它算进
+     * 键里，用户切换思考模式后还会命中旧裁决——「改了设置没效果」。
+     */
+    const exactKey = DecisionCache.exactKey([
+      endpoint,
+      model,
+      normalizeThinkMode(cfg.thinkMode),
+      call.state,
+      call.questions,
+    ]);
     // 软键（归一化「同类」复用）默认关闭，fail-closed：只有调用方显式传
     // `softCacheable: true` 才启用。授权（authorize）这类安全检查绝不启用——
     // 归一化签名只保留「工具名 + 命令族 + 风险标记」，丢弃了参数内容，
@@ -2271,13 +2383,33 @@ export function apply(ctx, config) {
     getServerOverride: serverOverride,
     refreshServer: refreshServerInBackground,
   });
+  /**
+   * 会话名 / 工作区名解析器（session / workspace 分文件模式的命名依据）。
+   *
+   * 实现放在模块级 `createSessionMetaResolver()`：读标题的顺序、隐私清洗
+   * 与缓存都是**纯逻辑**，可以和宿主解耦单测（见 decisions-route.test.js）。
+   * 这里只把宿主服务接进去。
+   */
+  const sessionTitleService = () => {
+    try {
+      return ctx.get?.("sessionTitle");
+    } catch {
+      return undefined;
+    }
+  };
+  const sessionMetaOf = createSessionMetaResolver({ getTitleService: sessionTitleService });
+
   /**
    * 决策明细存储（「决策历史」页的数据源，见 lib/decision-store.js）。
    *
-   * 三个取值函数都由配置现读，因此配置页改了开关立刻生效——不需要重启，
-   * 与插件其余配置的处理方式一致。开关关闭时 `record()` 直接返回 false，
-   * 既不建文件也不占磁盘；开启时明细一定带内容（每条记录上的 `capture`
-   * 只反映 `truncateContent()` 的截断结果，没有任何配置能把它降级成 meta）。
+   * 所有取值函数都由配置现读，因此配置页改了开关/分文件方式立刻生效——
+   * 不需要重启，与插件其余配置的处理方式一致。开关关闭时 `record()` 直接
+   * 返回 false，既不建目录也不占磁盘；开启时明细一定带内容（每条记录上的
+   * `capture` 只反映 `truncateContent()` 的截断结果，没有任何配置能把它
+   * 降级成 meta）。
+   *
+   * 时区不单独配置：日期分片按**系统时区**切（用户看到的日历就是系统日历）。
+   * 想按别处时区归档，是罕见需求；为它加一个配置键会把设置页撑得更长。
    */
   const decisionStore = new DecisionStore({
     dir: telemetryDir,
@@ -2285,6 +2417,10 @@ export function apply(ctx, config) {
     getEnabled: () => cfg.decisionsTabEnabled !== false,
     getMaxBytes: () => cfg.decisionsMaxBytes,
     getMaxContentChars: () => cfg.decisionsMaxContentChars,
+    getSplitMode: () => cfg.decisionsSplitMode,
+    getDateSeparator: () => cfg.decisionsDateSeparator,
+    getRetentionDays: () => cfg.decisionsRetentionDays,
+    getTotalMaxBytes: () => cfg.decisionsTotalMaxBytes,
   });
 
   /**
@@ -2335,9 +2471,59 @@ export function apply(ctx, config) {
       }
     })
     .catch(() => {
-      /* 历史整理失败不影响插件启动 */
+      /* 历史统计整理失败不影响插件启动 */
+    })
+    .then(() => {
+      /**
+       * 决策日志的两步整理，**必须排在统计回填之后、且自己串行**。
+       *
+       *   1. `migrateLegacyOnce()`：旧 `decisions.jsonl` → `logs/` 日期分片。
+       *      它自己靠标记文件保证只做一次；失败只 warn，旧文件仍可读。
+       *   2. `cleanupOnce()`：按保留天数 + 总量上限清理过期分片。
+       *
+       * 为什么不能与第 1 步并发：清理会枚举 `logs/`，若迁移正往目录里写分片，
+       * 清理可能对着一个刚创建、还没写完的文件做删除判断（Windows 上删不掉、
+       * 其它平台可能删掉半份数据）。迁移是毫秒级动作，串行没有成本。
+       *
+       * 注意上面那道 `.catch()` 的位置：统计整理失败时必须**继续**往下走，
+       * 否则「旧遥测坏了」会连带把日志迁移也永久跳过（两个子系统本无关系）。
+       */
+      return decisionStore.migrateLegacyOnce().then((migrated) => {
+        if (migrated > 0) {
+          ctx.logger?.info?.(
+            `dsh-decision-engine: 已把 ${migrated} 条旧决策明细迁移到按日期分片（旧文件已改名 .migrated，未删除）`,
+          );
+        }
+        return decisionStore.cleanupOnce();
+      });
+    })
+    .then((report) => {
+      if (report && report.removed > 0) {
+        ctx.logger?.info?.(
+          `dsh-decision-engine: 已清理 ${report.removed} 个过期决策日志分片（释放 ${report.removedBytes} 字节）`,
+        );
+      }
+    })
+    .catch(() => {
+      /* 日志整理失败不影响插件启动 */
     });
 
+  /**
+   * 定期清理（每 6 小时）。
+   *
+   * 为什么需要它：只在启动时清理的话，DSH 长期不重启（真实用法常常是开着
+   * 几天）就会一直涨；而 `unref()` 保证这个定时器不会拦住进程退出。
+   * 每一轮都是**尽力而为**：失败只 warn，下一轮再来。
+   *
+   * 6 小时的选择：清理本身很便宜（一次 readdir + 若干 unlink），而频率再高
+   * 也不会有更多收益——保留期以「天」为单位。
+   */
+  const decisionsCleanupTimer = setInterval(() => {
+    void decisionStore.cleanupOnce().catch(() => {});
+  }, 6 * 60 * 60 * 1000);
+  // 定时器不该成为进程退出的理由（Node 的 unref 语义；测试进程尤为重要）。
+  decisionsCleanupTimer.unref?.();
+
 
   /**
    * 匿名使用统计（DEC-020）。
@@ -2623,6 +2809,8 @@ export function apply(ctx, config) {
             ...(result?.answers === undefined ? {} : { answers: result.answers }),
           },
         }),
+        // 分文件模式要会话名/工作区名；守卫路径本来就握着 Session 对象。
+        sessionMetaOf(options.session),
       );
     } catch (error) {
       ctx.logger?.warn?.(
@@ -2664,10 +2852,14 @@ export function apply(ctx, config) {
      * 决策明细（「决策历史」页）。与 `log`（遥测）是两条独立旁路：
      * 遥测是「服务端说了什么」的结论口径，明细是本地的现场 + 会话归属。
      * 这里补上限指针——截断策略属于存储层，引擎不该知道配置项叫什么。
+     *
+     * 第二个参数是**会话引用**（Session 对象或 id 字符串，由 engine.js 原样
+     * 传下来）：session/workspace 分文件模式要拿它的名字做文件名。
      */
-    recordDetail: (record) =>
+    recordDetail: (record, session) =>
       decisionStore.record(
         buildDecisionRecord({ ...record, maxContentChars: cfg.decisionsMaxContentChars }),
+        sessionMetaOf(session),
       ),
   });
 
@@ -3160,6 +3352,21 @@ export function apply(ctx, config) {
         // 才是真值；回 `undefined` 会让界面把开关画成关。
         approvalDetailReadable: cfg.approvalDetailReadable !== false,
         decisionsFile: decisionStore.path,
+        // 日志分文件与保留（T3）：配置页的三行控件都靠这几项回显。
+        //
+        // **必须回传生效值**（归一化之后再回）：用户可能把 config.yml 手改成
+        // `decisionsSplitMode: Day` 这种拼错的值，`*normalize*` 会把它当 date；
+        // 若照原样回显，界面会把「按日期」画成选中、却把一个不存在的选项
+        // 塞进下拉——保存一次就又多了一个坏值。
+        decisionsSplitMode: normalizeSplitMode(cfg.decisionsSplitMode),
+        decisionsSplitModes: SPLIT_MODES,
+        decisionsDateSeparator: normalizeDateSeparator(cfg.decisionsDateSeparator),
+        decisionsDateSeparators: DATE_SEPARATORS,
+        decisionsRetentionDays: decisionStore.retentionDays(),
+        // 清理结果（文件数 / 字节数 / 上次清理时间）：设置页用它说明
+        // 「现在磁盘上大概有多少日志」。这是**上次清理时**的快照，不是实时
+        // 扫描——状态接口不该每次都去 stat 一整个目录。
+        decisionsStorage: decisionStore.storageReport(),
         // 人工审核比例（DEC-035）：配置页滑块的唯一数据源。
         tolerance: tolerancePayload(),
         stats: client.stats,
@@ -3282,6 +3489,12 @@ export function apply(ctx, config) {
             // 改截断长度），不是用户日常会拨的开关，走配置页会把界面变复杂；
             // 需要时手改 config.yml 即可。
             "decisionsTabEnabled",
+            // 日志分文件与保留（T3）：这三个是**用户日常会拨**的开关，必须能
+            // 保存。`decisionsTotalMaxBytes` 与 `decisionsMaxBytes` 则是运维
+            // 旋钮，刻意不在白名单里（理由见上面那段）。
+            "decisionsSplitMode",
+            "decisionsDateSeparator",
+            "decisionsRetentionDays",
             // 审批卡正文可读化（DEC-042）：配置页要能拨，否则拨了也存不下去。
             "approvalDetailReadable",
             // 服务端下发开关（DEC-030）：不在白名单里的后果与上面 telemetryLevel
@@ -3684,7 +3897,8 @@ export function apply(ctx, config) {
      * 与 `/log` 的区别不是路径而是**口径**：
      *
      *   - `/log` 读的是 telemetry.jsonl（全机、无会话维度、只有结论）；
-     *   - 这里读的是 decisions.jsonl（有会话归属、有决策内容、按体积轮转）。
+     *   - 这里读的是 `logs/` 下的决策明细分片（有会话归属、有决策内容；
+     *     默认按日期分片，跨分片读取后按会话过滤）。
      *
      * `sessionId` 是**必填**的：没有会话参数时返回 400 而不是「返回全部」。
      * 返回全部会让人以为「这个会话里居然有别的会话的记录」，而正确的回答是
@@ -3714,7 +3928,11 @@ export function apply(ctx, config) {
             scanned: page.scanned,
             truncated: page.truncated,
             // 文件路径给排查用：用户常问「记录到底写到哪了」。
+            // `file` 是**最新读到的那个分片**（兼容旧界面的单文件展示），
+            // `files` 是本次实际读的全部分片（从新到旧）——分文件模式下
+            // 一个会话的记录可能跨多个文件，界面要能显示「几个文件、在哪」。
             file: page.file,
+            files: page.files,
             // 单条内容长度上限：界面据此说明内容可能被截断。截断是内容丢失的
             // **唯一**来源——没有任何配置键能把整条内容剥成只留元数据。
             contentLimit: cfg.decisionsMaxContentChars,
@@ -3769,6 +3987,103 @@ function stripUndefined(source) {
   return out;
 }
 
+/** 会话名解析缓存的默认上限（条）。 */
+const SESSION_META_CACHE_LIMIT = 512;
+
+/**
+ * 造一个「会话 → { sessionName, workspaceName }」的解析器。
+ *
+ * 这两个名字是 `session` / `workspace` 分文件模式的**文件名来源**，但它们
+ * 只挂在宿主 Session 上（记录体里只有 id），所以要在 index 侧反查。取名字
+ * 的顺序是「越接近用户所见越优先」：
+ *
+ *   1. 宿主 `sessionTitle` 服务给出的标题（DSH 界面上显示的就是它）；
+ *   2. `session.header.title`（老宿主 / 测试里的形态）；
+ *   3. 会话 cwd 的目录名（没有标题时，目录名比一串 uuid 有用得多）；
+ *   4. `unknown`。
+ *
+ * 工作区名：`workspaceRoots[0]`（`session.header.workspaceRoots` /
+ * `session.workspaceRoots` / `session.header.workspaceRoot`）的基名，
+ * 拿不到再退回 cwd 的基名，最后退回进程 cwd。
+ *
+ * **隐私**：名字会进文件名，所以先过 `maskSecrets()` 再截断到 64 字符——
+ * 会话标题里贴过的一次 key 不该出现在目录列表里。`session` 模式另有 id
+ * 后缀兜底，名字缺失时也不会串会话。
+ *
+ * 按 sessionId 缓存（上限 512）：一条会话会写很多条明细，每次都去问宿主
+ * 服务既慢又可能抛错；标题改名是低频事件，重启后自然刷新。
+ *
+ * @param options.getTitleService - 返回宿主 `sessionTitle` 服务的取值函数。
+ * @returns `(session) => { sessionName, workspaceName }`；永不抛错。
+ */
+export function createSessionMetaResolver(options = {}) {
+  const cache = new Map();
+  const limit = Number.isFinite(options.cacheLimit) && options.cacheLimit > 0
+    ? Math.floor(options.cacheLimit)
+    : SESSION_META_CACHE_LIMIT;
+  const getTitleService =
+    typeof options.getTitleService === "function" ? options.getTitleService : () => undefined;
+  const basenameOfPath = (value) => {
+    try {
+      const text = typeof value === "string" ? value.trim() : "";
+      return text.length > 0 ? basename(text) : "";
+    } catch {
+      return "";
+    }
+  };
+  const privacyName = (value, fallback) => {
+    let text = typeof value === "string" ? value.trim() : "";
+    text = maskSecrets(text);
+    if (text.length === 0) text = fallback;
+    return String(text).slice(0, 64);
+  };
+  return (session) => {
+    try {
+      const id = typeof session === "string"
+        ? session
+        : typeof session?.id === "string"
+          ? session.id
+          : "";
+      const cached = id.length > 0 ? cache.get(id) : undefined;
+      if (cached !== undefined) return cached;
+      let title = "";
+      try {
+        const titled = getTitleService()?.get?.(session);
+        if (typeof titled?.title === "string") title = titled.title;
+      } catch {
+        /* 宿主没有这个服务时照常往下走 */
+      }
+      if (title.length === 0 && typeof session?.header?.title === "string") {
+        title = session.header.title;
+      }
+      const cwd = typeof session?.header?.cwd === "string" ? session.header.cwd : "";
+      if (title.length === 0) title = basenameOfPath(cwd);
+      const roots = Array.isArray(session?.header?.workspaceRoots)
+        ? session.header.workspaceRoots
+        : Array.isArray(session?.workspaceRoots)
+          ? session.workspaceRoots
+          : typeof session?.header?.workspaceRoot === "string"
+            ? [session.header.workspaceRoot]
+            : [];
+      const workspaceRoot = typeof roots[0] === "string" ? roots[0] : "";
+      const workspace = basenameOfPath(workspaceRoot) || basenameOfPath(cwd) || basenameOfPath(process.cwd());
+      const meta = {
+        // 会话名兜底用会话 id：至少文件名可读、可相关性对照。
+        sessionName: privacyName(title, id.length > 0 ? id : "unknown"),
+        workspaceName: privacyName(workspace, "unknown"),
+      };
+      if (id.length > 0) {
+        cache.set(id, meta);
+        if (cache.size > limit) cache.delete(cache.keys().next().value);
+      }
+      return meta;
+    } catch {
+      // 解析失败只能退化成 unknown：分文件名不该因为宿主形状变化而抛错。
+      return { sessionName: "unknown", workspaceName: "unknown" };
+    }
+  };
+}
+
 /**
  * 从完整端点里取出它的路径风格（`decisions` / `systemone`）。
  *

package/lib/outcomes.js

@@ -59,7 +59,9 @@ export const OUTCOMES = ["allow", "ask", "reject"];
  */
 export const OUTCOME_LABELS = {
   allow: "放行",
-  ask: "询问",
+  // 「转人工」而不是「询问」（T4 统一口径）：这一格的意思是「升级到人来确认」，
+  // 不是「问了一句」。裁决历史页的裁决格用的是同一个词，两处必须一致。
+  ask: "转人工",
   reject: "拦截",
   none: "未裁决",
 };

package/lib/points/spec.js

@@ -121,6 +121,14 @@ function evidence(parts) {
     .join(" ");
 }
 
+/**
+ * 技能选择的「没有更匹配」保留选项。
+ *
+ * 用双下划线包起来是为了与真实技能名分处不同命名空间：技能名里出现
+ * `__none__` 的概率远低于 `none`，而旧值 `none` 在 decide 里仍按出口兼容。
+ */
+const SKILL_PICK_NONE = "__none__";
+
 /**
  * 各决策点的规格。
  *
@@ -212,6 +220,19 @@ export const POINT_SPECS = {
       const state = {
         turn: input.turn,
         step: input.step,
+        /**
+         * 这段 incoming 是「谁说的」。
+         *
+         * 修之前没有这一项：incoming 是把 `payload.messages` 全拼起来的，
+         * 而插件自己注入的 `[decision-engine-*]` 提示也是 `role: 'user'`。
+         * 于是插件可能对着自己刚写下的「建议开 subagent」再判一次分派，
+         * 把一条注入提示滚成自我确认的任务。
+         *
+         * origin 让「决策历史」能回答「这次凭什么认为有新用户任务」：
+         * `user` = 宿主声明 `source.kind === 'user'`；`legacy` = 老宿主没有
+         * source 时按 `role: 'user'` 且无插件前缀兜底；`user+legacy` = 两者都有。
+         */
+        origin: input.origin ?? "unknown",
         incoming: input.incoming ?? "",
         recent: input.recent ?? "",
       };
@@ -349,6 +370,23 @@ export const POINT_SPECS = {
         return { kind: "summarize", reason: `decision-engine-compact: 仍需逐字原文，交给摘要压缩（${note}）` };
       }
       if (parsed.distilled >= cfg.compactDistilledFloor) {
+        // 默认**绝不** prune：交给宿主摘要。
+        //
+        // 修之前：distilled 达线就直接 prune。但 prune 是不可逆的——中间段
+        // 一旦被换成标记，后续轮次再也拿不回原文；而 state 里只有「有几条
+        // 超长结果」这个数字，模型看不到它们是什么、哪些结论已经真正写进
+        // 对话。用一个 0.61 的概率授权不可逆删除，证据不够。
+        //
+        // 而 compaction-basic 的摘要至少把信息保成一段话。因此默认
+        // （compactAllowPrune=false）无论 distilled 多高都返回 summarize，
+        // 把「要不要摘要」留给宿主；只有运维显式打开 compactAllowPrune，
+        // 才允许这个点按门槛跳过摘要、只裁工具结果。
+        if (cfg.compactAllowPrune !== true) {
+          return {
+            kind: "summarize",
+            reason: `decision-engine-compact: 结论看似已落地，但未开启裁剪（compactAllowPrune=false），交给摘要压缩（${note}）`,
+          };
+        }
         return { kind: "prune", reason: `decision-engine-compact: 结论已落地，只丢陈旧工具结果并跳过摘要（${note}）` };
       }
       return { kind: "summarize", reason: `decision-engine-compact: 结论尚未落地，交给摘要压缩（${note}）` };
@@ -375,6 +413,17 @@ export const POINT_SPECS = {
     build(input) {
       const state = {
         turn: input.turn,
+        /**
+         * 用户最初提的要求（已截断）。
+         *
+         * 修之前 state 里只有 `last`（助手最后一句话）：模型判断「还有没有
+         * 没干完的活」时没有对照物——它只能从自己刚说的话里猜用户要什么，
+         * 而「未完成」恰恰是相对用户原始目标才成立的事实。
+         *
+         * 只取**第一条真实用户消息**：插件自己注入的 `[decision-engine-*]`
+         * 提示不算（否则目标会漂移到「继续把没做完的部分做完」上）。
+         */
+        goal: input.goal ?? "",
         last: input.last ?? "",
         pendingTools: input.pendingTools ?? 0,
         steered: input.steered ?? 0,
@@ -419,7 +468,9 @@ export const POINT_SPECS = {
       const value = readNoul(answers, "value");
       const closed = readNoul(answers, "closed");
       // awaiting_user 缺席**不算**形状不合格：旧端点可能不认识这个问题。
-      // 缺它 = 判不出来 = 不据此改变行为（fail-open），而不是把整次裁决作废。
+      // 但缺席也**不再**等于「不改变行为」：边界判不出来时 decide 禁止续轮
+      // （见 decide 的「边界第二道」）。理由与 DEC-045 同一条——在「是否在
+      // 等用户」未知时续轮，就是在边界未知的情况下替用户把选择顶掉。
       const awaitingUser = readNoul(answers, "awaiting_user");
       if (unfinished === undefined || value === undefined || closed === undefined) return undefined;
       return { unfinished, value, closed, awaitingUser };
@@ -438,7 +489,7 @@ export const POINT_SPECS = {
      *
      * **但 unfin 之前还有一道边界（DEC-045）**：模型在等用户时，unfin 会很高
      * （「还没决定用哪个方案」既没干完、也不 closed）。这时续轮就是越权，
-     * 所以边界判定排在最前面，且它的结果**只可能是让位**（`defer`）——
+     * 所以边界判定排在最前面，且它的结果**只可能是让位**（`defer` / `stop`）——
      * 本插件不会因为「在等用户」而替用户做任何决定，它只是不插手。
      */
     decide(parsed, cfg) {
@@ -464,6 +515,19 @@ export const POINT_SPECS = {
           reason: `decision-engine-turnstop: 这一轮在等用户决定，插件让位不介入（${note} await=${awaiting.toFixed(2)}）`,
         };
       }
+      // 边界第二道：awaiting_user 缺席 = 边界未知 → 禁止续轮。
+      //
+      // 修之前：这里直接往下走 unfinished 判据。于是旧端点（不认识这一问）
+      // 在「你选 A 还是 B？」这类轮次上拿到 unfin 0.9 / value 0.8 → continue，
+      // 用一个小模型的判断把用户的选择权顶掉——正是 DEC-045 要防的事，只是
+      // 从「判错」换成了「判不出来还硬判」。现在缺这一问就保守收束：代价
+      // 只是少续一轮，与 defer 的取舍完全一致。
+      if (awaiting === undefined) {
+        return {
+          kind: "stop",
+          reason: `decision-engine-turnstop: 无法判断这一轮是否在等用户（awaiting_user 缺席），保守收束不续轮（${note}）`,
+        };
+      }
       // 排在前面：确实还有活，且续一轮有增量价值 → 续。
       if (parsed.unfinished >= cfg.turnStopUnfinishedFloor && parsed.value >= cfg.turnStopValueFloor) {
         return { kind: "continue", reason: `decision-engine-turnstop: 仍有未完成的活，续一轮（${note}）` };
@@ -540,15 +604,23 @@ export const POINT_SPECS = {
   /**
    * 判断该装哪个技能。装错再换等于付两遍技能正文的 token，因此把候选清单
    * 交给决策模型挑一个，比让主模型自己试错便宜。
+   *
+   * choice 里「没有更匹配的技能」用保留键 `__none__`：修之前它直接叫 `none`，
+   * 一旦候选里真有一个名叫 none 的技能，criteria 里两行同名、后者覆盖前者——
+   * 模型选 `none` 时无法区分「没有更匹配」与「选了那个技能」，decide 也把
+   * 任何 `none` 当成出口，那个技能永远拿不到 redirect（正确调用被判成「没选」）。
+   * 控制流选项必须与业务数据（技能名）分处不同命名空间。
    */
   skillPick: {
     build(input) {
       const candidates = input.candidates ?? [];
       const criteria = {};
       for (const item of candidates) criteria[item.name] = item.description || item.name;
-      criteria.none = "No listed skill applies to the current request";
+      criteria[SKILL_PICK_NONE] = "No listed skill applies to the current request";
       const state = {
         requested: input.requested ?? "",
+        // 候选名字原样进 state：它们和 criteria 的键必须一致，否则模型
+        // 选出来的名字与后续的 suggest 校验对不上。
         candidates: candidates.map((item) => item.name),
         recent: input.recent ?? "",
       };
@@ -569,9 +641,18 @@ export const POINT_SPECS = {
       if (best === undefined) return undefined;
       return { best: best.choice, confidence: best.confidence };
     },
-    decide(parsed, cfg) {
+    decide(parsed, cfg, input) {
       const note = evidence([["conf", parsed.confidence]]);
-      if (parsed.best === "none") {
+      // 出口判定：
+      //   - 新保留键 `__none__` 一律是出口；
+      //   - 旧值 `none`（老端点 / 旧缓存）只在候选里没有同名技能时才按出口
+      //     解释——否则「名叫 none 的那个技能」就永远无法被建议。
+      const names = new Set(
+        (Array.isArray(input?.candidates) ? input.candidates : []).map((item) =>
+          typeof item === "string" ? item : item?.name,
+        ),
+      );
+      if (parsed.best === SKILL_PICK_NONE || (parsed.best === "none" && !names.has("none"))) {
         return { kind: "allow", reason: `decision-engine-skillpick: 没有更匹配的技能，放行（${note}）` };
       }
       if (parsed.confidence < cfg.skillPickConfidenceFloor) {