dsh-decision-layer 0.4.0 → 0.5.1

package/service/session-state.mjs

@@ -1,3 +1,6 @@
+import { randomUUID } from 'node:crypto';
+import { advanceRun, severityOf } from './quality-trend.mjs';
+
 function sessionKey(value) {
   if (typeof value !== 'string' || !value.trim() || value.length > 512) throw new Error('Invalid session ID');
   return value.trim();
@@ -6,8 +9,9 @@ function sessionKey(value) {
 function emptyState() {
   return { enabled: true, attempts: 0, failures: 0,
     gate: { attempts: 0, failures: 0, ask: 0, deny: 0, allow: 0, actual: { allow: 0, deny: 0, error: 0 } },
-    check: { attempts: 0, failures: 0, low: 0 },
-    narrow: { attempts: 0, failures: 0, applied: 0, dropped: 0 }, log: [] };
+    check: { attempts: 0, failures: 0, low: 0, run: 0, severity: 'normal' },
+    narrow: { attempts: 0, failures: 0, applied: 0, dropped: 0 },
+    complete: { attempts: 0, failures: 0, unsatisfied: 0, satisfied: 0, insufficient: 0, steered: 0 }, log: [] };
 }
 
 function safeTool(value) {
@@ -19,11 +23,17 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
   if (!Number.isSafeInteger(maxLogEntries) || maxLogEntries < 1) throw new Error('Invalid log limit');
   const sessions = new Map();
   const sink = typeof onLog === 'function' ? onLog : undefined;
+  // FIFO eviction: when the map is full, drop the oldest-inserted session before
+  // admitting a new one (Map preserves insertion order, so the first key is the
+  // oldest). This mirrors loop-guard / narrowing and means the store never
+  // "fills up" — there is no capacity-exceeded state. An evicted session's
+  // in-memory counters/log are gone, but the persisted JSONL log is unaffected;
+  // a later call rebuilds an empty state for it.
   const writable = id => {
     const key = sessionKey(id);
     let state = sessions.get(key);
     if (!state) {
-      if (sessions.size >= maxSessions) throw new Error('Session state limit reached');
+      if (sessions.size >= maxSessions) sessions.delete(sessions.keys().next().value);
       state = emptyState();
       sessions.set(key, state);
     }
@@ -32,19 +42,16 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
   return {
     setEnabled(id, enabled) {
       if (typeof enabled !== 'boolean') throw new Error('Invalid enabled value');
-      const key = sessionKey(id);
-      if (!sessions.has(key) && sessions.size >= maxSessions && !enabled) return;
-      writable(key).enabled = enabled;
+      writable(id).enabled = enabled;
     },
     snapshot(id) {
       const stored = sessions.get(sessionKey(id));
-      const overflow = !stored && sessions.size >= maxSessions;
       const state = stored ?? emptyState();
-      const value = { enabled: overflow ? false : state.enabled, hasAutomaticDecisions: state.attempts > 0, attempts: state.attempts, failures: state.failures };
-      if (overflow) value.capacityExceeded = true;
+      const value = { enabled: state.enabled, hasAutomaticDecisions: state.attempts > 0, attempts: state.attempts, failures: state.failures };
       if (state.gate.attempts > 0) value.gate = { ...state.gate, actual: { ...state.gate.actual } };
-      if (state.check.attempts > 0) value.check = { ...state.check };
+      if (state.check.attempts > 0) value.check = { attempts: state.check.attempts, failures: state.check.failures, low: state.check.low, trend: { run: state.check.run, severity: state.check.severity } };
       if (state.narrow.attempts > 0) value.narrow = { ...state.narrow };
+      if (state.complete.attempts > 0) value.complete = { ...state.complete };
       if (state.log.length > 0) value.log = state.log.map(entry => ({ ...entry }));
       return value;
     },
@@ -60,13 +67,21 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
       if (!['allow', 'deny', 'error'].includes(outcome)) throw new Error('Invalid actual decision');
       writable(id).gate.actual[outcome]++;
     },
-    recordCheck(id, outcome) {
+    recordCheck(id, outcome, trend) {
       if (!['ok', 'low', 'error'].includes(outcome)) throw new Error('Invalid self-check outcome');
       const state = writable(id);
       state.attempts++;
       state.check.attempts++;
-      if (outcome === 'error') { state.failures++; state.check.failures++; }
-      else if (outcome === 'low') state.check.low++;
+      if (outcome === 'error') { state.failures++; state.check.failures++; return; }
+      if (outcome === 'low') state.check.low++;
+      // Advance the quality-trend run over this evaluated score. A good score
+      // resets the run; a high-confidence low score grows it; a low-confidence
+      // low score neither resets nor grows. `trend` carries the per-sample flags
+      // and the configured thresholds; absent trend leaves the run unchanged.
+      if (trend && typeof trend === 'object') {
+        state.check.run = advanceRun(state.check.run, { lowScore: outcome === 'low', confident: trend.confident === true });
+        state.check.severity = severityOf(state.check.run, { trendRun: trend.trendRun, trendSevereRun: trend.trendSevereRun });
+      }
     },
     recordNarrow(id, outcome, dropped = 0) {
       if (!['ok', 'applied', 'error'].includes(outcome)) throw new Error('Invalid narrowing outcome');
@@ -79,10 +94,27 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
         if (Number.isSafeInteger(dropped) && dropped > 0) state.narrow.dropped += dropped;
       }
     },
+    // Task-completion checking. `ok`/`unsatisfied` are real evaluations; `error`
+    // is an unevaluated failure counted as a failure, never as "unsatisfied".
+    // The per-condition three-state tallies come from `detail`.
+    recordComplete(id, outcome, detail = {}) {
+      if (!['ok', 'unsatisfied', 'error'].includes(outcome)) throw new Error('Invalid task-completion outcome');
+      const state = writable(id);
+      state.attempts++;
+      state.complete.attempts++;
+      if (outcome === 'error') { state.failures++; state.complete.failures++; return; }
+      if (Number.isSafeInteger(detail.satisfied) && detail.satisfied > 0) state.complete.satisfied += detail.satisfied;
+      if (Number.isSafeInteger(detail.unsatisfied) && detail.unsatisfied > 0) state.complete.unsatisfied += detail.unsatisfied;
+      if (Number.isSafeInteger(detail.insufficient) && detail.insufficient > 0) state.complete.insufficient += detail.insufficient;
+      if (detail.steered === true) state.complete.steered++;
+    },
     log(id, entry) {
       if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) throw new Error('Invalid log entry');
-      if (!['gate', 'check', 'narrow'].includes(entry.kind)) throw new Error('Invalid log entry');
-      const record = { at: Date.now(), kind: entry.kind, outcome: typeof entry.outcome === 'string' ? entry.outcome.slice(0, 32) : '' };
+      if (!['gate', 'check', 'narrow', 'complete'].includes(entry.kind)) throw new Error('Invalid log entry');
+      // Every decision record carries a stable unique id, generated here so the
+      // in-memory panel copy and the persisted sink record share the same id.
+      // Later annotation events reference this id to attribute a rating to one decision.
+      const record = { id: randomUUID(), at: Date.now(), kind: entry.kind, outcome: typeof entry.outcome === 'string' ? entry.outcome.slice(0, 32) : '' };
       const tool = safeTool(entry.tool);
       if (tool) record.tool = tool;
       if (typeof entry.suggestion === 'string' && entry.suggestion) record.suggestion = entry.suggestion.slice(0, 16);
@@ -94,6 +126,11 @@ export function createSessionState({ maxSessions = 1024, maxLogEntries = 50, onL
       if (Number.isSafeInteger(entry.dropped) && entry.dropped >= 0) record.dropped = entry.dropped;
       if (Number.isSafeInteger(entry.kept) && entry.kept >= 0) record.kept = entry.kept;
       if (Number.isSafeInteger(entry.candidates) && entry.candidates >= 0) record.candidates = entry.candidates;
+      if (Number.isSafeInteger(entry.conditions) && entry.conditions >= 0) record.conditions = entry.conditions;
+      if (Number.isSafeInteger(entry.satisfied) && entry.satisfied >= 0) record.satisfied = entry.satisfied;
+      if (Number.isSafeInteger(entry.unsatisfied) && entry.unsatisfied >= 0) record.unsatisfied = entry.unsatisfied;
+      if (Number.isSafeInteger(entry.insufficient) && entry.insufficient >= 0) record.insufficient = entry.insufficient;
+      if (entry.steered === true) record.steered = true;
       if (Array.isArray(entry.tools)) {
         const names = entry.tools.filter(name => typeof name === 'string' && name.trim()).slice(0, 12).map(name => name.trim().slice(0, 64));
         if (names.length > 0) record.tools = names;

package/service/task-completion.mjs

@@ -0,0 +1,155 @@
+const MAX_STATE = 8 * 1024;
+const MAX_CONDITION = 512;
+const MAX_CONDITIONS = 20;
+const MAX_EVIDENCE = 40;
+
+const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const probability = value => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
+
+const STEER_TEXT = '本回合任务完成核对发现有明确交付条件尚未满足：请对照用户列出的条件逐项复核，补完未完成的部分。';
+
+// Deterministic extraction of the explicit deliverable conditions a user listed.
+// Only structured forms are recognized — numbered lists, bullet lists, and a
+// single line of comma/、-separated multiple commands. Implicit or inferred
+// expectations are deliberately out of scope for the first version.
+export function extractConditions(userText) {
+  const text = typeof userText === 'string' ? userText : '';
+  if (!text.trim()) return [];
+  const conditions = [];
+  const push = value => {
+    const item = value.trim().replace(/\s+/g, ' ').slice(0, MAX_CONDITION);
+    if (item && !conditions.includes(item)) conditions.push(item);
+  };
+  const lines = text.split(/\r?\n/);
+  let matchedStructured = false;
+  for (const line of lines) {
+    // Numbered: `1. `, `1) `, `1、`, `（1）`, `(1)`; or bullets: `- `, `* `, `• `.
+    const numbered = line.match(/^\s*(?:[（(]?\d+[)）.、]|\d+\s*[.)、])\s+(.*)$/);
+    const bullet = line.match(/^\s*[-*•]\s+(.*)$/);
+    if (numbered && numbered[1].trim()) { push(numbered[1]); matchedStructured = true; }
+    else if (bullet && bullet[1].trim()) { push(bullet[1]); matchedStructured = true; }
+  }
+  // Fallback: a single instruction line joining multiple commands with 、/,/，
+  // and enough parts to look like an explicit multi-step ask (e.g. "改配置、跑测试、说明失败原因").
+  if (!matchedStructured) {
+    const compact = text.trim();
+    if (!/[\r\n]/.test(compact)) {
+      const parts = compact.split(/[、，,]/).map(part => part.trim()).filter(Boolean);
+      if (parts.length >= 2) for (const part of parts) push(part);
+    }
+  }
+  return conditions.slice(0, MAX_CONDITIONS);
+}
+
+// Build one choice question per explicit condition. The state carries the
+// conditions, the turn's tool evidence, and the final reply. Tool evidence is
+// primary; the reply's own claims are explicitly NOT treated as proof, so the
+// model can answer insufficient_evidence when only the reply asserts completion.
+export function completionQuestions(conditions, evidence, answer) {
+  const items = Array.isArray(conditions) ? conditions.slice(0, MAX_CONDITIONS) : [];
+  const tools = Array.isArray(evidence)
+    ? evidence.filter(item => isObject(item) && typeof item.tool === 'string').slice(0, MAX_EVIDENCE)
+      .map(item => ({ tool: item.tool.slice(0, 128), outcome: item.outcome === 'error' ? 'error' : 'ok' }))
+    : [];
+  const state = {
+    conditions: items.map((text, index) => ({ id: `c${index}`, text })),
+    toolEvidence: tools,
+    finalReply: String(answer ?? '').slice(0, MAX_STATE),
+    note: '工具证据（toolEvidence）是判定依据；finalReply 自称完成不作为证据。缺少证据时选 insufficient_evidence。',
+  };
+  const questions = Object.fromEntries(items.map((text, index) => [`c${index}`, {
+    type: 'choice',
+    instructions: {
+      condition: text,
+      question: '根据当前工具证据与最终回复，这个交付条件的完成情况属于哪一种？',
+    },
+    criteria: {
+      satisfied: '有工具证据或用户明确确认表明该条件已完成',
+      unsatisfied: '有证据表明该条件未完成或做错',
+      insufficient_evidence: '现有证据不足以判断该条件是否完成',
+    },
+  }]));
+  return { state, questions };
+}
+
+// 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 } = {}) {
+  if (typeof evaluate !== 'function') throw new Error('Task completion requires an evaluator');
+  const steeredTurns = new Set();
+  const steerKey = turn => {
+    const id = turn?.agent?.session?.id;
+    return typeof id === 'string' && Number.isInteger(turn?.turn) ? `${id}:${turn.turn}` : undefined;
+  };
+  const resolveSettings = async () => {
+    let raw = {};
+    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 };
+  };
+  const record = (turn, outcome, detail = {}) => {
+    const id = turn?.agent?.session?.id;
+    if (!sessions || typeof id !== 'string' || typeof sessions.recordComplete !== 'function') return;
+    try { sessions.recordComplete(id, outcome, detail); } catch { /* telemetry is best effort */ }
+    if (typeof sessions.log !== 'function') return;
+    try { sessions.log(id, { kind: 'complete', outcome, ...detail }); }
+    catch { /* logging is best effort */ }
+  };
+  const skip = { evaluated: false, steered: false };
+  return {
+    async review(turn) {
+      const output = typeof turn?.output === 'string' ? turn.output.trim() : '';
+      const { mode, minConditions } = await resolveSettings();
+      const conditions = extractConditions(turn?.userText);
+      if (conditions.length < minConditions) return { ...skip };
+      const evidence = Array.isArray(turn?.evidence) ? turn.evidence : [];
+      if (evidence.length === 0) return { ...skip };
+      const id = turn?.agent?.session?.id;
+      if (sessions && typeof id === 'string') {
+        try { if (sessions.snapshot(id).enabled === false) return { ...skip }; }
+        catch { return { ...skip }; }
+      }
+      let answers;
+      try {
+        const result = await evaluate(completionQuestions(conditions, evidence, output), { signal: turn.signal });
+        answers = isObject(result?.answers) ? result.answers : undefined;
+      } catch (error) {
+        record(turn, 'error', { reason: typeof error?.reason === 'string' ? error.reason : 'unreachable' });
+        return { ...skip };
+      }
+      if (!answers) { record(turn, 'error', { reason: 'invalid-response' }); return { ...skip }; }
+      let satisfied = 0, unsatisfied = 0, insufficient = 0;
+      let minConf = 1;
+      for (let index = 0; index < conditions.length; index++) {
+        const answer = answers[`c${index}`];
+        if (!isObject(answer) || answer.type !== 'choice' || typeof answer.choice !== 'string') {
+          insufficient++; continue;
+        }
+        if (probability(answer.confidence)) minConf = Math.min(minConf, answer.confidence);
+        if (answer.choice === 'satisfied') satisfied++;
+        else if (answer.choice === 'unsatisfied') unsatisfied++;
+        else insufficient++;
+      }
+      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 && minConf >= minConfidence;
+      let steered = false;
+      if (mode === 'steer' && confident && typeof steer === 'function' && turn?.agent) {
+        const key = steerKey(turn);
+        if (key !== undefined && !steeredTurns.has(key)) {
+          steeredTurns.add(key);
+          if (steeredTurns.size > 4096) steeredTurns.delete(steeredTurns.values().next().value);
+          try { steer(turn.agent, STEER_TEXT); steered = true; }
+          catch { steered = false; }
+        }
+      }
+      if (steered) detail.steered = true;
+      record(turn, outcome, detail);
+      return { evaluated: true, steered, satisfied, unsatisfied, insufficient };
+    },
+  };
+}