dsh-decision-layer 0.6.4 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-decision-layer",
-  "version": "0.6.4",
+  "version": "0.7.0",
   "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",
@@ -35,7 +35,9 @@
   },
   "scripts": {
     "test": "node --test tests/*.test.mjs",
-    "build:client": "tsc -p tsconfig.client.json && node scripts/build-client.mjs"
+    "build:client": "tsc -p tsconfig.client.json && node scripts/build-client.mjs",
+    "check": "npm run build:client && npm test",
+    "pack:assert": "node scripts/assert-pack.mjs"
   },
   "exports": {
     ".": "./service/dsh.mjs",

package/service/config-store.mjs

@@ -29,6 +29,11 @@ function safeText(value) {
   return typeof value === 'string' ? value.trim() : '';
 }
 
+// A confidence/threshold/probability: any finite number in [0, 1].
+function probability(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
+}
+
 function checkedUrl(value) {
   if (!value) return '';
   let url;
@@ -53,9 +58,31 @@ function validRules(value) {
   return rules;
 }
 
+// Danger-gate settings. A gate verdict only intervenes on a high-confidence
+// `deny`, so minConfidence is the single knob that decides how sure the model
+// must be before a dangerous call is actually blocked. Lowering it makes the
+// gate block more (and risk blocking legitimate commands); raising it makes it
+// pass more through. Range 0–1; unset uses the built-in 0.6.
+//
+// Like every sibling validator, an unknown field or an out-of-range value is
+// REJECTED rather than ignored, which makes the whole resolve reject (see the
+// contract note on saveConfig). Callers that read config on a hot path must
+// therefore tolerate a throw and fall back to a safe default — see `featureOn`
+// in dsh.mjs and `resolveMinConfidence` in danger-gate.mjs.
+function validGate(value) {
+  if (!safeObject(value)) return undefined;
+  if (Object.keys(value).some(key => key !== 'minConfidence')) throw new Error('Invalid gate settings');
+  const gate = {};
+  if (value.minConfidence !== undefined) {
+    if (!probability(value.minConfidence)) throw new Error('Invalid gate settings');
+    gate.minConfidence = value.minConfidence;
+  }
+  return gate;
+}
+
 function validCheck(value) {
   if (!safeObject(value)) return undefined;
-  if (Object.keys(value).some(key => !['mode', 'rubric', 'lowScoreThreshold', 'trendMinConfidence', 'trendRun', 'trendSevereRun'].includes(key))) throw new Error('Invalid self-check settings');
+  if (Object.keys(value).some(key => !['mode', 'rubric', 'lowScoreThreshold', 'minConfidence', 'trendMinConfidence', 'trendRun', 'trendSevereRun'].includes(key))) throw new Error('Invalid self-check settings');
   const check = {};
   if (value.mode !== undefined) {
     if (value.mode !== 'observe' && value.mode !== 'steer') throw new Error('Invalid self-check settings');
@@ -71,11 +98,18 @@ function validCheck(value) {
     if (!Number.isSafeInteger(value.lowScoreThreshold) || value.lowScoreThreshold < 0 || value.lowScoreThreshold > 9) throw new Error('Invalid self-check settings');
     check.lowScoreThreshold = value.lowScoreThreshold;
   }
+  // Confidence required before a low score actually triggers the supplemental
+  // prompt. Below this the score is still logged; only interrupting the user
+  // warrants the model being sure. Range 0–1; unset uses the built-in 0.4.
+  if (value.minConfidence !== undefined) {
+    if (!probability(value.minConfidence)) throw new Error('Invalid self-check settings');
+    check.minConfidence = value.minConfidence;
+  }
   // Quality-trend alarm thresholds (all unvalidated heuristics, tuned on real logs):
   // a high-confidence low score requires confidence ≥ trendMinConfidence; a run of
   // trendRun such scores raises "warn", trendSevereRun raises "severe".
   if (value.trendMinConfidence !== undefined) {
-    if (typeof value.trendMinConfidence !== 'number' || !Number.isFinite(value.trendMinConfidence) || value.trendMinConfidence < 0 || value.trendMinConfidence > 1) throw new Error('Invalid self-check settings');
+    if (!probability(value.trendMinConfidence)) throw new Error('Invalid self-check settings');
     check.trendMinConfidence = value.trendMinConfidence;
   }
   if (value.trendRun !== undefined) {
@@ -104,7 +138,7 @@ function validNarrow(value) {
     narrow.mode = value.mode;
   }
   if (value.threshold !== undefined) {
-    if (typeof value.threshold !== 'number' || !Number.isFinite(value.threshold) || value.threshold < 0 || value.threshold > 1) throw new Error('Invalid narrowing settings');
+    if (!probability(value.threshold)) throw new Error('Invalid narrowing settings');
     narrow.threshold = value.threshold;
   }
   // Tool name prefixes that are always kept and never judged for relevance, on
@@ -144,10 +178,12 @@ export const FEATURE_KEYS = Object.freeze(['gate', 'check', 'narrow', 'complete'
 
 // Task-completion checking settings: observe-only by default; steer opts into a
 // single supplemental prompt on low completion. minConditions is the minimum
-// number of explicit conditions a turn must have for the check to run at all.
+// number of explicit conditions a turn must have for the check to run at all;
+// minConfidence is how sure the model must be that a condition is unmet before
+// it actually opens the supplemental step.
 function validComplete(value) {
   if (!safeObject(value)) return undefined;
-  if (Object.keys(value).some(key => !['mode', 'minConditions'].includes(key))) throw new Error('Invalid task-completion settings');
+  if (Object.keys(value).some(key => !['mode', 'minConditions', 'minConfidence'].includes(key))) throw new Error('Invalid task-completion settings');
   const complete = {};
   if (value.mode !== undefined) {
     if (value.mode !== 'observe' && value.mode !== 'steer') throw new Error('Invalid task-completion settings');
@@ -157,6 +193,11 @@ function validComplete(value) {
     if (!Number.isSafeInteger(value.minConditions) || value.minConditions < 2 || value.minConditions > 20) throw new Error('Invalid task-completion settings');
     complete.minConditions = value.minConditions;
   }
+  // Range 0–1; unset uses the built-in 0.4.
+  if (value.minConfidence !== undefined) {
+    if (!probability(value.minConfidence)) throw new Error('Invalid task-completion settings');
+    complete.minConfidence = value.minConfidence;
+  }
   return complete;
 }
 
@@ -186,6 +227,7 @@ function view(stored) {
     httpApprovedUrl: safeText(stored.httpApprovedUrl),
   };
   if (stored.dangerRules !== undefined) result.dangerRules = validRules(stored.dangerRules);
+  if (stored.gateSettings !== undefined) result.gateSettings = validGate(stored.gateSettings);
   if (stored.checkSettings !== undefined) result.checkSettings = validCheck(stored.checkSettings);
   if (stored.narrowSettings !== undefined) result.narrowSettings = validNarrow(stored.narrowSettings);
   if (stored.completeSettings !== undefined) result.completeSettings = validComplete(stored.completeSettings);
@@ -207,6 +249,7 @@ export async function resolveConfig({ path = configPath(), env = process.env } =
     httpApprovedUrl: safeText(stored.httpApprovedUrl),
   };
   if (stored.dangerRules !== undefined) resolved.dangerRules = validRules(stored.dangerRules);
+  if (stored.gateSettings !== undefined) resolved.gateSettings = validGate(stored.gateSettings);
   if (stored.checkSettings !== undefined) resolved.checkSettings = validCheck(stored.checkSettings);
   if (stored.narrowSettings !== undefined) resolved.narrowSettings = validNarrow(stored.narrowSettings);
   if (stored.completeSettings !== undefined) resolved.completeSettings = validComplete(stored.completeSettings);
@@ -214,8 +257,17 @@ export async function resolveConfig({ path = configPath(), env = process.env } =
   return resolved;
 }
 
+// Write the configuration atomically. Contract for the nested settings sections
+// (dangerRules, gateSettings, checkSettings, narrowSettings, completeSettings,
+// features): a POSTED section REPLACES the stored one wholesale; an OMITTED
+// section keeps its previous value. So a caller updating one field of a section
+// must send the whole section, and a caller that wants to change a field inside
+// a section it does not own must read first and send `{...previous, edit}`.
+// Merge-per-field was considered and rejected: it would make a stored field
+// impossible to unset. service/manager-api.mjs forwards the raw body, so this
+// contract holds for API clients too, not just the config page.
 export async function saveConfig(input, path = configPath()) {
-  if (!safeObject(input) || Object.keys(input).some(key => !['url', 'apiKey', 'model', 'confirmHttpUrl', 'dangerRules', 'checkSettings', 'narrowSettings', 'completeSettings', 'features'].includes(key))) {
+  if (!safeObject(input) || Object.keys(input).some(key => !['url', 'apiKey', 'model', 'confirmHttpUrl', 'dangerRules', 'gateSettings', 'checkSettings', 'narrowSettings', 'completeSettings', 'features'].includes(key))) {
     throw new Error('Invalid configuration fields');
   }
   for (const key of ['url', 'apiKey', 'model', 'confirmHttpUrl']) {
@@ -229,6 +281,7 @@ export async function saveConfig(input, path = configPath()) {
     throw new Error('Invalid model or API key');
   }
   const dangerRules = input.dangerRules === undefined ? previous.dangerRules : validRules(input.dangerRules);
+  const gateSettings = input.gateSettings === undefined ? previous.gateSettings : validGate(input.gateSettings);
   const checkSettings = input.checkSettings === undefined ? previous.checkSettings : validCheck(input.checkSettings);
   const narrowSettings = input.narrowSettings === undefined ? previous.narrowSettings : validNarrow(input.narrowSettings);
   const completeSettings = input.completeSettings === undefined ? previous.completeSettings : validComplete(input.completeSettings);
@@ -240,6 +293,7 @@ export async function saveConfig(input, path = configPath()) {
   }
   const next = { url, apiKey, model, httpApprovedUrl: url.startsWith('http://') ? url : '' };
   if (dangerRules !== undefined) next.dangerRules = dangerRules;
+  if (gateSettings !== undefined) next.gateSettings = gateSettings;
   if (checkSettings !== undefined) next.checkSettings = checkSettings;
   if (narrowSettings !== undefined) next.narrowSettings = narrowSettings;
   if (completeSettings !== undefined) next.completeSettings = completeSettings;

package/service/danger-gate.mjs

@@ -11,7 +11,9 @@ const PATH_KEYS = new Set(['path', 'file_path', 'filePath', 'target', 'file', 'f
 const MAX_RULES = 64;
 const MAX_PATTERN_LENGTH = 128;
 const MAX_METADATA_LENGTH = 2048;
-export const MIN_CONFIDENCE = 0.7;
+export const MIN_CONFIDENCE = 0.6;
+
+const isProbability = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
 
 export const DEFAULT_DANGEROUS_RULES = Object.freeze({
   toolNames: Object.freeze(['bash', 'pwsh', 'shell', 'exec', 'terminal', 'run_command', 'write', 'edit', 'str_replace_editor', 'file_write', 'write_file']),
@@ -82,6 +84,17 @@ export function createDangerGate({ evaluate, sessions, rules = DEFAULT_DANGEROUS
     if (typeof rules !== 'function') return rules;
     try { return (await rules()) ?? DEFAULT_DANGEROUS_RULES; } catch { return DEFAULT_DANGEROUS_RULES; }
   };
+  // The confidence floor may be a fixed number or a live resolver (config-backed),
+  // mirroring `rules`, so changing it takes effect without reloading the plugin.
+  // An invalid or failed resolution falls back to the built-in floor rather than
+  // to 0 — a broken config must never turn the gate into "block every deny".
+  const resolveMinConfidence = async () => {
+    if (typeof minConfidence !== 'function') return isProbability(minConfidence) ? minConfidence : MIN_CONFIDENCE;
+    try {
+      const value = await minConfidence();
+      return isProbability(value) ? value : MIN_CONFIDENCE;
+    } catch { return MIN_CONFIDENCE; }
+  };
   const deniedCalls = new WeakSet();
   const evaluatedCalls = new WeakSet();
   const record = (exec, outcome, detail = {}) => {
@@ -139,7 +152,8 @@ export function createDangerGate({ evaluate, sessions, rules = DEFAULT_DANGEROUS
       const answer = result?.answers?.verdict;
       const choice = answer?.choice;
       if (!['allow', 'ask', 'deny'].includes(choice)) return passThrough(exec, 'error', { reason: 'invalid-response' });
-      const confident = typeof answer.confidence === 'number' && Number.isFinite(answer.confidence) && answer.confidence >= minConfidence;
+      const minConfidenceNow = await resolveMinConfidence();
+      const confident = typeof answer.confidence === 'number' && Number.isFinite(answer.confidence) && answer.confidence >= minConfidenceNow;
       // Only a high-confidence deny blocks the call.
       if (choice === 'deny' && confident) {
         record(exec, 'deny', { suggestion: 'deny', action: 'deny' });

package/service/dsh.mjs

@@ -122,10 +122,23 @@ export async function apply(ctx, options = {}) {
     evaluate: (input, request) => backend.evaluate(input, request),
     sessions,
     rules: async () => normalizeDangerRules((await resolveConfig({ path })).dangerRules),
+    // Live config-backed floor (default 0.6): a `deny` only blocks once the model
+    // is at least this confident. Read per call so an edit takes effect at once.
+    minConfidence: async () => (await resolveConfig({ path })).gateSettings?.minConfidence,
   });
   const loopGuard = createLoopGuard({ sessions });
   // Live per-feature enablement; every decision point defaults to enabled.
-  const featureOn = async key => featureEnabled((await resolveConfig({ path })).features, key);
+  // An invalid config must not fail every tool call: these hooks run inside the
+  // host's tools/pre-execute waterfall, which converts a throw into a failed call
+  // (the tool never dispatches, so `read`/`edit` can no longer repair the file).
+  // An unreadable config therefore degrades to "all features on", and each
+  // decision point keeps its own safe fallback (the gate falls back to 0.6 and
+  // the built-in rules), so the safety net stays armed instead of the agent
+  // losing every tool.
+  const featureOn = async key => {
+    try { return featureEnabled((await resolveConfig({ path })).features, key); }
+    catch { return true; }
+  };
   if (typeof ctx.on === 'function') {
     if (typeof ctx.tools.guard === 'function') {
       // Deterministic loop guard runs with no backend; then the dangerous-gate

package/service/self-check.mjs

@@ -33,6 +33,8 @@ function boundedRubric(rubric) {
   return levels.length >= 2 ? levels : DEFAULT_RUBRIC;
 }
 
+const isProbability = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
+
 export function scoreQuestion(output, rubric = DEFAULT_RUBRIC) {
   return {
     state: { answer: String(output).slice(0, MAX_OUTPUT) },
@@ -44,10 +46,16 @@ export function scoreQuestion(output, rubric = DEFAULT_RUBRIC) {
   };
 }
 
+// The confidence floor for interrupting the user with a supplemental prompt.
+// Named rather than inlined because config-store's `checkSettings.minConfidence`
+// and the config form both document this value; a bare literal in three places
+// drifts silently on the next tuning pass.
+export const DEFAULT_MIN_CONFIDENCE = 0.4;
+
 // `settings` is an async resolver so rubric/mode/threshold follow live config.
 // `steer(agent, text)` performs the host-native steer; the caller owns building
 // the framework UserMessage so this module stays free of DSH message types.
-export function createSelfCheck({ evaluate, sessions, steer, settings, minConfidence = 0.4 } = {}) {
+export function createSelfCheck({ evaluate, sessions, steer, settings, minConfidence = DEFAULT_MIN_CONFIDENCE } = {}) {
   if (typeof evaluate !== 'function') throw new Error('Self-check requires an evaluator');
   const steerOnce = createSteerOnce();
   const resolveSettings = async () => {
@@ -55,11 +63,15 @@ export function createSelfCheck({ evaluate, sessions, steer, settings, minConfid
     try { raw = (typeof settings === 'function' ? await settings() : settings) ?? {}; } catch { raw = {}; }
     const mode = raw?.mode === 'steer' ? 'steer' : 'observe';
     const lowScoreThreshold = Number.isSafeInteger(raw?.lowScoreThreshold) && raw.lowScoreThreshold >= 0 ? raw.lowScoreThreshold : 1;
+    // Confidence required before a low score actually opens the supplemental
+    // prompt. The constructor argument is the fallback so a direct caller (and a
+    // config without the field) keeps its own floor.
+    const confidenceFloor = isProbability(raw?.minConfidence) ? raw.minConfidence : minConfidence;
     // Quality-trend thresholds (unvalidated heuristics; see quality-trend.mjs).
     const trendMinConfidence = typeof raw?.trendMinConfidence === 'number' && Number.isFinite(raw.trendMinConfidence) && raw.trendMinConfidence >= 0 && raw.trendMinConfidence <= 1 ? raw.trendMinConfidence : 0.6;
     const trendRun = Number.isSafeInteger(raw?.trendRun) && raw.trendRun >= 2 ? raw.trendRun : 3;
     const trendSevereRun = Number.isSafeInteger(raw?.trendSevereRun) && raw.trendSevereRun > trendRun ? raw.trendSevereRun : Math.max(trendRun + 1, 5);
-    return { mode, rubric: boundedRubric(raw?.rubric), lowScoreThreshold, trendMinConfidence, trendRun, trendSevereRun };
+    return { mode, rubric: boundedRubric(raw?.rubric), lowScoreThreshold, minConfidence: confidenceFloor, trendMinConfidence, trendRun, trendSevereRun };
   };
   const record = (turn, outcome, detail = {}, trend) => {
     const id = turn?.agent?.session?.id;
@@ -82,7 +94,7 @@ export function createSelfCheck({ evaluate, sessions, steer, settings, minConfid
       // can tell which turn's output each self-check score belongs to.
       const subject = subjectOf(turn?.userText);
       const subjectDetail = subject ? { subject } : {};
-      const { mode, rubric, lowScoreThreshold, trendMinConfidence, trendRun, trendSevereRun } = await resolveSettings();
+      const { mode, rubric, lowScoreThreshold, minConfidence: confidenceFloor, trendMinConfidence, trendRun, trendSevereRun } = await resolveSettings();
       let answer;
       try {
         const result = await evaluate(scoreQuestion(output, rubric), { signal: turn.signal });
@@ -107,7 +119,7 @@ export function createSelfCheck({ evaluate, sessions, steer, settings, minConfid
       if (lowScore && confidence !== undefined && !trend.confident) detail.lowConfidence = true;
       record(turn, lowScore ? 'low' : 'ok', { score: answer.score, ...detail }, trend);
       if (!lowScore) return { evaluated: true, lowScore: false, steered: false, score: answer.score };
-      const confident = confidence !== undefined && confidence >= minConfidence;
+      const confident = confidence !== undefined && confidence >= confidenceFloor;
       // The turn budget is consumed only on a successful steer (createSteerOnce),
       // so a transient host failure does not permanently suppress this turn.
       const steered = mode === 'steer' && confident && typeof steer === 'function' && turn?.agent

package/service/task-completion.mjs

@@ -74,11 +74,17 @@ export function completionQuestions(conditions, evidence, answer) {
   return { state, questions };
 }
 
+// The confidence floor for interrupting the user with a supplemental prompt.
+// Named rather than inlined because config-store's `completeSettings.minConfidence`
+// and the config form both document this value; a bare literal in three places
+// drifts silently on the next tuning pass.
+export const DEFAULT_MIN_CONFIDENCE = 0.4;
+
 // Orchestrates one task-completion pass at turn end. Read-only by default: it
 // records a per-condition verdict and only steers when explicitly configured,
 // the model is confident, and at least one condition is not satisfied. A steer
 // opens a supplemental step; it never rewrites the already-committed reply.
-export function createTaskCompletion({ evaluate, sessions, steer, settings, minConfidence = 0.4 } = {}) {
+export function createTaskCompletion({ evaluate, sessions, steer, settings, minConfidence = DEFAULT_MIN_CONFIDENCE } = {}) {
   if (typeof evaluate !== 'function') throw new Error('Task completion requires an evaluator');
   const steerOnce = createSteerOnce();
   const resolveSettings = async () => {
@@ -86,7 +92,11 @@ export function createTaskCompletion({ evaluate, sessions, steer, settings, minC
     try { raw = (typeof settings === 'function' ? await settings() : settings) ?? {}; } catch { raw = {}; }
     const mode = raw?.mode === 'steer' ? 'steer' : 'observe';
     const minConditions = Number.isSafeInteger(raw?.minConditions) && raw.minConditions >= 2 ? raw.minConditions : 2;
-    return { mode, minConditions };
+    // Confidence required before an unmet condition actually opens the
+    // supplemental step; the constructor argument is the fallback when the
+    // config does not set it.
+    const confidenceFloor = probability(raw?.minConfidence) ? raw.minConfidence : minConfidence;
+    return { mode, minConditions, minConfidence: confidenceFloor };
   };
   const record = (turn, outcome, detail = {}) => {
     const id = turn?.agent?.session?.id;
@@ -100,7 +110,7 @@ export function createTaskCompletion({ evaluate, sessions, steer, settings, minC
   return {
     async review(turn) {
       const output = typeof turn?.output === 'string' ? turn.output.trim() : '';
-      const { mode, minConditions } = await resolveSettings();
+      const { mode, minConditions, minConfidence: confidenceFloor } = await resolveSettings();
       const conditions = extractConditions(turn?.userText);
       if (conditions.length < minConditions) return { ...skip };
       const evidence = Array.isArray(turn?.evidence) ? turn.evidence : [];
@@ -139,7 +149,7 @@ export function createTaskCompletion({ evaluate, sessions, steer, settings, minC
       const outcome = unsatisfied > 0 ? 'unsatisfied' : 'ok';
       const detail = { conditions: conditions.length, satisfied, unsatisfied, insufficient };
       // A steer is only for a confident finding that a listed condition is not met.
-      const confident = unsatisfied > 0 && unsatisfiedMinConf >= minConfidence;
+      const confident = unsatisfied > 0 && unsatisfiedMinConf >= confidenceFloor;
       // The turn budget is consumed only on a successful steer (createSteerOnce),
       // so a transient host failure does not permanently suppress this turn.
       const steered = mode === 'steer' && confident && typeof steer === 'function' && turn?.agent