dsh-decision-engine 0.0.0-stage → 0.5.0

package/config.example.yml

@@ -0,0 +1,223 @@
+# dsh-decision-engine 配置模板
+#
+# 用法：复制到数据目录，按需修改。
+#   mkdir -p ~/.dsh/dsh-decision-engine
+#   cp config.example.yml ~/.dsh/dsh-decision-engine/config.yml
+#
+# 文件名是 config.yml：本插件早已不是「只服务 startlux 一家」的插件，
+# 而是任意 system-one 风格服务（system one / bamboonode / custom）的决策层，
+# 名字里再挂某个服务商只会误导。旧名 startlux.yml 仍会被自动读取并迁移，
+# 升级不需要重新填 key。
+#
+# 插件按以下顺序找配置，取第一个存在的：
+#   ~/.dsh/dsh-decision-engine/config.yml          （首选位置）
+#   ~/.dsh/dsh-decision-engine/startlux.yml        （旧名，首次启动自动改名）
+#   ~/.dsh/dsh-startlux-decision/startlux.yml      （上一代数据目录；自动拷到新目录）
+#   ~/.dsh/plugins/dsh-startlux-decision/startlux.yml
+#   ~/.dsh/plugins/dsh-startlux-guard/startlux.yml
+#
+# 数据目录（插件自动读取）：
+#   <上述目录>/config.yml          配置
+#   <上述目录>/telemetry.jsonl     决策记录
+#
+# 改完立即生效：每次工具调用 / 每一步前都会检查 mtime，无需重启 DSH。
+
+# 总开关：true 才开始工作（默认 false，不会擅自介入你的会话）
+enabled: false
+
+# shadow  = 只记录判断结果，绝不拦截（建议先用它观察一段时间）
+# enforce = 真正执行各决策点的处置
+#
+# 注意：这一项现在只是「工具授权」这一个决策点的历史开关。
+# 新写法是给每个决策点单独指定模式，见下面的 pointXxx。
+# pointAuthorize 留 auto 时，就沿用这里的 mode（shadow→observe、enforce→enforce）。
+mode: shadow
+
+# ============================================================================
+# 服务提供方（provider）
+# ============================================================================
+# 三选一：
+#   bamboonode  内置。StartLux 官方端点 POST /v1/decisions，本插件的原有默认值。
+#   systemone   内置。任意 System One 协议服务 POST /v1/systemone，
+#               默认指向 TypeSafe（https://api.typesafe.ai/v1）。
+#   custom      自己填 base URL，接任何 system-one 风格服务
+#               （自建 llama.cpp / vLLM、企业网关、第三方中转）。
+#
+# 不写这一项 = bamboonode，老配置行为完全不变。
+provider: bamboonode
+
+# ---- bamboonode 预设的地址覆盖 ----------------------------------------------
+# 只在 provider=bamboonode 时生效。老版本唯一的地址字段，继续支持，因此
+# 已有的自建 bamboonode 兼容地址不会因为升级被改回官方。
+# 接受多种写法（等价）：
+#   https://api.bamboonode.dev/v1
+#   https://api.bamboonode.dev/v1/decisions
+#   api.bamboonode.dev/v1          （会补 https://）
+# 末尾斜杠会被规范化，不会拼出 //decisions 或 /v1/v1/decisions。
+baseUrl: https://api.bamboonode.dev/v1
+
+# ---- 模型（按 provider 分开存，切换时互不覆盖）------------------------------
+# bamboonode 的模型。留空 = 自动（由服务端选当前默认决策模型），
+# 这样服务商将来换模型名时，本配置不会失效。
+model:
+
+# system one 的模型。留空 = 服务端默认（jev-latest）。
+# 与上面的 model 分开：否则切到 system one 会把 bamboonode 的模型名发过去，
+# 得到 400 model not served。
+systemoneModel: ""
+
+# ---- custom 预设（provider=custom 时才生效）--------------------------------
+# base URL 必填，且必须是 http/https 地址；不带 scheme 会被拒绝（内置预设
+# 允许省略 scheme，custom 不允许——自定义地址必须显式，避免猜错协议）。
+# customBaseUrl: https://api.example.com/v1
+#
+# 端点风格：
+#   auto       地址已带 /decisions 或 /systemone 就原样用，否则按 decisions 拼
+#   decisions  POST <base>/decisions
+#   systemone  POST <base>/systemone
+customEndpointStyle: auto
+#
+# custom 自己的模型（留空 = 服务端默认）。与内置预设的 model 分开存，
+# 这样在两者之间来回切换不会互相覆盖。
+customModel: ""
+# custom 的 key；留空则读 customApiKeyEnv（环境变量或 .credentials.yaml 的 refs）
+customApiKey: ""
+customApiKeyEnv: ""
+# 附加请求头，格式 `名称: 值`，多项用分号分隔。
+# authorization / content-type / host 由插件固定，写了也会被忽略。
+customHeaders: ""
+
+# ============================================================================
+# 密钥
+# ============================================================================
+# 每个 provider 有**自己的** key 名，各自保存各自的 key：
+#
+#   system one -> TYPESAFE_API_KEY
+#   bamboonode -> BAMBOO_API_KEY
+#   custom     -> customApiKeyEnv（没填时用 DECISION_ENGINE_CUSTOM_KEY）
+#
+# 三者互不覆盖，可以同时配好；切换 provider 不会串用别人的 key。
+
+# 密钥存到哪里：
+#   credentials = ~/.dsh/.credentials.yaml 的 refs 段（默认，与其他服务统一托管）
+#   config      = 本文件（自包含，便于随目录备份；注意这里是明文）
+keyStorage: credentials
+
+# 变量名可以覆盖（留空即用上面的默认名）：
+# systemoneApiKeyEnv: ""
+# bamboonodeApiKeyEnv: ""
+# customApiKeyEnv: ""
+
+# 直接写明文 key 也可以（各 provider 一格，互不影响）。
+# 若 keyStorage=credentials，在设置界面粘贴的 key 会写进 .credentials.yaml，
+# 不会落到这里；只有 keyStorage=config 时下面这些字段才会被写入。
+# systemoneApiKey: ""
+# bamboonodeApiKey: ""
+# customApiKey: ""
+
+# .credentials.yaml 里的形态就是 refs 段：
+#   refs:
+#     BAMBOO_API_KEY: sk-你的key
+#     TYPESAFE_API_KEY: sk-另一个key
+
+# 超时预算（毫秒）。超时自动降级放行，连续失败进入冷却。
+timeoutMs: 8000
+
+# 思考模式（startlux 的 think_mode），三档：
+#   never  不思考——最省延迟（实测约 1.9s vs 7.2s），默认值，热路径首选
+#   auto   仅在模型自己判断需要时思考——折中
+#   always 总是思考——判断更充分，但每次工具调用约多等 5 秒
+# 该端点 output_tokens 恒为 0，思考开销不计入计量，所以省的主要是延迟。
+thinkMode: never
+
+# ============================================================================
+# 决策模型参与点
+# ============================================================================
+# 三态：off 不参与 / observe 只记录不干预 / enforce 真正生效。
+# 九个点全部已实装。新点默认 off —— 升级不会改变现有行为。
+#
+# 建议：先 observe 跑一段时间，对着 telemetry.jsonl 确认与人工判断一致，
+# 再逐点切 enforce。热路径的点（route / delegate / cotTranslate）尤其如此。
+
+# ---- 1. 工具授权：每次工具调用前判断能否放行 -------------------------------
+# 替代 auto-review——后者把完整会话历史发给主模型，每次调用都跑一遍。
+pointAuthorize: auto
+
+# ---- 2. 模型路由：机械步骤下沉到便宜模型 -----------------------------------
+# 热路径。三道闸控量：每轮最多 routeMaxStepsPerTurn 步、路由未变不问、
+# 新用户输入后的步骤不问。
+# 必须同时配好 routeCheapProvider + routeCheapModel 才会真的换模型；
+# 两者留空时即便打开此点也只会记录「本该换」。
+pointRoute: off
+routeCheapProvider: ""
+routeCheapModel: ""
+# routeMaxStepsPerTurn: 3
+# routeMaxScore: 0.4        # 能力需求归一化后超过此值就保留强模型
+# routeMechanicalFloor: 0.6 # 「机械步骤」的最低置信
+# routeRiskFloor: 0.3       # 风险达线一律保留强模型
+
+# ---- 3. 子任务分派：接着做 / 开 subagent / 组 agent team -------------------
+# 热路径。只在每轮第一步且带新用户输入时判断（分派只在这一刻可能改变）。
+# 生效时注入一条提示，不替模型决定——工具选择仍归模型。
+pointDelegate: off
+# delegateConfidenceFloor: 0.5  # 三选项均分 0.33，实测需 ≥0.5 才算有倾向
+# delegateBlockingFloor: 0.6    # 被本地事实阻塞时继续内联
+# delegateParallelFloor: 0.5    # 组队还需真并行才有意义
+
+# ---- 4. 上下文压缩：摘要 vs 只丢陈旧工具结果 -------------------------------
+# 非热路径。只在实测 token 达触发线（compactThresholdRatio × 窗口）才问。
+# 生效方式：先跑宿主的确定性工具结果裁剪；compaction-basic 随后重新测压，
+# 低于阈值就跳过摘要——这才是真正省下的那一次调用。
+pointCompact: off
+# compactContextWindow: 0     # 0 = 用 compactTriggerTokens 绝对阈值
+# compactThresholdRatio: 0.7  # 提前于 compaction-basic 的 0.8 介入
+# compactTriggerTokens: 100000
+# compactToolResultChars: 8192
+# compactDistilledFloor: 0.6  # 结论已落地 → 允许只裁剪
+# compactVerbatinFloor: 0.6   # 仍需逐字原文 → 一律摘要（安全否决优先）
+
+# ---- 5. 轮次延续：再来一轮有没有增量价值 -----------------------------------
+# 非热路径。生效方式是用 agent.steer() 续一轮，每轮最多 turnStopMaxSteers 次。
+pointTurnStop: off
+# turnStopMaxSteers: 1
+# turnStopClosedFloor: 0.6
+# turnStopUnfinishedFloor: 0.6
+# turnStopValueFloor: 0.35    # 只作弱确认；主判据是 unfinished
+
+# ---- 6. 检索必要性：这条信息是不是已经知道 ---------------------------------
+# 非热路径。只对检索类工具生效，其余工具零开销。
+pointRetrieval: off
+# retrievalTools: [web_search, web_fetch, research, multi_search, advanced_search]
+# retrievalCoveredFloor: 0.5     # 上下文已覆盖该事实
+# retrievalWouldAddCeiling: 0.8  # 且再搜基本没有新信息
+
+# ---- 7. 技能选择：该装哪个技能 ---------------------------------------------
+# 非热路径。只对 skill 工具、且候选 ≥2 时判断。
+# 生效时拦下不匹配的加载并指路，避免「装错再换」付两遍正文 token。
+pointSkillPick: off
+# skillPickCandidates: 8      # 送给模型挑选的候选上限（只带名称+描述）
+# skillPickConfidenceFloor: 0.5
+
+# ---- 8. 思维链翻译门槛：这条内容真的需要翻译吗 -----------------------------
+# 热路径（每条消息）。本地先做免费预筛（去代码块/URL 后判断有无正文），
+# 预筛不过的直接跳过，不发请求。生效时判为「不需要」则返回原文。
+pointCotTranslate: off
+# cotProseFloor: 0.5
+# cotSameLanguageFloor: 0.8
+
+# ============================================================================
+# 自身开销护栏
+# ============================================================================
+# 决策模型自己也烧 token（实测约 1.9k/次，p50 约 0.5s）。
+# 这是每小时上限，超出后所有决策点自动退回启发式并放行——
+# 省钱的东西不能反过来变成主要消耗方。0 表示不限制。
+budgetTokens: 400000
+budgetWindowMs: 3600000
+
+# ---- 以下为可选调优项 ----
+# cacheSize: 256            # 缓存条数上限
+# cacheTtlMs: 600000        # 裁决存活时间
+# recentMessages: 4         # 带给模型的上下文条数
+# guardReadOnlyTools: [read, grep, glob, todo_write]
+# guardDenyConfidence: 0.85
+# guardIrreversibleCeiling: 0.2

package/cordis.patch.yml

@@ -0,0 +1,14 @@
+# dsh-decision-engine 的 bundle 层。
+#
+# 这里**刻意不写 config**。
+#
+# 原因：bundle patch 属于 profile 配置层，而 DSH 传给插件 apply() 的 config
+# 是 Schemastery 解析后的完整默认值（enabled:false / mode:shadow ...），
+# 并非用户显式配置。若在此硬编码，会盖掉用户在配置页保存的选择，
+# 表现为「一按保存就自动弹回关闭」。
+#
+# 运行时配置的唯一来源是插件目录下的 config.yml（配置页保存的也是它）。
+# 插件内的 DEFAULTS 只负责兜底，不在此重复声明。
+- insert:
+    - id: decision-engine
+      name: dsh-decision-engine

package/icon.svg

@@ -0,0 +1,17 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="StartLux Decision">
+  <!-- Bamboo Relay 官方标识（bamboonode.dev），等比放大到插件图标尺寸 -->
+  <defs>
+    <linearGradient id="bamboo-grad" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0%" stop-color="#3AC251"/>
+      <stop offset="55%" stop-color="#2BAE7E"/>
+      <stop offset="100%" stop-color="#1481BF"/>
+    </linearGradient>
+  </defs>
+  <g transform="translate(4 4) scale(2)">
+    <rect x="3" y="10" width="3.2" height="16" rx="1.6" fill="url(#bamboo-grad)"/>
+    <rect x="8" y="4" width="3.2" height="22" rx="1.6" fill="url(#bamboo-grad)"/>
+    <rect x="13" y="0" width="3.2" height="26" rx="1.6" fill="url(#bamboo-grad)"/>
+    <rect x="18" y="6" width="3.2" height="20" rx="1.6" fill="url(#bamboo-grad)"/>
+    <rect x="23" y="12" width="3.2" height="14" rx="1.6" fill="url(#bamboo-grad)"/>
+  </g>
+</svg>

package/lib/adapters/agent.js

@@ -0,0 +1,307 @@
+/**
+ * 子任务分派、轮次延续、上下文压缩 —— 三个都挂在 `agent/pre-step` 与
+ * `agent/turn-stopping` 上的适配器。
+ *
+ * 为什么合在一个文件：三者的触发条件都依赖「这一步/这一轮到哪了」，
+ * 分成三个监听器会让同一份 inbox/step 状态被读三遍，也让「这一步到底问了
+ * 几个决策点」变得难以推断。这里用一个 pre-step 监听器内部分派。
+ *
+ * 各点的生效方式都刻意保守：
+ *
+ *   分派    只注入一条 runtime-context 建议，绝不替模型开子代理
+ *           （开子代理是模型的决定，插件越权会让上下文分叉不可控）
+ *   轮次    用 `agent.steer()` 续一轮，且每轮最多一次
+ *   压缩    只在自己判定够便宜时先跑确定性裁剪；摘要交给 compaction-basic
+ *
+ * @module dsh-decision-engine/adapters/agent
+ */
+
+/**
+ * 挂载分派 / 轮次 / 压缩三个监听器。
+ * @param ctx - cordis 插件上下文。
+ * @param deps - 运行期依赖。
+ */
+export function mountAgentPoints(ctx, deps) {
+  const { runner, getConfig, digestRecent, telemetry, makeUserMessage } = deps;
+
+  /** 每会话的续轮计数：turn → 已 steer 次数。防止自续无限循环。 */
+  const steerCounts = new WeakMap();
+
+  const steersThisTurn = (session, turn) => {
+    const map = steerCounts.get(session);
+    return map?.get(turn) ?? 0;
+  };
+
+  const noteSteer = (session, turn) => {
+    let map = steerCounts.get(session);
+    if (map === undefined) {
+      map = new Map();
+      steerCounts.set(session, map);
+    }
+    map.set(turn, (map.get(turn) ?? 0) + 1);
+    // 只保留最近两轮，避免长会话里这个 Map 无界增长。
+    if (map.size > 2) {
+      const oldest = map.keys().next();
+      if (!oldest.done) map.delete(oldest.value);
+    }
+  };
+
+  /** 取最近一步的助手文本，作为「这一轮说了什么」的判断依据。 */
+  const lastAssistantText = (session, chars) => {
+    let events;
+    try {
+      events = session.events ?? [];
+    } catch {
+      return "";
+    }
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index];
+      if (event?.type !== "assistant/message") continue;
+      const content = event.data?.message?.content;
+      if (!Array.isArray(content)) continue;
+      const text = content
+        .map((block) => (block?.type === "text" && typeof block.text === "string" ? block.text : ""))
+        .filter((part) => part.length > 0)
+        .join(" ");
+      if (text.length > 0) return text.slice(-chars);
+    }
+    return "";
+  };
+
+  // ---------------------------------------------------------------- pre-step
+  const preStep = async (payload, next) => {
+    const decision = await next();
+    // 判 reject 说明这一步根本没进入，注入建议没有意义。
+    if (decision.kind === "reject") return decision;
+    const agent = payload?.agent;
+    if (agent?.session === undefined) return decision;
+    const cfg = getConfig();
+
+    try {
+      const additions = [];
+
+      // ---- 上下文压缩 ------------------------------------------------
+      if (runner.participates("compact")) {
+        const compacted = await maybePruneContext(ctx, agent, payload, cfg, runner, telemetry);
+        if (compacted !== undefined) additions.push(compacted);
+      }
+
+      // ---- 子任务分派 ------------------------------------------------
+      // 只在「每轮第一步 + 这一步确实带着新的用户输入」时判断：
+      // 分派决策只在这个时刻可能改变，后续步骤再问必然是 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) {
+          const result = await runner.ask(
+            "delegate",
+            {
+              turn: payload.turn,
+              step: payload.step,
+              incoming,
+              recent: digestRecent(agent.session, cfg.recentMessages, cfg.recentMessageChars),
+            },
+            { signal: payload.signal },
+          );
+          // 只有明确建议「开子代理/组队」时才注入提示；inline 不打扰。
+          if (runner.enforces("delegate") && result.action?.kind === "advise") {
+            additions.push(
+              makeUserMessage(
+                `[decision-engine-delegate] ${result.action.reason}\n` +
+                  `如果确实适合，请用 subagent / 团队工具把它分出去；否则直接在当前上下文里做完，不要为了分派而分派。`,
+                "delegate",
+              ),
+            );
+          }
+        }
+      }
+
+      if (additions.length === 0) return decision;
+      return { ...decision, messages: [...decision.messages, ...additions] };
+    } catch (error) {
+      telemetry.noteAdapterError("pre-step", error, ctx);
+      return decision;
+    }
+  };
+
+  ctx.on("agent/pre-step", preStep);
+
+  // ----------------------------------------------------------- turn-stopping
+  /**
+   * 轮次延续：`agent/turn-stopping` 是 serial 而不是 waterfall，返回值不传递，
+   * 唯一的生效方式是调用 `agent.steer(...)` 把消息塞回 inbox —— 机器随后
+   * 重新读一遍 inbox，有东西就再跑一步。
+   *
+   * 契约明确写了「数据决定，监听器顺序不改变结果」，因此这里唯一能做的就是
+   * 「steer 或不 steer」，不能否决别的监听器的意见。
+   */
+  const turnStopping = async (payload) => {
+    const agent = payload?.agent;
+    if (agent?.session === undefined) return;
+    if (!runner.participates("turnStop")) return;
+
+    try {
+      const cfg = getConfig();
+      // 每轮最多续一次：否则一轮里的空转会被无限放大成烧钱循环。
+      if (steersThisTurn(agent.session, payload.turn) >= Math.max(0, cfg.turnStopMaxSteers ?? 1)) return;
+
+      const last = lastAssistantText(agent.session, cfg.recentMessageChars * 4);
+      const result = await runner.ask(
+        "turnStop",
+        {
+          turn: payload.turn,
+          last,
+          pendingTools: 0,
+          steered: steersThisTurn(agent.session, payload.turn),
+        },
+        { signal: payload.signal },
+      );
+
+      if (!runner.enforces("turnStop")) return;
+      if (result.action?.kind !== "continue") return;
+      if (typeof agent.steer !== "function") return;
+
+      noteSteer(agent.session, payload.turn);
+      agent.steer(
+        makeUserMessage(
+          `[decision-engine-turnstop] ${result.action.reason}\n继续把没做完的部分做完；如果其实已经完成，直接说明结论即可。`,
+          "turnStop",
+        ),
+      );
+      ctx.logger?.info?.(`dsh-decision-engine: 第 ${payload.turn} 轮按决策续一轮`);
+    } catch (error) {
+      telemetry.noteAdapterError("turnStop", error, ctx);
+    }
+  };
+
+  ctx.on("agent/turn-stopping", turnStopping);
+}
+
+/** 把一条消息压成纯文本（只取 text block）。 */
+function textOf(message) {
+  const content = message?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((block) => (block?.type === "text" && typeof block.text === "string" ? block.text : ""))
+    .filter((part) => part.length > 0)
+    .join(" ");
+}
+
+/**
+ * 上下文压缩：判断「现在只丢陈旧工具结果够不够」。
+ *
+ * 生效方式是调用宿主的 `toolResultPruner.pruneSession(session)` —— 这是一个
+ * 纯确定性、无模型、replay 安全的裁剪，把超长工具结果的中间段换成标记。
+ * 裁完之后 compaction-basic 会在同一步重新测量压力：低于阈值它就**跳过摘要**，
+ * 于是真正省下一次摘要调用。
+ *
+ * 绝不在 observe 模式下裁剪（那会改变会话内容），也绝不在没超阈值时裁剪。
+ *
+ * @returns 需要追加进这一步的提示消息，或 undefined（不注入）。
+ */
+async function maybePruneContext(ctx, agent, payload, cfg, runner, telemetry) {
+  const meter = ctx.get?.("tokenMeter");
+  const pruner = ctx.get?.("toolResultPruner");
+  if (meter === undefined || pruner === undefined) return undefined;
+
+  let measurement;
+  try {
+    measurement = meter.measure(agent.session);
+  } catch {
+    return undefined;
+  }
+  const total = Number(measurement?.totalTokens ?? 0);
+  if (total <= 0) return undefined;
+
+  // 触发线：compaction-basic 默认 thresholdRatio 0.8。它只在达到 0.8×contextWindow
+  // 时才动手，所以我们要在它之前判断，取 0.7 作为「提前介入」的位置。
+  // 拿不到 contextWindow 时退回绝对阈值，避免完全不动。
+  const contextWindow = Number(cfg.compactContextWindow ?? 0);
+  const threshold = contextWindow > 0 ? contextWindow * (cfg.compactThresholdRatio ?? 0.7) : (cfg.compactTriggerTokens ?? 100000);
+  if (total < threshold) return undefined;
+
+  // 先数一下有多少超长工具结果，没有就不必问模型。
+  const oversized = countOversizedToolResults(agent.session, cfg.compactToolResultChars ?? 8192);
+  if (oversized === 0) return undefined;
+
+  const result = await runner.ask(
+    "compact",
+    {
+      totalTokens: total,
+      triggerTokens: Math.round(threshold),
+      oversized,
+      nodes: Array.isArray(measurement?.nodes) ? measurement.nodes.length : 0,
+      recent: digestRecentSafe(agent.session, cfg),
+    },
+    { signal: payload.signal },
+  );
+
+  if (!runner.enforces("compact")) return undefined;
+  if (result.action?.kind !== "prune") return undefined;
+
+  let pruned;
+  try {
+    pruned = pruner.pruneSession(agent.session);
+  } catch (error) {
+    telemetry.noteAdapterError("compact", error, ctx);
+    return undefined;
+  }
+  if (pruned === undefined || pruned.pruned.length === 0) return undefined;
+
+  ctx.logger?.info?.(
+    `dsh-decision-engine: 裁剪 ${pruned.pruned.length} 条超长工具结果，省 ${pruned.charsRemoved} 字符（${result.action.reason}）`,
+  );
+  return undefined;
+}
+
+/** 数当前 surface 上超长的 tool/result 数量。 */
+function countOversizedToolResults(session, limit) {
+  let count = 0;
+  let nodes;
+  try {
+    nodes = session.surface?.nodes;
+  } catch {
+    return 0;
+  }
+  if (nodes === undefined) return 0;
+  for (const seq of nodes) {
+    let event;
+    try {
+      event = session.eventAt(seq);
+    } catch {
+      continue;
+    }
+    if (event?.type !== "tool/result") continue;
+    const content = event.data?.message?.content;
+    if (!Array.isArray(content)) continue;
+    let chars = 0;
+    for (const block of content) {
+      if (block?.type === "text" && typeof block.text === "string") chars += block.text.length;
+    }
+    if (chars > limit) count += 1;
+  }
+  return count;
+}
+
+/** 压缩判断里只需要很短的上下文；单独一个 helper 避免把大字符串传进 state。 */
+function digestRecentSafe(session, cfg) {
+  try {
+    const count = Math.min(cfg.recentMessages ?? 0, 4);
+    if (count <= 0) return "";
+    const events = session.events ?? [];
+    const lines = [];
+    for (let index = events.length - 1; index >= 0 && lines.length < count; index -= 1) {
+      const event = events[index];
+      if (event?.type !== "user/message" && event?.type !== "assistant/message") continue;
+      const text = textOf(event.data?.message ?? event.data);
+      if (text.length > 0) lines.unshift(text.slice(0, 160));
+    }
+    return lines.join("\n");
+  } catch {
+    return "";
+  }
+}