dsh-decision-layer 0.5.5 → 0.5.6

package/README.md

@@ -40,7 +40,7 @@ dsh plugin --profile web add file:/绝对路径/dsh-decision-layer
 - **产出自检**：回合结束用评分量表给最终产出打分（0–2，按各档位概率加权，可能是小数）。默认只提示、不打断；可开启「低分补完」，得分偏低且模型有把握时以你的名义追加一次补完提示，同一回合最多补一次。
 - **任务完成核对**：当用户明确列出多个交付条件（编号 / 项目符号 / 多命令）时，回合结束前用单选逐项判定「已满足 / 未满足 / 证据不足」，工具证据优先、回复自述不算证据；确定性提取、不推断隐含期望。默认只观察、可配 steer，与产出自检并存、指标分列。
 - **产出质量趋势告警**：建在自检数据上的只读提醒。连续多次高置信低分时，把输入框旁触发按钮的图标从灰变橙、变红，hover 提示可能是任务变难或模型波动、建议调整 prompt 或更换模型。纯提示、不驱动自动干预；高置信门槛 / 连续轮数 / 严重档三个阈值可配（默认 0.6 / 3 / 5），偏保守、待实测校准。
-- **工具收窄**：回合开始时用 noul 逐个判断可选工具与本轮任务的相关性，摘掉用不上的（相关性概率低于摘除阈值，默认 0.3、可配），只在宿主已允许的集合内取交集、不扩权。默认真正生效，可切到「仅观察」只记录不改工具集。三重保护：核心工具（读写、编辑、Shell、检索、待办，以及问用户、目标、技能、交付、后台作业、协作等 agent 元能力）始终保留、不参与判定；可选工具超过候选上限（默认 20，可配）时自动降为仅观察；保留下来不足 5 个时视为判定不可信、跳过。**保留工具前缀**白名单里的工具（默认含 `mcp__openviking`、`team_task_`）也始终保留、不参与判定，适合记忆 / 检索、协作这类常驻、按需触发的工具。
+- **工具收窄**：回合开始时用 noul 逐个判断可选工具与本轮任务的相关性，摘掉用不上的（相关性概率低于摘除阈值，默认 0.3、可配），只在宿主已允许的集合内取交集、不扩权。默认真正生效，可切到「仅观察」只记录不改工具集。三重保护：核心工具（读写、编辑、Shell、检索、待办，以及问用户、目标、技能、交付、后台作业、协作等 agent 元能力）始终保留、不参与判定；可选工具超过候选上限（默认 20，可配）时自动降为仅观察；保留下来不足 5 个时视为判定不可信、跳过。**保留工具前缀**白名单里的工具（默认含 `mcp__openviking`、`team_task_`）也始终保留、不参与判定，适合记忆 / 检索、协作这类常驻、按需触发的工具。**分批策略**按后端上下文容量自适应（`batchMode`，默认 `auto`）：大上下文后端（如 Jev）一次请求判完全部工具；小上下文后端（如本地 tev1，约 2050 token 单请求上限）在遇到上下文超限错误时自动降级为「每工具一次请求、并发执行」并记住，之后直接走拆分，不再反复探测。也可显式设 `single`（始终整批）或 `split`（始终逐工具）。某个工具的拆分请求失败时该工具保守保留。
 - **防循环**：确定性判断，不走后端；同一调用连续重复超过阈值即拒绝，打断死循环。始终生效，不在决策点开关范围内。
 - **会话面板**：输入框下方的 dock 触发器弹出面板，展示自动裁决指标（评估数、失败回退、模型建议与实际结果分列）、会话总开关和决策日志；无自动裁决时显示空态。总开关关闭只暂停自动介入，不影响手动裁决。
 - **决策分析页**：会话内「决策分析」tab（`conversation.view`，与对话/轨迹平级、天然按会话隔离），基于已落盘日志做只读聚合，展示过程画像（各决策点触发数与结果分布、自检平均分）、质量趋势阈值回测、判断准确度汇总，并可对每条决策标注「判对 / 判错 / 说不准」。标注与介入面板同源：任一处标注都写入同一份日志、按决策 id 关联、取最新。只读日志、只追加标注，不改任何决策行为。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-decision-layer",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description": "A structured decision layer for the DeepSeek Harness agent loop: a danger-call gate, output self-check, tool narrowing, and loop guard backed by a pluggable adjudication model.",
   "keywords": [
     "dsh",

package/service/config-store.mjs

@@ -97,7 +97,7 @@ function validCheck(value) {
 
 function validNarrow(value) {
   if (!safeObject(value)) return undefined;
-  if (Object.keys(value).some(key => !['mode', 'threshold', 'keepPrefixes', 'maxCandidates'].includes(key))) throw new Error('Invalid narrowing settings');
+  if (Object.keys(value).some(key => !['mode', 'threshold', 'keepPrefixes', 'maxCandidates', 'batchMode'].includes(key))) throw new Error('Invalid narrowing settings');
   const narrow = {};
   if (value.mode !== undefined) {
     if (value.mode !== 'observe' && value.mode !== 'enforce') throw new Error('Invalid narrowing settings');
@@ -124,6 +124,17 @@ function validNarrow(value) {
     if (!Number.isSafeInteger(value.maxCandidates) || value.maxCandidates < 1 || value.maxCandidates > 200) throw new Error('Invalid narrowing settings');
     narrow.maxCandidates = value.maxCandidates;
   }
+  // Per-request batching strategy for the relevance pass, chosen by backend
+  // context capacity. 'single' sends every tool in one systemone request (best
+  // for large-context backends like Jev — one call). 'split' sends one request
+  // per tool concurrently (required for small-context backends like tev1, whose
+  // ~2050-token prompt limit rejects a many-tool request). 'auto' (default)
+  // tries 'single' first and falls back to 'split' only after a context-overflow
+  // http-error, so Jev stays at one call and tev1 self-corrects.
+  if (value.batchMode !== undefined) {
+    if (!['auto', 'single', 'split'].includes(value.batchMode)) throw new Error('Invalid narrowing settings');
+    narrow.batchMode = value.batchMode;
+  }
   return narrow;
 }
 

package/service/narrowing.mjs

@@ -82,15 +82,22 @@ export function relevanceQuestions(state, tools) {
 //   C. if narrowing would leave fewer than `minKeep` tools total, the verdict is
 //      treated as untrustworthy and no restriction is applied.
 export function createNarrowing({ evaluate, sessions, settings, coreTools = DEFAULT_CORE_TOOLS,
-  keepPrefixes = DEFAULT_KEEP_PREFIXES, minCandidates = 2, maxCandidates = 20, minKeep = 5 } = {}) {
+  keepPrefixes = DEFAULT_KEEP_PREFIXES, minCandidates = 2, maxCandidates = 20, minKeep = 5, splitConcurrency = 8 } = {}) {
   if (typeof evaluate !== 'function') throw new Error('Narrowing requires an evaluator');
   const core = new Set(Array.isArray(coreTools) ? coreTools.filter(name => typeof name === 'string') : []);
   const defaultPrefixes = Array.isArray(keepPrefixes) ? keepPrefixes.filter(prefix => typeof prefix === 'string' && prefix) : [];
+  const concurrency = Number.isSafeInteger(splitConcurrency) && splitConcurrency >= 1 ? splitConcurrency : 8;
+  // Set once a 'single' (whole-batch) pass hits a context-overflow http-error:
+  // from then on 'auto' sends one request per tool. A large-context backend
+  // (Jev) never trips this and stays at one call; a small-context backend
+  // (tev1, ~2050-token prompt) self-corrects after the first failure.
+  let adaptiveSplit = false;
   const resolveSettings = async () => {
     let raw = {};
     try { raw = (typeof settings === 'function' ? await settings() : settings) ?? {}; } catch { raw = {}; }
     const mode = raw?.mode === 'observe' ? 'observe' : 'enforce';
     const threshold = typeof raw?.threshold === 'number' && Number.isFinite(raw.threshold) && raw.threshold >= 0 && raw.threshold <= 1 ? raw.threshold : 0.3;
+    const batchMode = raw?.batchMode === 'single' || raw?.batchMode === 'split' ? raw.batchMode : 'auto';
     // An explicit array in settings (including empty) overrides the default set.
     const prefixes = Array.isArray(raw?.keepPrefixes)
       ? raw.keepPrefixes.filter(prefix => typeof prefix === 'string' && prefix)
@@ -100,7 +107,7 @@ export function createNarrowing({ evaluate, sessions, settings, coreTools = DEFA
     // never large enough to be rejected before it is sent.
     const configuredCap = Number.isSafeInteger(raw?.maxCandidates) && raw.maxCandidates >= 1 ? raw.maxCandidates : maxCandidates;
     const cap = Math.min(configuredCap, MAX_QUESTIONS);
-    return { mode, threshold, prefixes, cap };
+    return { mode, threshold, prefixes, cap, batchMode };
   };
   const record = (turn, outcome, detail = {}) => {
     const id = turn?.agent?.session?.id;
@@ -111,12 +118,34 @@ export function createNarrowing({ evaluate, sessions, settings, coreTools = DEFA
     try { sessions.log(id, { kind: 'narrow', outcome, ...detail }); }
     catch { /* logging is best effort */ }
   };
+  // Send one relevance request per tool with bounded concurrency, then merge the
+  // per-tool answers into one result. Each request's prompt is only the task
+  // state plus a single question, so it cannot exceed a small-context backend's
+  // prompt limit. A tool whose request fails is omitted from the merged answers,
+  // which narrowTools treats as "keep" (best effort). Returns null only when
+  // every tool failed, so the caller can still report a backend error.
+  const evaluateSplit = async (state, tools, signal) => {
+    const answers = Object.create(null);
+    let anyOk = false;
+    for (let i = 0; i < tools.length; i += concurrency) {
+      const group = tools.slice(i, i + concurrency);
+      const settled = await Promise.all(group.map(async tool => {
+        try {
+          const reply = await evaluate(relevanceQuestions(state, [tool]), { signal });
+          const answer = reply?.answers?.[tool.name];
+          return isObject(answer) ? [tool.name, answer] : undefined;
+        } catch { return undefined; }
+      }));
+      for (const pair of settled) { if (pair) { answers[pair[0]] = pair[1]; anyOk = true; } }
+    }
+    return anyOk ? { model: 'split', answers } : null;
+  };
   const skip = { evaluated: false, applied: false, keep: [], drop: [], mode: 'observe' };
   return {
     async review(turn) {
       const tools = Array.isArray(turn?.tools) ? turn.tools.filter(tool => tool && typeof tool.name === 'string') : [];
       const names = tools.map(tool => tool.name);
-      const { mode, threshold, prefixes, cap } = await resolveSettings();
+      const { mode, threshold, prefixes, cap, batchMode } = await resolveSettings();
       // A: core tools and keep-prefix matches are always kept and never sent to
       // the model for judging (e.g. mcp__openviking memory tools stay resident).
       const alwaysKeep = name => core.has(name) || prefixes.some(prefix => name.startsWith(prefix));
@@ -139,9 +168,29 @@ export function createNarrowing({ evaluate, sessions, settings, coreTools = DEFA
       const effectiveMode = overCap ? 'observe' : mode;
       const judged = overCap ? optional.slice(0, cap) : optional;
       const judgedNames = judged.map(tool => tool.name);
+      // Choose per-request strategy by backend context capacity. 'split' (or an
+      // 'auto' pass that already fell back) sends one request per tool so no
+      // prompt exceeds a small-context limit. 'single'/'auto' first try one
+      // whole-batch request; under 'auto', a context-overflow http-error flips
+      // this instance to split from then on and retries the same tools split.
       let result;
-      try { result = await evaluate(relevanceQuestions(turn.state, judged), { signal: turn.signal }); }
-      catch (error) { record(turn, 'error', { reason: typeof error?.reason === 'string' ? error.reason : 'unreachable', mode: effectiveMode }); return { ...skip, keep: names, mode: effectiveMode }; }
+      if (batchMode === 'split' || adaptiveSplit) {
+        result = await evaluateSplit(turn.state, judged, turn.signal);
+        if (!result) { record(turn, 'error', { reason: 'unreachable', mode: effectiveMode }); return { ...skip, keep: names, mode: effectiveMode }; }
+      } else {
+        try { result = await evaluate(relevanceQuestions(turn.state, judged), { signal: turn.signal }); }
+        catch (error) {
+          const reason = typeof error?.reason === 'string' ? error.reason : 'unreachable';
+          if (batchMode === 'auto' && reason === 'http-error') {
+            adaptiveSplit = true;
+            result = await evaluateSplit(turn.state, judged, turn.signal);
+            if (!result) { record(turn, 'error', { reason, mode: effectiveMode }); return { ...skip, keep: names, mode: effectiveMode }; }
+          } else {
+            record(turn, 'error', { reason, mode: effectiveMode });
+            return { ...skip, keep: names, mode: effectiveMode };
+          }
+        }
+      }
       const narrowed = narrowTools(judgedNames, result, { threshold });
       const keep = [...keptNames, ...narrowed.keep];
       const drop = narrowed.drop;