dsh-decision-layer 0.5.4 → 0.5.6

package/README.en.md

@@ -4,7 +4,7 @@
 
 `dsh-decision-layer` adds structured, explicitly scoped decisions to the DeepSeek Harness (DSH) agent loop, backed by a pluggable adjudication backend. Dangerous-call gating, output self-check, tool narrowing, and loop prevention hook into the agent loop as automatic interventions.
 
-> **0.5.4 is a preview release.** The plugin works, but how much real value the adjudication interventions add is still being explored — every threshold is an unvalidated heuristic default. Treat it as something to observe, not a proven guarantee of impact. See [ROADMAP.md](<ROADMAP.md>) for scope and progress.
+> **0.5.5 is a preview release.** The plugin works, but how much real value the adjudication interventions add is still being explored — every threshold is an unvalidated heuristic default. Treat it as something to observe, not a proven guarantee of impact. See [ROADMAP.md](<ROADMAP.md>) for scope and progress.
 
 ## Installation
 
@@ -49,4 +49,4 @@ Restart `dsh web` and refresh after installing or updating: the host and client
 
 ## Safety boundary and development
 
-Automatic intervention only subtracts: the gate only denies, narrowing only removes tools, and neither grants new permissions. The gate defers to native DSH approval on backend failure rather than allowing; self-check, narrowing, and loop-guard errors skip intervention. The redacted summary sent to the backend carries only tool name and command/path with secret redaction — never file content. Node.js `>=20.11`; `npm test` and `npm run build:client` run local checks. Rebuild and commit `lib/client.js` with any client change. 0.5.4 is a preview: the interventions work, but their real value and thresholds are still being explored — feedback on misjudgments and feel observed in the decision log is welcome.
+Automatic intervention only subtracts: the gate only denies, narrowing only removes tools, and neither grants new permissions. The gate defers to native DSH approval on backend failure rather than allowing; self-check, narrowing, and loop-guard errors skip intervention. The redacted summary sent to the backend carries only tool name and command/path with secret redaction — never file content. Node.js `>=20.11`; `npm test` and `npm run build:client` run local checks. Rebuild and commit `lib/client.js` with any client change. 0.5.5 is a preview: the interventions work, but their real value and thresholds are still being explored — feedback on misjudgments and feel observed in the decision log is welcome.

package/README.md

@@ -4,7 +4,7 @@
 
 DeepSeek Harness（DSH）的结构化裁决插件。它把有明确判断标准的问题交给同协议的裁决后端，供 agent 在需要时使用，并在 agent loop 上接入危险门控、产出自检、工具收窄和防循环等自动介入。
 
-> **0.5.4 是体验版。** 插件功能已可用，但裁决介入能带来多少实际价值仍在探索中——各决策点的阈值都是未经验证的启发式默认值，建议先以观察心态体验，别当成经过验证的效果保证。功能与后续进度以 [ROADMAP.md](<ROADMAP.md>) 为准。
+> **0.5.5 是体验版。** 插件功能已可用，但裁决介入能带来多少实际价值仍在探索中——各决策点的阈值都是未经验证的启发式默认值，建议先以观察心态体验，别当成经过验证的效果保证。功能与后续进度以 [ROADMAP.md](<ROADMAP.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 关联、取最新。只读日志、只追加标注，不改任何决策行为。
@@ -53,4 +53,4 @@ dsh plugin --profile web add file:/绝对路径/dsh-decision-layer
 
 ## 开发
 
-服务端使用 Node.js `>=20.11`（`.mjs`，无需构建）；客户端用 TypeScript + esbuild 构建。`npm test` 跑本地测试，`npm run build:client` 生成 `lib/client.js`。改动客户端后需重建并连同 `lib/client.js` 一起提交，否则 GitHub 安装拿到的是旧 bundle。0.5.4 为体验版：介入能力已可用，但实际价值与阈值仍在探索，欢迎反馈决策日志观察到的误判与体感。
+服务端使用 Node.js `>=20.11`（`.mjs`，无需构建）；客户端用 TypeScript + esbuild 构建。`npm test` 跑本地测试，`npm run build:client` 生成 `lib/client.js`。改动客户端后需重建并连同 `lib/client.js` 一起提交，否则 GitHub 安装拿到的是旧 bundle。0.5.5 为体验版：介入能力已可用，但实际价值与阈值仍在探索，欢迎反馈决策日志观察到的误判与体感。

package/lib/client.js

@@ -1113,14 +1113,20 @@ function ConfigForm({ t, fetchFn = fetch }) {
     setNarrowOn(features?.narrow !== false);
     setCompleteOn(features?.complete !== false);
   };
-  const applyConfig = (value) => {
+  const applyBackend = (value) => {
     setConfig(value);
+  };
+  const applyAdvanced = (value) => {
     setCheckMode(value.checkSettings?.mode ?? "observe");
     setNarrowMode(value.narrowSettings?.mode ?? "enforce");
     setCompleteMode(value.completeSettings?.mode ?? "observe");
     setKeepPrefixes(prefixesText(value.narrowSettings));
     setMaxCandidates(String(maxCandidatesOf(value.narrowSettings)));
     setThreshold(String(thresholdOf(value.narrowSettings)));
+  };
+  const applyConfig = (value) => {
+    applyBackend(value);
+    applyAdvanced(value);
     applyFeatures(value.features);
   };
   (0, import_react4.useEffect)(() => {
@@ -1141,6 +1147,23 @@ function ConfigForm({ t, fetchFn = fetch }) {
       live = false;
     };
   }, [t, fetchFn]);
+  const toggleFeature = async (features, revert) => {
+    setBusy(true);
+    try {
+      const value = await request2("config", fetchFn, {
+        method: "PUT",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ features })
+      });
+      applyFeatures(value.features);
+    } catch {
+      revert();
+      setMessage({ text: t("error"), ok: false });
+    } finally {
+      setBusy(false);
+    }
+  };
+  const featureState = () => ({ gate: gateOn, check: checkOn, narrow: narrowOn, complete: completeOn });
   const saveAdvanced = async (event) => {
     event.preventDefault();
     const parsedCap = Number.parseInt(maxCandidates, 10);
@@ -1155,11 +1178,10 @@ function ConfigForm({ t, fetchFn = fetch }) {
         body: JSON.stringify({
           checkSettings: { mode: checkMode },
           narrowSettings: { mode: narrowMode, keepPrefixes: parsePrefixes(keepPrefixes), maxCandidates: cap, threshold: thresh },
-          completeSettings: { mode: completeMode },
-          features: { gate: gateOn, check: checkOn, narrow: narrowOn, complete: completeOn }
+          completeSettings: { mode: completeMode }
         })
       });
-      applyConfig(value);
+      applyAdvanced(value);
       setAdvancedDirty(false);
       setMessage({ text: t("saved"), ok: true });
     } catch {
@@ -1186,7 +1208,7 @@ ${url}`)) return;
           ...needsHttpConsent ? { confirmHttpUrl: url } : {}
         })
       });
-      applyConfig(value);
+      applyBackend(value);
       setKey("");
       setBackendDirty(false);
       setMessage({ text: t("saved"), ok: true });
@@ -1241,10 +1263,10 @@ ${url}`)) return;
           {
             label: t("featureGate"),
             checked: gateOn,
-            disabled: !ready,
+            disabled: !ready || busy,
             onChange: (next) => {
               setGateOn(next);
-              setAdvancedDirty(true);
+              void toggleFeature({ ...featureState(), gate: next }, () => setGateOn(!next));
             }
           }
         ),
@@ -1254,10 +1276,10 @@ ${url}`)) return;
           {
             label: t("featureCheck"),
             checked: checkOn,
-            disabled: !ready,
+            disabled: !ready || busy,
             onChange: (next) => {
               setCheckOn(next);
-              setAdvancedDirty(true);
+              void toggleFeature({ ...featureState(), check: next }, () => setCheckOn(!next));
             }
           }
         ),
@@ -1267,10 +1289,10 @@ ${url}`)) return;
           {
             label: t("featureNarrow"),
             checked: narrowOn,
-            disabled: !ready,
+            disabled: !ready || busy,
             onChange: (next) => {
               setNarrowOn(next);
-              setAdvancedDirty(true);
+              void toggleFeature({ ...featureState(), narrow: next }, () => setNarrowOn(!next));
             }
           }
         ),
@@ -1280,10 +1302,10 @@ ${url}`)) return;
           {
             label: t("featureComplete"),
             checked: completeOn,
-            disabled: !ready,
+            disabled: !ready || busy,
             onChange: (next) => {
               setCompleteOn(next);
-              setAdvancedDirty(true);
+              void toggleFeature({ ...featureState(), complete: next }, () => setCompleteOn(!next));
             }
           }
         ),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-decision-layer",
-  "version": "0.5.4",
+  "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;