@master0071/dsh-systemone 0.4.0 → 0.4.2

package/cordis.patch.yml

@@ -1,7 +1,8 @@
 # @master0071/dsh-systemone bundle patch：把 SystemOne 决策插件插入任何将本包列入
 # `dsh.profile.bundles` 的 profile。插件依赖 harness 的 `tools`（注册 Agent
-# 工具）与 `logger`；无 Web 面。配置项全部有默认值，可在插件设置面板中覆盖。
+# 工具）与 `logger`；浏览器侧配置页由 client.js 提供。配置项全部有默认值，
+# 可在插件设置面板中覆盖。
 - insert:
     - id: systemone
       name: '@master0071/dsh-systemone'
-      config: {}
+      config: {}

package/lib/auto.js

@@ -36,6 +36,22 @@ import { readBoolean, readNumber, readString } from './volatile.js'
 /** 宿主运行时上下文使用的 source.kind（见 dsh-agent-loop 的 SOURCE 常量）。 */
 const RUNTIME_CONTEXT_SOURCE = 'runtime-context'
 
+/** 自动决策结果缓存的最大条目数；达到后先清过期再按插入序淘汰最旧。 */
+const MAX_AUTO_CACHE = 200
+
+/** 当前请求注入 state 的最大字符数（历史逐条限 2000，这里限制本轮原文）。 */
+const MAX_CURRENT_CHARS = 8000
+
+/** 自动决策数字配置的兜底默认值（与 lib/index.js Config schema 的 default 保持同一份来源）。 */
+export const AUTO_DEFAULTS = {
+  autoMaxMessages: 6,
+  autoTimeoutMs: 8000,
+  autoCacheTtlMs: 60000,
+  autoRouteMinConfidence: 0.35,
+  autoMinConfidence: 0.6,
+  autoMinChars: 4,
+}
+
 /**
  * 安装自动决策。返回卸载函数。
  *
@@ -56,9 +72,8 @@ export function installAutoDecide(ctx, deps) {
   const cache = new Map()
   /** stateHash → Promise：并发相同 state 只发一次上游请求。 */
   const inFlight = new Map()
-  // 每次都经 unwrap 读取，配置页里的改动无需重启即生效
-  const minChars = readNumber(config, 'autoMinChars', 0)
-  const routeFloor = readNumber(config, 'autoRouteMinConfidence', 0)
+  /** 已告警过的无效固定场景 id：同一错误只提示一次，避免每步刷日志。 */
+  const warnedScenarios = new Set()
 
   const log = (level, message) => {
     try {
@@ -79,40 +94,44 @@ export function installAutoDecide(ctx, deps) {
   }))
 
   // ── context 通道：入箱预计算 + 动态上下文渲染（不写历史，第二步起稳定可见） ──
-  if (readString(config, 'autoInject', 'message') === 'context') {
-    disposers.push(ctx.on('agent/created', (payload) => {
-      const agent = payload?.agent
-      const agentCtx = agent?.ctx
-      if (!agentCtx) return
-      // ① 消息一入箱就异步预计算，让决策尽可能在 assembly 之前就绪
-      if (typeof agentCtx.on === 'function') {
-        try {
-          disposers.push(agentCtx.on('agent/inbox/inserted', (event) => {
-            const newText = extractUserText([event?.message])
-            if (!newText) return
-            if (newText.trimStart().startsWith('/')) return
-            if (isTrivialInput(newText, minChars)) return
-            // 返回 promise 便于测试等待；宿主事件总线忽略返回值
-            return computeAndStore(agent, newText)
-          }))
-        } catch (error) {
-          log('warn', `注册入箱预计算失败：${messageOf(error)}`)
-        }
+  // 监听器无条件注册，autoInject 的门控放在事件回调里按当前配置判断：
+  // autoInject 是 volatile 字段，只有事件期判断才能让 message ↔ context
+  // 在运行期双向切换都立即生效（在装配期固化只支持一个方向）。
+  disposers.push(ctx.on('agent/created', (payload) => {
+    const agent = payload?.agent
+    const agentCtx = agent?.ctx
+    if (!agentCtx) return
+    // ① 消息一入箱就异步预计算，让决策尽可能在 assembly 之前就绪
+    if (typeof agentCtx.on === 'function') {
+      try {
+        disposers.push(agentCtx.on('agent/inbox/inserted', (event) => {
+          if (readString(config, 'autoInject', 'message') !== 'context') return
+          const newText = extractUserText([event?.message])
+          if (!newText) return
+          if (newText.trimStart().startsWith('/')) return
+          if (isTrivialInput(newText, readNumber(config, 'autoMinChars', AUTO_DEFAULTS.autoMinChars))) return
+          // 返回 promise 便于测试等待；宿主事件总线忽略返回值
+          return computeAndStore(agent, newText)
+        }))
+      } catch (error) {
+        log('warn', `注册入箱预计算失败：${messageOf(error)}`)
       }
-      // ② 把最新决策渲染进作用域动态上下文
-      if (agentCtx?.systemPrompt?.context) {
-        try {
-          disposers.push(agentCtx.systemPrompt.context({
-            name: 'systemone-auto-decision',
-            order: 900,
-            text: () => perAgent.get(agent?.id)?.text || '',
-          }))
-        } catch (error) {
-          log('warn', `注册动态上下文失败：${messageOf(error)}`)
-        }
+    }
+    // ② 把最新决策渲染进作用域动态上下文
+    if (agentCtx?.systemPrompt?.context) {
+      try {
+        disposers.push(agentCtx.systemPrompt.context({
+          name: 'systemone-auto-decision',
+          order: 900,
+          text: () => (readString(config, 'autoInject', 'message') === 'context')
+            ? (perAgent.get(agent?.id)?.text || '')
+            : '',
+        }))
+      } catch (error) {
+        log('warn', `注册动态上下文失败：${messageOf(error)}`)
       }
-    }))
-  }
+    }
+  }))
 
   // ── pre-step：同一步生效（仅 message 通道） ──
   disposers.push(ctx.on('agent/pre-step', async (payload, next) => {
@@ -132,13 +151,14 @@ export function installAutoDecide(ctx, deps) {
     const newText = extractUserText(claimed)
     if (!newText) return decision                       // 工具结果步骤 / 无新用户消息
     if (newText.trimStart().startsWith('/')) return decision  // 斜杠命令
-    if (isTrivialInput(newText, minChars)) return decision     // 寒暄/致谢等无业务含义的输入
+    if (isTrivialInput(newText, readNumber(config, 'autoMinChars', AUTO_DEFAULTS.autoMinChars))) return decision     // 寒暄/致谢等无业务含义的输入
 
     let injected = null
     try {
       // 双保险：既给上游传 abort signal，也用 race 兜底，
       // 即使提供商忽略 signal 也不会让这一步的推理被无限阻塞。
-      const timeout = combineSignal(payload?.signal, readNumber(config, 'autoTimeoutMs', 8000))
+      const timeoutMs = readNumber(config, 'autoTimeoutMs', AUTO_DEFAULTS.autoTimeoutMs)
+      const timeout = combineSignal(payload?.signal, timeoutMs)
       try {
         injected = await raceTimeout(
           computeDecision({
@@ -151,8 +171,9 @@ export function installAutoDecide(ctx, deps) {
             inFlight,
             signal: timeout.signal,
             log,
+            warnedScenarios,
           }),
-          readNumber(config, 'autoTimeoutMs', 8000),
+          timeoutMs,
         )
       } finally {
         timeout.dispose()
@@ -187,7 +208,8 @@ export function installAutoDecide(ctx, deps) {
   /** 入箱预计算：异步算好并存进 perAgent，供 context 通道渲染。 */
   async function computeAndStore(agent, newText) {
     try {
-      const timeout = combineSignal(undefined, readNumber(config, 'autoTimeoutMs', 8000))
+      const timeoutMs = readNumber(config, 'autoTimeoutMs', AUTO_DEFAULTS.autoTimeoutMs)
+      const timeout = combineSignal(undefined, timeoutMs)
       try {
         const injected = await raceTimeout(
           computeDecision({
@@ -200,8 +222,9 @@ export function installAutoDecide(ctx, deps) {
             inFlight,
             signal: timeout.signal,
             log,
+            warnedScenarios,
           }),
-          readNumber(config, 'autoTimeoutMs', 8000),
+          timeoutMs,
         )
         if (injected) perAgent.set(agent?.id ?? 'unknown', injected)
       } finally {
@@ -232,8 +255,8 @@ export function installAutoDecide(ctx, deps) {
 /**
  * 计算决策（带并发去重）。相同 state 只发一次上游请求。
  */
-async function computeDecision({ agent, newText, provider, config, scenarios, cache, inFlight, signal, log }) {
-  const state = captureState(agent, newText, readNumber(config, 'autoMaxMessages', 6))
+async function computeDecision({ agent, newText, provider, config, scenarios, cache, inFlight, signal, log, warnedScenarios }) {
+  const state = captureState(agent, newText, readNumber(config, 'autoMaxMessages', AUTO_DEFAULTS.autoMaxMessages))
   const key = hashString(state)
   const existing = inFlight.get(key)
   if (existing) return existing
@@ -248,6 +271,7 @@ async function computeDecision({ agent, newText, provider, config, scenarios, ca
     cache,
     signal,
     log,
+    warnedScenarios,
   }).finally(() => {
     if (inFlight.get(key) === promise) inFlight.delete(key)
   })
@@ -255,19 +279,19 @@ async function computeDecision({ agent, newText, provider, config, scenarios, ca
   return promise
 }
 
-async function decide({ agent, newText, state, key, provider, config, scenarios, cache, signal, log }) {
-  const ttl = readNumber(config, 'autoCacheTtlMs', 0) || 0
+async function decide({ agent, newText, state, key, provider, config, scenarios, cache, signal, log, warnedScenarios }) {
+  const ttl = readNumber(config, 'autoCacheTtlMs', AUTO_DEFAULTS.autoCacheTtlMs) || 0
   if (ttl > 0) {
     const hit = cache.get(key)
     if (hit && Date.now() - hit.at < ttl) return hit.result
   }
 
   // 1) 选场景：固定绑定，或让模型做一次自动路由
-  const routed = await resolveScenario({ state, provider, config, scenarios, signal })
+  const routed = await resolveScenario({ state, provider, config, scenarios, signal, log, warnedScenarios })
   if (!routed) return null
 
   // 路由置信度不足：宁可不注入，也不要塞一个瞎猜的结论
-  const floor = readNumber(config, 'autoRouteMinConfidence', 0)
+  const floor = readNumber(config, 'autoRouteMinConfidence', AUTO_DEFAULTS.autoRouteMinConfidence)
   if (Number.isFinite(floor) && floor > 0
     && Number.isFinite(routed.confidence) && routed.confidence < floor) {
     log?.('info', `路由置信度 ${(routed.confidence * 100).toFixed(1)}% 低于阈值 ${(floor * 100).toFixed(0)}%，跳过注入`)
@@ -282,7 +306,7 @@ async function decide({ agent, newText, state, key, provider, config, scenarios,
     scenario: routed.scenario.id,
     state,
     exec: { signal },
-    minConfidence: readNumber(config, 'autoMinConfidence', 0.6),
+    minConfidence: readNumber(config, 'autoMinConfidence', AUTO_DEFAULTS.autoMinConfidence),
   })
   if (!result?.ok) {
     log?.('warn', `场景 ${routed.scenario.id} 执行失败，已放行：${result?.error || '未知错误'}`)
@@ -297,16 +321,35 @@ async function decide({ agent, newText, state, key, provider, config, scenarios,
     headline: result.recommendation || routed.scenario.title,
     at: Date.now(),
   }
-  if (ttl > 0) cache.set(key, { at: Date.now(), result: injected })
+  if (ttl > 0) {
+    // 缓存上限：先清过期，再按插入序淘汰最旧，防止长会话无限增长
+    if (cache.size >= MAX_AUTO_CACHE) {
+      const now = Date.now()
+      for (const [k, v] of cache) {
+        if (now - v.at >= ttl) cache.delete(k)
+      }
+    }
+    while (cache.size >= MAX_AUTO_CACHE) {
+      cache.delete(cache.keys().next().value)
+    }
+    cache.set(key, { at: Date.now(), result: injected })
+  }
   return injected
 }
 
 /** 选择场景：固定绑定优先，否则用一次 choice 问句自动路由。 */
-async function resolveScenario({ state, provider, config, scenarios, signal }) {
+async function resolveScenario({ state, provider, config, scenarios, signal, log, warnedScenarios }) {
   const fixed = readString(config, 'autoScenario', '').trim()
   if (fixed) {
     const scenario = findScenario(scenarios, fixed)
-    if (!scenario) return null
+    if (!scenario) {
+      // 配置错误不能静默：同一 id 只告警一次，避免每步刷日志
+      if (!warnedScenarios.has(fixed)) {
+        warnedScenarios.add(fixed)
+        log?.('warn', `固定场景 "${fixed}" 不在场景库中，自动决策已停用（请检查 autoScenario 配置；可用：${scenarios.map((s) => s.id).join('、')}）`)
+      }
+      return null
+    }
     return { scenario, source: '固定绑定', confidence: null }
   }
   if (scenarios.length === 0) return null
@@ -365,8 +408,9 @@ function questionLabel(scenario, qid) {
 /**
  * 判断是否为"无业务含义"的输入，用于跳过自动决策。
  *
- * 只用长度阈值会误伤真实请求（"退款失败" 只有 4 个字），所以改成
- * 「长度阈值 + 寒暄黑名单」：短且整体就是寒暄才跳过。
+ * 两条独立的跳过规则（命中任一即跳过）：
+ *   1. 长度阈值：短于 autoMinChars 的一律跳过（默认 4，"退款失败" 恰好 4 字不被误伤）；
+ *   2. 寒暄黑名单：整体就是一句寒暄/致谢的跳过，与长度无关。
  */
 const TRIVIAL_PATTERN = /^(你好|您好|哈喽|在吗|hi|hello|hey|ok|okay|好的|好嘞|收到|明白|嗯+|谢谢|多谢|感谢|thanks|thank you|thx|再见|拜拜|bye|测试|test)[\s!！。.~～,，、?？]*$/i
 
@@ -387,7 +431,7 @@ function captureState(agent, newText, maxMessages) {
   const history = readHistory(agent, limit)
   const parts = []
   if (history.length > 0) parts.push(`【近期对话】\n${history.join('\n')}`)
-  parts.push(`【当前请求】\n${newText}`)
+  parts.push(`【当前请求】\n${truncate(newText, MAX_CURRENT_CHARS)}`)
   return parts.join('\n\n')
 }
 

package/lib/client.js

@@ -89,12 +89,14 @@ window.__ModuleLoader__.load({
       autoRouteMinConfidence: '自动路由置信度门槛',
       autoRouteMinConfidenceHint: '低于该值时宁可不注入，避免塞入瞎猜的结论',
       autoMinChars: '最小触发长度（字符）',
-      autoMinCharsHint: '低于该长度且整体是寒暄时跳过',
+      autoMinCharsHint: '低于该长度、或整体就是寒暄/致谢时跳过',
       save: '保存',
       saving: '保存中…',
       revert: '撤销修改',
       saved: '已保存，立即生效',
       saveFailed: '保存失败，请检查填写内容',
+      numberInvalid: '必须是有效数字',
+      numberRequired: '数字字段不能为空',
       conflict: '配置已被其他地方改动，已刷新为最新值，请重新修改',
       readOnly: '当前不可编辑',
       noForm: '宿主要求该条目声明 volatile 配置字段后才会显示表单。',
@@ -157,12 +159,14 @@ window.__ModuleLoader__.load({
       autoRouteMinConfidence: 'Auto routing confidence floor',
       autoRouteMinConfidenceHint: 'Below this value nothing is injected rather than guessing',
       autoMinChars: 'Minimum trigger length (chars)',
-      autoMinCharsHint: 'Shorter greetings are skipped',
+      autoMinCharsHint: 'Skipped when shorter than this, or when it is a bare greeting',
       save: 'Save',
       saving: 'Saving…',
       revert: 'Revert changes',
       saved: 'Saved — applied immediately',
       saveFailed: 'Save failed — check the values',
+      numberInvalid: 'Must be a valid number',
+      numberRequired: 'Number fields cannot be empty',
       conflict: 'The configuration changed elsewhere; the newest values were reloaded',
       readOnly: 'Read-only right now',
       noForm: 'The host exposes a form only when the entry declares volatile config fields.',
@@ -261,7 +265,6 @@ window.__ModuleLoader__.load({
 
     /* ────────────────────────────── 字段定义 ────────────────────────────── */
 
-    /** 数字字段在草稿里保持字符串，保存时再转数字，避免用户输入中途被强制转换。 */
     /**
      * 内置场景候选（供「固定场景」输入框的下拉提示）。
      *
@@ -349,7 +352,7 @@ window.__ModuleLoader__.load({
                 : null
               if (keys === null) issues.push(`问题 ${qid}（choice）需要 criteria 对象`)
               else if (keys.length < 2) issues.push(`问题 ${qid}（choice）至少 2 个选项`)
-              else if (keys.length > 26) issues.push(`问题 ${qid}（choice）选项建议 ≤26（当前 ${keys.length}）`)
+              else if (keys.length > 26) issues.push(`问题 ${qid}（choice）选项不能超过 26 个（当前 ${keys.length}）`)
             }
             if (q.type === 'score'
               && (!Array.isArray(q.criteria) || q.criteria.length < 2)) {
@@ -401,7 +404,7 @@ window.__ModuleLoader__.load({
     /**
      * 一个可折叠的配置卡片：标题 + 说明，展开后是字段表单。
      */
-    function ConfigCard({ t, title, description, open, onToggle, children }) {
+    function ConfigCard({ title, description, open, onToggle, children }) {
       return hs('li', {
         style: cardStyle,
         children: [
@@ -492,7 +495,7 @@ window.__ModuleLoader__.load({
         control = h('input', {
           id: controlId,
           style: inputStyle,
-          type: field.kind === 'password' ? 'password' : field.kind === 'number' ? 'text' : 'text',
+          type: field.kind === 'password' ? 'password' : 'text',
           inputMode: field.kind === 'number' ? 'decimal' : undefined,
           value,
           disabled,
@@ -579,8 +582,22 @@ window.__ModuleLoader__.load({
       const customCheck = validateCustomScenarios(values.customScenarios)
       const customErrorText = customCheck.ok ? undefined : describeCustomError(customCheck.error, t)
 
+      // 数字字段同样先校验：非法值直接拦住保存，
+      // 而不是保存时静默丢弃却仍提示「已保存」
+      const numberErrors = {}
+      for (const field of ALL_FIELDS) {
+        if (field.kind !== 'number') continue
+        const raw = String(values[field.key] ?? '').trim()
+        if (raw === '') numberErrors[field.key] = t('numberRequired')
+        else if (!Number.isFinite(Number(raw))) numberErrors[field.key] = t('numberInvalid')
+      }
+      const numberExtras = {}
+      for (const [key, error] of Object.entries(numberErrors)) {
+        numberExtras[key] = { error }
+      }
+
       const dirty = draft !== null && Object.keys(draft).some((key) => draft[key] !== current[key])
-      const canSave = dirty && !busy && writable && customCheck.ok
+      const canSave = dirty && !busy && writable && customCheck.ok && Object.keys(numberErrors).length === 0
 
       // 「固定场景」候选 = 10 个内置 + 当前生效的自定义场景 id
       const scenarioOptions = [
@@ -602,6 +619,7 @@ window.__ModuleLoader__.load({
         setBusy(true)
         setNotice(null)
         try {
+          // 数字字段在草稿里保持字符串，这里再转数字（合法性已由上方 numberErrors 拦截）
           const ops = []
           for (const [key, value] of Object.entries(draft ?? {})) {
             if (value === current[key]) continue
@@ -661,12 +679,23 @@ window.__ModuleLoader__.load({
         ],
       })
 
+      // 三张卡片共用同一套 footer：save（可选 revert / 额外状态）+ 状态行
+      const renderFooter = ({ showRevert, extra }) => hs('div', {
+        key: 'footer',
+        style: footerStyle,
+        children: [
+          h('button', { key: 'save', type: 'button', style: { ...primaryButton, opacity: canSave ? 1 : 0.5 }, disabled: !canSave, onClick: onSave, children: busy ? t('saving') : t('save') }),
+          ...(showRevert ? [h('button', { key: 'revert', type: 'button', style: ghostButton, disabled: !dirty || busy, onClick: () => { setDraft(null); setNotice(null) }, children: t('revert') })] : []),
+          ...(extra ? [extra] : []),
+          statusLine,
+        ],
+      })
+
       return hs('ul', {
         style: listStyle,
         children: [
           h(ConfigCard, {
             key: 'service',
-            t,
             title: t('tabService'),
             description: t('tabServiceHint'),
             open: openService,
@@ -674,39 +703,13 @@ window.__ModuleLoader__.load({
             // 注意：jsx(type, props, key) 的第三个参数是 key，正文必须作为 children 放进 props
             children: hs(Fragment, {
               children: [
-                ...renderFields(SERVICE_FIELDS),
-                hs('div', {
-                  key: 'footer',
-                  style: footerStyle,
-                  children: [
-                    h('button', {
-                      key: 'save',
-                      type: 'button',
-                      style: { ...primaryButton, opacity: canSave ? 1 : 0.5 },
-                      disabled: !canSave,
-                      onClick: onSave,
-                      children: busy ? t('saving') : t('save'),
-                    }),
-                    h('button', {
-                      key: 'revert',
-                      type: 'button',
-                      style: ghostButton,
-                      disabled: !dirty || busy,
-                      onClick: () => {
-                        setDraft(null)
-                        setNotice(null)
-                      },
-                      children: t('revert'),
-                    }),
-                    statusLine,
-                  ],
-                }),
+                ...renderFields(SERVICE_FIELDS, numberExtras),
+                renderFooter({ showRevert: true }),
               ],
             }),
           }),
           h(ConfigCard, {
             key: 'custom',
-            t,
             title: t('tabCustom'),
             description: t('tabCustomHint'),
             open: openCustom,
@@ -763,69 +766,31 @@ window.__ModuleLoader__.load({
                     }),
                   },
                 }),
-                hs('div', {
-                  key: 'footer',
-                  style: footerStyle,
-                  children: [
-                    h('button', {
-                      key: 'save',
-                      type: 'button',
-                      style: { ...primaryButton, opacity: canSave ? 1 : 0.5 },
-                      disabled: !canSave,
-                      onClick: onSave,
-                      children: busy ? t('saving') : t('save'),
-                    }),
-                    h('button', {
-                      key: 'revert',
-                      type: 'button',
-                      style: ghostButton,
-                      disabled: !dirty || busy,
-                      onClick: () => {
-                        setDraft(null)
-                        setNotice(null)
-                      },
-                      children: t('revert'),
-                    }),
-                    customCheck.ok
-                      ? h('span', {
-                        key: 'ok',
-                        style: statusStyle,
-                        children: customCheck.count === 0
-                          ? t('jsonEmpty')
-                          : `${t('jsonOk', { count: customCheck.count })} ${t('customIdsUsed')}`,
-                      })
-                      : null,
-                    statusLine,
-                  ],
+                renderFooter({
+                  showRevert: true,
+                  extra: customCheck.ok
+                    ? h('span', {
+                      key: 'ok',
+                      style: statusStyle,
+                      children: customCheck.count === 0
+                        ? t('jsonEmpty')
+                        : `${t('jsonOk', { count: customCheck.count })} ${t('customIdsUsed')}`,
+                    })
+                    : null,
                 }),
               ],
             }),
           }),
           h(ConfigCard, {
             key: 'auto',
-            t,
             title: t('tabAuto'),
             description: t('tabAutoHint'),
             open: openAuto,
             onToggle: () => setOpenAuto((value) => !value),
             children: hs(Fragment, {
               children: [
-                ...renderFields(AUTO_FIELDS),
-                hs('div', {
-                  key: 'footer',
-                  style: footerStyle,
-                  children: [
-                    h('button', {
-                      key: 'save',
-                      type: 'button',
-                      style: { ...primaryButton, opacity: canSave ? 1 : 0.5 },
-                      disabled: !canSave,
-                      onClick: onSave,
-                      children: busy ? t('saving') : t('save'),
-                    }),
-                    statusLine,
-                  ],
-                }),
+                ...renderFields(AUTO_FIELDS, numberExtras),
+                renderFooter({ showRevert: false }),
               ],
             }),
           }),
@@ -872,8 +837,3 @@ window.__ModuleLoader__.load({
     return module.exports
   },
 })
-
-
-
-
-

package/lib/format.js

@@ -11,6 +11,7 @@ export function formatSummary({
   latencyMs,
   lines = [],
   recommendation,
+  notes = [],
   needsHumanReview = false,
 }) {
   const out = [
@@ -18,10 +19,11 @@ export function formatSummary({
     `- **决策服务**：${provider} / ${model}`,
     ...lines,
   ]
+  for (const note of notes) out.push(`- **注意**：${note}`)
   if (recommendation) out.push(`- **建议**：${recommendation}`)
   out.push(`- **建议复核**：${needsHumanReview ? '需要人工复核' : '无需人工复核'}`)
   if (requestId) out.push(`- **请求 ID**：${requestId}（延迟 ${latencyMs}ms）`)
-  return out.filter(Boolean).join('\n')
+  return out.join('\n')
 }
 
 /**
@@ -53,7 +55,7 @@ export function normalizeAnswers(answers, questions = {}) {
       decision[qid] = Number.isFinite(score) ? idx : null
       const legend = raw.legend || {}
       const scale = Array.isArray(question?.criteria) ? question.criteria : []
-      labels[qid] = idx != null ? (legend[String(idx)] ?? scale[Number(raw.score ?? 0)] ?? String(idx)) : '无法判断'
+      labels[qid] = idx != null ? (legend[String(idx)] ?? scale[idx] ?? String(idx)) : '无法判断'
       if (Number.isFinite(Number(raw.confidence))) confidences[qid] = Number(raw.confidence)
       continue
     }
@@ -150,13 +152,21 @@ export function noulLine(label, answer) {
   return `- **${label}**：${v >= 0.5 ? '是' : '否'}（${(v * 100).toFixed(1)}%）`
 }
 
+/** noul 落在该区间视为「摇摆不定」（接近 0.5），建议人工复核。 */
+const NOUL_UNCERTAIN_LOW = 0.45
+const NOUL_UNCERTAIN_HIGH = 0.55
+
+/** choice 返回这些取值时视为「无法判断」。 */
+const UNCERTAIN_CHOICES = new Set(['uncertain', 'unknown'])
+
 /** 是否需要人工复核：置信度低于阈值，或出现不确定项。 */
 export function computeNeedsHumanReview(answers, minConfidence) {
   for (const a of Object.values(answers || {})) {
     if (!a || typeof a !== 'object') continue
     if (typeof a.confidence === 'number' && a.confidence < minConfidence) return true
-    if (a.type === 'choice' && (a.choice == null || a.choice === 'uncertain' || a.choice === 'unknown')) return true
-    if (a.type === 'noul' && typeof a.noul === 'number' && a.noul > 0.45 && a.noul < 0.55) return true
+    if (a.type === 'choice' && (a.choice == null || UNCERTAIN_CHOICES.has(a.choice))) return true
+    if (a.type === 'noul' && typeof a.noul === 'number'
+      && a.noul > NOUL_UNCERTAIN_LOW && a.noul < NOUL_UNCERTAIN_HIGH) return true
   }
   return false
 }

package/lib/index.js

@@ -2,7 +2,7 @@
  * @master0071/dsh-systemone 插件入口。
  *
  * 架构：Cordis 插件（Service 形态）。依赖 harness 的 `tools`（工具注册表）
- * 与 `logger`；无 Web 面。
+ * 与 `logger`；浏览器侧配置页由 client.js 提供（经 dsh.client 注入）。
  *
  * - 注册 2 个 Agent 工具：
  *     systemone_scenario — 统一场景调度（list / describe / run）
@@ -16,8 +16,11 @@ import z from '@deepseek-ai/schemastery'
 import { createProvider } from './provider.js'
 import { createTools } from './tools.js'
 import { resolveScenarios } from './scenarios.js'
-import { installAutoDecide } from './auto.js'
-import { readBoolean, readString } from './volatile.js'
+import { installAutoDecide, AUTO_DEFAULTS } from './auto.js'
+import { readBoolean, readString, unwrap } from './volatile.js'
+
+/** 合法的提供商类型；其他值会按 unisound 处理并告警一次。 */
+const KNOWN_PROVIDERS = ['unisound', 'http', 'mock']
 
 /**
  * 把「当前提供商」包成一个稳定引用的对象，内部每次调用都转发到最新实例。
@@ -79,17 +82,17 @@ const Config = z.object({
   /** 注入通道：message=本步生效（pre-step 注入）；context=官方动态上下文（晚一步生效） */
   autoInject: z.string().default('message').volatile(),
   /** 自动决策超时（毫秒），超时即放行，绝不阻塞会话 */
-  autoTimeoutMs: z.number().min(500).default(8000).volatile(),
+  autoTimeoutMs: z.number().min(500).default(AUTO_DEFAULTS.autoTimeoutMs).volatile(),
   /** 捕获的历史消息条数（不含本轮新消息） */
-  autoMaxMessages: z.number().min(1).max(50).default(6).volatile(),
+  autoMaxMessages: z.number().min(1).max(50).default(AUTO_DEFAULTS.autoMaxMessages).volatile(),
   /** 相同内容的结果缓存时长（毫秒），0 表示不缓存 */
-  autoCacheTtlMs: z.number().min(0).default(60000).volatile(),
+  autoCacheTtlMs: z.number().min(0).default(AUTO_DEFAULTS.autoCacheTtlMs).volatile(),
   /** 自动决策使用的置信度阈值 */
-  autoMinConfidence: z.number().min(0).max(1).default(0.6).volatile(),
+  autoMinConfidence: z.number().min(0).max(1).default(AUTO_DEFAULTS.autoMinConfidence).volatile(),
   /** 自动路由的置信度门槛：低于该值宁可不注入，避免塞入瞎猜的结论 */
-  autoRouteMinConfidence: z.number().min(0).max(1).default(0.35).volatile(),
+  autoRouteMinConfidence: z.number().min(0).max(1).default(AUTO_DEFAULTS.autoRouteMinConfidence).volatile(),
   /** 触发自动决策的最小输入长度（字符）；低于该长度且整体是寒暄才跳过 */
-  autoMinChars: z.number().min(0).default(4).volatile(),
+  autoMinChars: z.number().min(0).default(AUTO_DEFAULTS.autoMinChars).volatile(),
 })
 
 export default class SystemOneService extends Service {
@@ -105,7 +108,7 @@ export default class SystemOneService extends Service {
 
   /**
    * @param {import('@deepseek-ai/cordis').Context} ctx
-   * @param {import('zod').infer<typeof Config>} config
+   * @param {object} config - 经 Config schema 校验的插件配置（volatile 字段是引用对象，读取须经 volatile.js 脱壳）
    */
   constructor(ctx, config) {
     super(ctx, 'systemone')
@@ -114,13 +117,16 @@ export default class SystemOneService extends Service {
 
     // provider 字段是 volatile：配置页里切换 unisound / http / mock 时，
     // 下面这个代理会按需重建真正的提供商，工具与自动决策无需改动即可跟随。
-    this._provider = createProvider(ctx, config)
-    this._providerKind = readString(config, 'provider', 'unisound')
+    this._warnedProviders = new Set()
+    this._providerKind = null
+    this._provider = null
     this.provider = createProviderProxy(() => this.currentProvider())
+    this.currentProvider()
 
     // 场景库同样是热更新的：customScenarios 一变就原地重建，
     // 工具与自动决策持有的是同一个 liveScenarios 引用，因此无需重新装配。
     this._scenarioSource = null
+    this._scenarioRawValue = undefined
     this.scenarioProblems = []
     this._scenarioArray = []
     this._refreshScenarios()
@@ -164,12 +170,22 @@ export default class SystemOneService extends Service {
   currentProvider() {
     const kind = readString(this.config, 'provider', 'unisound')
     if (kind !== this._providerKind) {
-      this._provider = createProvider(this.ctx, this.config)
+      this._warnUnknownProvider(kind)
+      this._provider = createProvider(this.config)
       this._providerKind = kind
     }
     return this._provider
   }
 
+  /** 未知 provider 值会在 provider.js 里静默回退到 unisound，这里负责告警（每个未知值只提示一次）。 */
+  _warnUnknownProvider(kind) {
+    if (KNOWN_PROVIDERS.includes(kind) || this._warnedProviders.has(kind)) return
+    this._warnedProviders.add(kind)
+    this.ctx?.logger?.warn?.(
+      `@master0071/dsh-systemone: 未知 provider "${kind}"，将按 unisound 处理（可选：${KNOWN_PROVIDERS.join(' / ')}）`,
+    )
+  }
+
   /**
    * 场景库的「活引用」。
    *
@@ -208,7 +224,13 @@ export default class SystemOneService extends Service {
    * 因为工具与自动决策捕获的是那个数组本身。
    */
   _refreshScenarios() {
-    const source = readString(this.config, 'customScenarios', '').trim()
+    // 先做引用比较快速返回：Proxy 的每次属性访问都会走到这里，
+    // 字符串不可变，volatile 热更新换值时会换引用，引用相同即配置未变，
+    // 避免对大段自定义场景 JSON 反复做全量 String() + trim + 比较。
+    const value = unwrap(this.config?.customScenarios) ?? ''
+    if (value === this._scenarioRawValue) return
+    this._scenarioRawValue = value
+    const source = String(value).trim()
     if (source === this._scenarioSource) return
     const { scenarios, problems } = resolveScenarios(source)
     this._scenarioArray.length = 0

package/lib/provider.js

@@ -20,23 +20,21 @@ import { readNumber, readString } from './volatile.js'
 const DEFAULT_BASE_URL = 'https://maas-api.unisound.com/v1'
 const DEFAULT_MODEL = 'u2-decision'
 
-/** 创建提供商实例。config 来自插件配置（已由 Config schema 校验）。 */
-export function createProvider(ctx, config) {
+/** 创建提供商实例。config 来自插件配置（已由 Config schema 校验）。未知 provider 值回退到 unisound（入口层负责告警）。 */
+export function createProvider(config) {
   const kind = readString(config, 'provider', 'unisound')
   if (kind === 'mock') return new MockProvider(config)
-  if (kind === 'http') return new HttpProvider(ctx, config, 'http')
-  return new UnisoundProvider(ctx, config)
+  if (kind === 'http') return new HttpProvider(config, 'http')
+  return new UnisoundProvider(config)
 }
 
 /** 通用 HTTP 提供商：请求 SystemOne 兼容端点，Bearer 认证。 */
 export class HttpProvider {
   /**
-   * @param {object} ctx - Cordis 上下文
    * @param {object} config - 插件配置
    * @param {string} [name] - 提供商显示名
    */
-  constructor(ctx, config, name = 'http') {
-    this.ctx = ctx
+  constructor(config, name = 'http') {
     this.config = config || {}
     this.name = name
   }
@@ -83,6 +81,7 @@ export class HttpProvider {
 
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(new Error(`SystemOne: 请求超时（${timeoutMs}ms）`)), timeoutMs)
+    timer.unref?.()
     const onOuterAbort = () => controller.abort()
     if (signal && typeof signal.addEventListener === 'function') {
       signal.addEventListener('abort', onOuterAbort, { once: true })
@@ -128,8 +127,8 @@ export class HttpProvider {
 
 /** Unisound 官方提供商（默认）。 */
 export class UnisoundProvider extends HttpProvider {
-  constructor(ctx, config) {
-    super(ctx, { ...config, provider: 'unisound' }, 'unisound')
+  constructor(config) {
+    super({ ...config, provider: 'unisound' }, 'unisound')
   }
 }
 

package/lib/tools.js

@@ -79,7 +79,15 @@ function scenarioTool(provider, config, scenarios) {
       if (action === 'describe') {
         return describeScenario(scenarios, args.scenario)
       }
-      return runScenario({ provider, config, scenarios, args, exec })
+      return runScenarioDecision({
+        provider,
+        config,
+        scenarios,
+        scenario: args.scenario,
+        state: args.state,
+        params: args.params,
+        exec,
+      })
     },
     presentCall: (args) => ({
       card: 'generic',
@@ -156,18 +164,6 @@ function describeScenario(scenarios, id) {
   return { ok: true, action: 'describe', scenario: scenario.id, title: scenario.title, questions, summary }
 }
 
-async function runScenario({ provider, config, scenarios, args, exec }) {
-  return runScenarioDecision({
-    provider,
-    config,
-    scenarios,
-    scenario: args.scenario,
-    state: args.state,
-    params: args.params,
-    exec,
-  })
-}
-
 /**
  * 执行一次场景决策（工具与自动决策共用的核心入口）。
  *
@@ -179,7 +175,6 @@ async function runScenario({ provider, config, scenarios, args, exec }) {
  * @param {unknown} options.state - 业务上下文
  * @param {object} [options.params] - 按问题 id 覆盖问题定义
  * @param {object} [options.exec] - 工具执行上下文（取 signal）
- * @param {string} [options.model] - 覆盖模型
  * @param {number} [options.minConfidence] - 覆盖置信度阈值
  * @returns {Promise<object>} 与工具输出同构的决策结果
  */
@@ -191,7 +186,6 @@ export async function runScenarioDecision({
   state,
   params,
   exec,
-  model,
   minConfidence,
 }) {
   const scenario = findScenario(scenarios, scenarioRef)
@@ -212,7 +206,7 @@ export async function runScenarioDecision({
     }
   }
 
-  const questions = applyParams(scenario.questions, params)
+  const { questions, ignored } = applyParams(scenario.questions, params)
   const configThreshold = readNumber(config, 'minConfidence', NaN)
   const threshold = Number.isFinite(Number(minConfidence))
     ? Number(minConfidence)
@@ -231,7 +225,9 @@ export async function runScenarioDecision({
     config,
     minConfidence: threshold,
     exec,
-    model,
+    warnings: ignored.length > 0
+      ? [`以下 params 覆盖无效，已忽略：${ignored.join('；')}`]
+      : [],
     finalize(answers) {
       const { decision, labels, confidences } = normalizeAnswers(answers, questions)
       const derived = deriveFields(scenario.derive, decision)
@@ -243,10 +239,16 @@ export async function runScenarioDecision({
   })
 }
 
-/** 按 params 覆盖问题定义。 */
+/**
+ * 按 params 覆盖问题定义，并收集无法应用的覆盖项（类型不匹配、未知问题 id），
+ * 让调用方能把「传了但没生效」反馈给模型，而不是静默丢弃。
+ *
+ * @returns {{ questions: object, ignored: string[] }}
+ */
 function applyParams(questions, params) {
-  if (!params || typeof params !== 'object') return questions
+  if (!params || typeof params !== 'object') return { questions, ignored: [] }
   const merged = {}
+  const ignored = []
   for (const [qid, question] of Object.entries(questions)) {
     const override = params[qid]
     if (!override || typeof override !== 'object') {
@@ -268,14 +270,23 @@ function applyParams(questions, params) {
         )
       } else if (question.type === 'score' && Array.isArray(override.criteria) && override.criteria.length >= 2) {
         next.criteria = override.criteria.map((v) => String(v))
+      } else {
+        ignored.push(`${qid}.criteria（与问题类型 ${question.type} 不匹配）`)
       }
     }
-    if (override.addCriteria && question.type === 'choice' && !Array.isArray(override.addCriteria)) {
-      next.criteria = { ...(next.criteria || {}), ...override.addCriteria }
+    if (override.addCriteria) {
+      if (question.type === 'choice' && !Array.isArray(override.addCriteria)) {
+        next.criteria = { ...(next.criteria || {}), ...override.addCriteria }
+      } else {
+        ignored.push(`${qid}.addCriteria（仅支持 choice 问题）`)
+      }
     }
     merged[qid] = next
   }
-  return merged
+  for (const qid of Object.keys(params)) {
+    if (!(qid in questions)) ignored.push(`${qid}（未知问题 id）`)
+  }
+  return { questions: merged, ignored }
 }
 
 /* ─── 2. 通用决策工具 ─────────────────────────────────────────────────────── */
@@ -357,6 +368,7 @@ async function executeDecision({
   exec,
   model,
   finalize,
+  warnings = [],
 }) {
   try {
     const started = Date.now()
@@ -383,6 +395,7 @@ async function executeDecision({
       latencyMs,
       lines,
       recommendation,
+      notes: warnings,
       needsHumanReview,
     })
     return {
@@ -399,6 +412,7 @@ async function executeDecision({
       confidences,
       needs_human_review: needsHumanReview,
       recommendation,
+      warnings,
       summary,
     }
   } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@master0071/dsh-systemone",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "DeepSeek Harness 插件：将 SystemOne 决策模型（默认云知声 u2-decision，可切换提供商）接入软件开发、客服、内容审核、路由、销售线索、风控、招聘、数据治理、教育、需求变更等 10 大业务场景，为 Agent 返回带概率分布的决策与处置建议。",
   "license": "MIT",
   "type": "module",