dsh-plugin-prompt-tool 1.0.0 → 2.0.1

package/engine/rule-engine.mjs

@@ -0,0 +1,40 @@
+/** 独立装配入口只读取统一 rules 产物包；插件管理路径直接调用同一编译/装配接口。 */
+import { readFileSync } from 'node:fs'
+import { basename, dirname, isAbsolute } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { parse } from './vendor/yaml/index.js'
+import { defineConfig, passthrough } from './fields.mjs'
+import { compileRules, getRuleEditorMeta } from './rule-spec.mjs'
+import { mountRuleSources } from './rule-runtime.mjs'
+import { loadStandingMountFor } from './predicates.mjs'
+
+export const name = 'rule-engine'
+export const inject = ['systemPrompt', 'tools', 'llm']
+export { compileRules, mountRuleSources, getRuleEditorMeta }
+const fields = defineConfig({
+  rulesFile: passthrough(value => typeof value === 'string' && value.length ? value : '../rules.yml'),
+  moduleRoot: passthrough(value => typeof value === 'string' && value.length ? value : undefined),
+  presetRoot: passthrough(value => typeof value === 'string' && value.length ? value : undefined),
+  strategyDir: passthrough(value => typeof value === 'string' && value.length ? value : undefined),
+})
+export const configContract = { ...fields, parse(config, plugin = name) {
+  const source = fields.parse(config, plugin)
+  if (source.moduleRoot !== undefined && source.presetRoot !== undefined && source.moduleRoot !== source.presetRoot) throw new TypeError(`${plugin}: moduleRoot and presetRoot conflict`)
+  source.moduleRoot ??= source.presetRoot
+  delete source.presetRoot
+  return source
+} }
+
+export async function apply(ctx, config) {
+  const source = configContract.parse(config, name)
+  const file = isAbsolute(source.rulesFile) ? source.rulesFile : fileURLToPath(new URL(source.rulesFile, import.meta.url))
+  const packet = parse(readFileSync(file, 'utf8'), { logLevel: 'silent' })
+  if (packet === null || typeof packet !== 'object' || Array.isArray(packet) || !Array.isArray(packet.rules)) throw new TypeError('rule-engine: rules.yml must contain a rules package')
+  const templateBaseUrl = pathToFileURL(file)
+  const templateModuleRoot = source.moduleRoot === undefined ? new URL('./', templateBaseUrl)
+    : isAbsolute(source.moduleRoot) ? pathToFileURL(source.moduleRoot.replace(/[\\/]?$/, '/')) : new URL(source.moduleRoot.replace(/\/?$/, '/'), templateBaseUrl)
+  const strategyDir = source.strategyDir === undefined ? undefined : isAbsolute(source.strategyDir) ? pathToFileURL(source.strategyDir).href : new URL(source.strategyDir, templateBaseUrl).href
+  const moduleId = typeof packet.moduleId === 'string' ? packet.moduleId : basename(dirname(file))
+  const rules = compileRules(packet.rules, { moduleId, variables: packet.variables, variablesEnabled: packet.variablesEnabled, configOrder: packet.configOrder, ctx, standingMountFor: await loadStandingMountFor(), promptConfigOptions: { templateBaseUrl, templateModuleRoot, strategyDir } })
+  return mountRuleSources(ctx, [{ moduleId, rules }])
+}

package/engine/rule-runtime.mjs

@@ -0,0 +1,110 @@
+import { prepareAction } from './actions/index.mjs'
+import { applyPromptConfigSources } from './executor.mjs'
+import { wireLayers } from './layers.mjs'
+import { wireTriggerObservers } from './trigger.mjs'
+import { ruleFrame, actionMatches } from './conditions/evaluation.mjs'
+import { createWarnOnce } from './shared.mjs'
+
+const noNext = new Set(['agent/inbox/inserted', 'agent/turn-stopping', 'subagent/start', 'subagent/end'])
+const compare = (a, b) => a.action.channelOrder - b.action.channelOrder
+  || a.moduleId.localeCompare(b.moduleId) || a.ruleIndex - b.ruleIndex || a.action.actionIndex - b.action.actionIndex
+
+/** 所有来源只进入这个装配入口；注入保留原有批处理和协调器所有权。 */
+export function mountRuleSources(ctx, sources, options = {}) {
+  const warnOnce = options.warnOnce ?? createWarnOnce(ctx, options.plugin ?? 'rule-engine')
+  const releases = []
+  const points = new Map()
+  const injections = new Map(sources.map(source => [source.moduleId, { sourceId: `module:${source.moduleId}`, configs: [], ruleActions: [], officialInstructions: source.officialInstructions === true }]))
+  const rules = sources.flatMap(source => source.rules.filter(rule => rule.enabled !== false))
+  const observer = wireTriggerObservers(ctx, rules, { plugin: options.plugin ?? 'rule-engine', warnOnce })
+  if (observer) releases.push(observer)
+  let active = true
+  const bind = (item, on) => prepareAction(item.action, { plugin: options.plugin, warnOnce, promptConfigOptions: item.rule.promptConfigOptions, on })(ctx)
+  try {
+    for (const source of sources) for (const [ruleIndex, rule] of source.rules.entries()) {
+      if (rule.enabled === false) continue
+      for (const action of rule.actions) {
+        const item = { moduleId: source.moduleId, ruleIndex, rule, action }
+        if (action.execution.lifecycle === 'registration' && action.kind === 'guard') { releases.push(bind(item)); continue }
+        const point = action.execution
+        const key = `${point.channel}:${point.phase}:${action.waterfallPosition}`
+        const bucket = points.get(key) ?? { ...point, waterfallPosition: action.waterfallPosition, items: [] }
+        bucket.items.push(item); points.set(key, bucket)
+      }
+    }
+    for (const point of points.values()) {
+      point.items.sort(compare)
+      const handlers = []
+      let textConfigs = []
+      const flushLayers = () => {
+        if (!textConfigs.length) return
+        releases.push(wireLayers(ctx, textConfigs, warnOnce, {
+          on: (channel, handler) => {
+            if (channel !== point.channel) throw new TypeError(`rule action registered outside ${point.channel}: ${channel}`)
+            handlers.push({ handler }); return () => {}
+          },
+        }))
+        textConfigs = []
+      }
+      for (const item of point.items) {
+        const { action, rule, moduleId } = item
+        if (action.kind === 'inject-text') {
+          const config = { ...action.compiledConfig, rule, sourceModuleId: moduleId, group: undefined, exclusive: false, enabled: true, actionWhen: action.actionWhen, bypassRuleWhen: action.bypassRuleWhen }
+          if (config.layer === 'pre-step') injections.get(moduleId).configs.push(config)
+          else textConfigs.push(config)
+          continue
+        }
+        flushLayers()
+        const on = (channel, handler) => {
+          if (channel !== point.channel) throw new TypeError(`rule action registered outside ${point.channel}: ${channel}`)
+          const entry = { rule, handler, sequence: action.channelOrder, sourceModuleId: moduleId, ruleId: rule.id, ruleActionIndex: action.actionIndex, id: action.id, actionWhen: action.actionWhen, bypassRuleWhen: action.bypassRuleWhen }
+          if (channel === 'agent/pre-step' && point.waterfallPosition === 'default') injections.get(moduleId).ruleActions.push(entry)
+          else handlers.push(entry)
+          return () => {}
+        }
+        releases.push(bind(item, on))
+      }
+      flushLayers()
+      if (!handlers.length) continue
+      releases.push(ctx.on(point.channel, (...args) => {
+        const free = noNext.has(point.channel)
+        const payload = free ? args : args.slice(0, -1)
+        const next = free ? () => undefined : args[args.length - 1]
+        if (!active) return next()
+        const frame = ruleFrame(point.channel, payload, warnOnce, ctx)
+        if (free) {
+          let pending
+          for (const entry of handlers) {
+            const invoke = () => active && actionMatches(entry, frame) ? entry.handler(...payload, undefined, frame) : undefined
+            pending = pending?.then ? pending.then(invoke) : invoke()
+          }
+          return pending
+        }
+        if (point.phase === 'after-next') return Promise.resolve(next()).then(async initial => {
+          let result = initial
+          for (const entry of handlers) {
+            if (!active || !actionMatches(entry, frame)) continue
+            result = await entry.handler(...payload, () => result, frame)
+          }
+          return result
+        })
+        const invoke = index => {
+          if (!active || index === handlers.length) return next()
+          const entry = handlers[index]
+          return actionMatches(entry, frame) ? entry.handler(...payload, () => invoke(index + 1), frame) : invoke(index + 1)
+        }
+        return invoke(0)
+      }, point.waterfallPosition === 'outermost' ? { prepend: true } : undefined))
+    }
+    const preStep = [...injections.values()].filter(source => source.configs.length || source.ruleActions.length)
+    if (preStep.length) releases.push(applyPromptConfigSources(ctx, preStep, { layers: false }))
+  } catch (error) {
+    active = false
+    for (const dispose of releases.reverse()) { try { dispose?.() } catch {} }
+    throw error
+  }
+  return () => {
+    active = false
+    for (const dispose of releases.splice(0).reverse()) { try { dispose?.() } catch {} }
+  }
+}

package/engine/rule-spec.mjs

@@ -0,0 +1,187 @@
+/** module.yml.rules 的唯一运行时编译入口。旧声明仅由离线迁移器读取。 */
+import { ACTION_KINDS, actionExecutionPoint, prepareAction, validateActionOptions } from './actions/index.mjs'
+import { compileWhen, PREDICATE_FACTORIES, COMPOSITE_OPERATORS } from './conditions/index.mjs'
+import { createPromptConfigs, KNOWN_LAYERS } from './schema.mjs'
+import { WATERFALL_POSITIONS } from './trigger.mjs'
+import { ACTION_EXAMPLES } from './actions/examples.mjs'
+import { PREDICATE_EXAMPLES } from './conditions/examples.mjs'
+import { conjunction, expandActions } from './branch.mjs'
+
+/** 规则字段：`if`/`then`/`else` 是当前名，`when`/`do` 保留为兼容输入（见 pickAlias）。 */
+const RULE_FIELDS = new Set(['id', 'name', 'enabled', 'layer', 'group', 'exclusive', 'if', 'then', 'else', 'when', 'do'])
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+const nonempty = value => typeof value === 'string' && value.trim().length > 0
+
+/** 规则及物化身份的唯一安全边界；host 保存、导入与直接编译共用。 */
+export function assertRuleId(id) {
+  if (!nonempty(id)) throw new TypeError('rule id must be a non-empty string')
+  if (id === '.' || id === '..') throw new TypeError(`rule id ${JSON.stringify(id)} must not be a dot directory`)
+  const reserved = '/\\\0:*?"<>|'
+  for (const char of reserved) if (id.includes(char)) throw new TypeError(`rule id ${JSON.stringify(id)} contains path separators or reserved filename characters`)
+  for (let index = 0; index < id.length; index++) if (id.charCodeAt(index) < 0x20) throw new TypeError(`rule id ${JSON.stringify(id)} contains control characters`)
+}
+
+/** 注入叶子的唯一身份投影；稳定动作 id 保证重排不改变投递身份。 */
+export function injectionConfigSpec(rule, action, options = {}) {
+  if (action?.kind !== 'inject-text' || !record(action.config)) throw new TypeError('inject-text config must be an object')
+  const config = { ...action.config, id: action.config.id ?? `rule:${encodeURIComponent(rule.id)}:${encodeURIComponent(action.id)}`, layer: action.config.layer ?? rule.layer ?? 'pre-step' }
+  const variables = record(options.variables) ? options.variables : {}
+  if (options.variablesEnabled === false) {
+    const keys = new Set(Object.keys(variables))
+    const strip = text => typeof text === 'string' ? text.replace(/\{\{([A-Za-z0-9_.\u4e00-\u9fff-]+)\}\}/g, (match, key) => keys.has(key) ? '' : match) : text
+    if (config.text !== undefined) config.text = strip(config.text)
+    if (Array.isArray(config.texts)) config.texts = config.texts.map(strip)
+    if (record(config.params) && typeof config.params.text === 'string') config.params = { ...config.params, text: strip(config.params.text) }
+  } else config.variables = { ...variables, ...(record(config.variables) ? config.variables : {}) }
+  return config
+}
+
+/** 非空同组任一成员声明互斥，整组最多允许一条 enabled；运行时不替作者选赢家。 */
+export function validateRuleGroups(rules) {
+  const groups = new Map()
+  for (const rule of rules) {
+    if (!nonempty(rule.group)) continue
+    const group = groups.get(rule.group) ?? []; group.push(rule); groups.set(rule.group, group)
+  }
+  for (const [name, group] of groups) {
+    if (group.some(rule => rule.exclusive === true) && group.filter(rule => rule.enabled !== false).length > 1) {
+      throw new TypeError(`rules: exclusive group ${JSON.stringify(name)} has multiple enabled rules`)
+    }
+  }
+}
+
+export function ruleActionExecution(action) {
+  const fixed = action.kind === 'guard' || (action.kind === 'inject-text'
+    && (action.config?.params?.complete === true || action.config?.params?.suppressRuntimeContext === true))
+  return { ...actionExecutionPoint(action), lifecycle: fixed ? 'registration' : 'event' }
+}
+
+/** 通用门只属于 when；固定系统段的 audience 保留为注册目标。 */
+function normalizeActionGates(action, execution) {
+  const inject = action.kind === 'inject-text'
+  if (!inject && action.kind !== 'request-params') return
+  const target = inject ? action.config : action
+  if (inject) {
+    if (target.enabled !== undefined && target.enabled !== true) throw new TypeError(`action ${action.id}: move config.enabled to rule.enabled`)
+    delete target.enabled
+  }
+  const fields = inject ? ['audience', 'modelScope', 'promotion', 'subject', 'match'] : ['audience', 'modelScope']
+  for (const field of fields) {
+    const value = target[field]
+    if (inject && field === 'audience' && target.layer === 'system-section' && execution.lifecycle === 'registration' && ['main', 'subagent'].includes(value)) continue
+    const neutral = value == null || value === '' || (field === 'modelScope' && value === 'all') || (field === 'promotion' && value === 'none')
+    if (!neutral) throw new TypeError(`action ${action.id}: ${inject ? 'config.' : ''}${field} is a legacy gate; move it to rule.if`)
+    delete target[field]
+  }
+}
+
+/** 注册制层：内容在 agent 装配时注册一次，没有逐轮求值时机，因此不接受分支条件。 */
+const REGISTRATION_LAYERS = new Set(['system-section', 'runtime-context'])
+
+/** options.promptConfigOptions 拥有模板/策略路径；configOrder 使用规则 id，moduleId 只标记来源。 */
+export function compileRules(specs, options = {}) {
+  if (!Array.isArray(specs)) throw new TypeError('rules must be an array')
+  const ids = new Set()
+  const pendingConfigs = []
+  const moduleId = options.moduleId ?? options.sourceModuleId
+  const rules = specs.map((spec, index) => {
+    if (!record(spec)) throw new TypeError(`rules[${index}] must be an object`)
+    const unknown = Object.keys(spec).filter(key => !RULE_FIELDS.has(key))
+    if (unknown.length) throw new TypeError(`rules[${index}] unknown fields: ${unknown.join(', ')}`)
+    assertRuleId(spec.id)
+    if (ids.has(spec.id)) throw new TypeError(`rules: duplicate id ${spec.id}`)
+    ids.add(spec.id)
+    for (const key of ['enabled', 'exclusive']) if (spec[key] !== undefined && typeof spec[key] !== 'boolean') throw new TypeError(`rule ${spec.id}.${key} must be boolean`)
+    for (const key of ['name', 'group']) if (spec[key] !== undefined && typeof spec[key] !== 'string') throw new TypeError(`rule ${spec.id}.${key} must be string`)
+    if (spec.layer !== undefined && !KNOWN_LAYERS.has(spec.layer)) throw new TypeError(`rule ${spec.id}: unknown layer ${spec.layer}`)
+    // 旧名已按引擎重构退役：显式拒绝并给出新名，比 "unknown fields" 更可直接照做。
+    if (spec.when !== undefined) throw new TypeError(`rule ${spec.id}: "when" 已退役，改用 "if"`)
+    if (spec.do !== undefined) throw new TypeError(`rule ${spec.id}: "do" 已退役，改用 "then"`)
+    const ruleIf = spec.if
+    const ruleThen = spec.then
+    if (!Array.isArray(ruleThen) || ruleThen.length === 0) throw new TypeError(`rule ${spec.id}.then must be a non-empty array`)
+    const sequence = options.configOrder?.[spec.id] ?? index * 10
+    if (!Number.isSafeInteger(sequence) || sequence < 0) throw new TypeError(`rule ${spec.id}: invalid configOrder`)
+    const when = compileWhen(ruleIf, options)
+    // 规则级 `if` 由 `rule.when` 判定，then 分支的动作不再重复叠加它；规则级 `else` 的动作
+    // 自带 `not(if)` 并标记跳过规则级判定——否则两者自相矛盾，else 分支永远不会执行。
+    const expanded = [
+      ...expandActions(ruleThen, {}, `rule ${spec.id}.then`),
+      ...(spec.else === undefined ? [] : expandActions(spec.else, {
+        outer: ruleIf === undefined ? [] : [{ not: ruleIf }],
+        bypass: true,
+      }, `rule ${spec.id}.else`)),
+    ]
+    const actionIds = new Set()
+    const actions = expanded.map(({ node: source, conditions, bypass }, actionIndex) => {
+      if (!record(source) || !nonempty(source.id)) throw new TypeError(`rule ${spec.id}: action id must be non-empty`)
+      if (actionIds.has(source.id)) throw new TypeError(`rule ${spec.id}: duplicate action id ${source.id}`)
+      actionIds.add(source.id)
+      if (!Object.hasOwn(ACTION_KINDS, source.kind)) throw new TypeError(`rule ${spec.id}: unknown action ${source.kind}`)
+      const action = structuredClone(source)
+      if (action.kind === 'inject-text') {
+        action.config = injectionConfigSpec(spec, action, options)
+        if (action.config.strategy === 'custom-fallback') throw new TypeError(`action ${action.id}: migrate custom-fallback to an anchor condition and anchor-notice content`)
+      }
+      const execution = ruleActionExecution(action)
+      normalizeActionGates(action, execution)
+      const channelOrder = action.channelOrder ?? sequence
+      if (!Number.isSafeInteger(channelOrder) || channelOrder < 0) throw new TypeError(`action ${action.id}: channelOrder must be a non-negative safe integer`)
+      const waterfallPosition = action.waterfallPosition ?? 'default'
+      if (!WATERFALL_POSITIONS.has(waterfallPosition)) throw new TypeError(`action ${action.id}: invalid waterfallPosition`)
+      if (execution.lifecycle === 'registration' && (when !== undefined || waterfallPosition !== 'default')) throw new TypeError(`action ${action.id}: registration effects do not support when or waterfall positioning`)
+      if (action.kind === 'inject-text' && waterfallPosition !== 'default') throw new TypeError(`action ${action.id}: inject-text placement belongs to its official layer, not waterfallPosition`)
+      if (action.kind === 'inject-text') {
+        validateActionOptions(action)
+        if (!record(action.config)) throw new TypeError(`action ${action.id}: config must be an object`)
+        // 原始声明保持不变；稳定动作身份只在未提供正文身份时补入运行时编译输入。
+        pendingConfigs.push({ action, source: { ...action.config, id: action.config.id ?? `${spec.id}:${action.id}` }, sequence: channelOrder, ruleId: spec.id, actionIndex })
+      } else prepareAction(action, { promptConfigOptions: options.promptConfigOptions })
+      // 空条件数组经 conjunction → undefined → compileWhen 直接返回 undefined（无条件动作）。
+      const actionWhen = compileWhen(conjunction(conditions), options)
+      const branchLayer = action.kind === 'inject-text' ? action.config.layer : spec.layer ?? 'pre-step'
+      if (actionWhen !== undefined && (REGISTRATION_LAYERS.has(branchLayer) || execution.lifecycle === 'registration')) {
+        throw new TypeError(`action ${action.id}: layer ${branchLayer} has no per-turn evaluation point — move the branch to pre-step / subagent-* / tool-pipeline / turn-stop`)
+      }
+      return Object.assign(action, { execution, channelOrder, waterfallPosition, actionIndex, actionWhen, bypassRuleWhen: bypass })
+    })
+    const pointOrders = new Map()
+    for (const action of actions) {
+      const key = `${action.execution.channel}:${action.execution.phase}:${action.waterfallPosition}`
+      const previous = pointOrders.get(key)
+      if (previous !== undefined && previous.channelOrder !== action.channelOrder) throw new TypeError(`rule ${spec.id}: conflicting channelOrder for actions ${previous.id} and ${action.id} at ${key}`)
+      pointOrders.set(key, action)
+    }
+    return { id: spec.id, name: spec.name, layer: spec.layer, group: spec.group, exclusive: spec.exclusive === true, enabled: spec.enabled !== false, sequence, when, actions, promptConfigOptions: options.promptConfigOptions }
+  })
+  validateRuleGroups(rules)
+  const complete = rules.filter(rule => rule.enabled).flatMap(rule => rule.actions).filter(action => action.config?.params?.complete === true)
+  if (complete.length > 1 || (complete.length > 0 && options.personaComplete === true)) throw new TypeError('rules: multiple complete system sections are active')
+  if (pendingConfigs.length) {
+    const compiled = createPromptConfigs(pendingConfigs.map(item => item.source), { ...options.promptConfigOptions, ...(moduleId === undefined ? {} : { sourceModuleId: moduleId }) })
+    const byId = new Map(compiled.map(config => [config.id, config]))
+    for (const item of pendingConfigs) {
+      const config = byId.get(item.source.id)
+      Object.assign(config, { sequence: item.sequence, ruleId: item.ruleId, ruleActionIndex: item.actionIndex })
+      item.action.compiledConfig = config
+    }
+  }
+  return rules
+}
+
+export function getRuleEditorMeta() {
+  const predicates = Object.keys(PREDICATE_FACTORIES).map(kind => ({ kind, example: { [kind]: structuredClone(PREDICATE_EXAMPLES[kind]) } }))
+  for (const kind of COMPOSITE_OPERATORS) {
+    const child = { phase: { promoted: false } }
+    predicates.push({ kind, example: { [kind]: kind === 'not' ? child : [child] } })
+  }
+  for (const { example } of predicates) compileWhen(example)
+  const actions = Object.keys(ACTION_KINDS).map(kind => {
+    const example = { kind, ...structuredClone(ACTION_EXAMPLES[kind]) }
+    // 新规则的投递身份由稳定 rule/action id 派生；迁移的显式 config.id 仍保留。
+    if (kind === 'inject-text') delete example.config.id
+    const action = compileRules([{ id: kind, then: [{ ...example, id: 'example' }] }])[0].actions[0]
+    return { kind, example, channel: action.execution.channel, phase: action.execution.phase, lifecycle: action.execution.lifecycle, supportsWhen: action.execution.lifecycle === 'event' }
+  })
+  return { predicates, actions, composites: [...COMPOSITE_OPERATORS], waterfallPositions: [...WATERFALL_POSITIONS] }
+}

package/engine/schema.mjs

@@ -12,7 +12,7 @@ import { attachStRenderers } from './st-render.mjs'
 import { FILE_SEQUENCE, compareConfigSequence } from './order.mjs'
 import { MATCH_LOGIC, createAnchorMatcher } from './anchor-match.mjs'
 
-const name = 'prompt-config-engine'
+const name = 'rule-engine'
 
 /**
  * 内容模板加载:提示词配置可声明 templateFile,由外部 yml / json / 纯文本模板提供内容,
@@ -146,7 +146,7 @@ export function loadPromptConfigFiles(dirUrl) {
   return specs
 }
 
-export const KNOWN_STRATEGIES = new Set(['static', 'placeholder', 'first-turn-anchor', 'guide-auto', 'custom-fallback', 'world-book'])
+export const KNOWN_STRATEGIES = new Set(['static', 'placeholder', 'first-turn-anchor', 'guide-auto', 'anchor-notice', 'world-book'])
 /**
  * 策略 × 层支持矩阵：`config.resolve` 只在 pre-step（executor）与 runtime-context 的
  * placeholder（layers）被消费，其他层声明非 static 策略会绑定 resolver 却无人调用，
@@ -158,7 +158,7 @@ export const STRATEGY_LAYER_SUPPORT = {
   placeholder: ['pre-step', 'runtime-context'],
   'first-turn-anchor': ['pre-step'],
   'guide-auto': ['pre-step'],
-  'custom-fallback': ['pre-step'],
+  'anchor-notice': ['pre-step'],
   'world-book': ['pre-step'],
 }
 /** 模板专属策略允许的层：resolver 同样只在 pre-step / runtime-context 被调用。 */
@@ -528,6 +528,9 @@ function resolveConfigFields(spec, label, layer) {
 
 /** 从 YAML 提示词配置描述构造运行时提示词配置。配置错误必须在挂载时暴露(fail loud)。 */
 export function createPromptConfigs(specs, options = {}) {
+  if (options.templateModuleRoot !== undefined && options.templatePresetRoot !== undefined
+    && String(options.templateModuleRoot) !== String(options.templatePresetRoot)) throw new TypeError('templateModuleRoot and templatePresetRoot conflict')
+  const templateModuleRoot = options.templateModuleRoot ?? options.templatePresetRoot
   if (specs === undefined) return []
   if (!Array.isArray(specs)) throw new TypeError(`${name}: config.configs must be an array`)
   // 重复 ID 拒绝：后者覆盖前者会静默丢卡，挂载前 fail loud。
@@ -550,6 +553,7 @@ export function createPromptConfigs(specs, options = {}) {
     }
     const rawStrategy = spec.strategy ?? 'static'
     const strategy = rawStrategy
+    if (strategy === 'custom-fallback') throw new TypeError(`${name}: migrate custom-fallback to an anchor condition and anchor-notice content`)
     if (!KNOWN_STRATEGIES.has(strategy)) {
       // 模板专属策略:声明了 strategyDir 时由 strategies.bindResolver 懒加载,
       // 否则视为未知策略 fail loud。
@@ -591,7 +595,7 @@ export function createPromptConfigs(specs, options = {}) {
       }
     }
     // 安装预检可把文件读取定向到尚未提交的候选目录，默认运行期仍走原解析器。
-    const template = (options.loadTemplate ?? loadTemplate)(spec.templateFile, options.templateBaseUrl, options.templatePresetRoot)
+    const template = (options.loadTemplate ?? loadTemplate)(spec.templateFile, options.templateBaseUrl, templateModuleRoot)
     const templatePatch = template !== null && typeof template === 'object'
       ? { id: template.id, role: template.role, content: template.content, source: template.source }
       : undefined
@@ -618,7 +622,14 @@ export function createPromptConfigs(specs, options = {}) {
       modelScope: fields.modelScope,
       subject: fields.subject,
       match,
-      sourceKind: typeof spec.sourceKind === 'string' && spec.sourceKind.length > 0 ? spec.sourceKind : spec.id,
+      // sourceKind 进的是消息 source.kind，必须是 **v4 的生产者身份**（`plugin:<owner>`）：
+      // 裸规则 id 会被 `userMessagesText` 的注入过滤漏掉（它只认 `source.plugin` 与
+      // `plugin:` 前缀），于是本引擎注入过的规则正文会回来参与下一轮 when 判定——实测
+      // 后果是只读档正文里的「只读」二字让写档的 notAny 在第二轮翻转，同一子代理两档并注。
+      sourceKind: (() => {
+        const declared = typeof spec.sourceKind === 'string' && spec.sourceKind.length > 0 ? spec.sourceKind : spec.id
+        return declared.startsWith('plugin:') ? declared : `plugin:${declared}`
+      })(),
       form: typeof spec.form === 'string' ? spec.form : 'notice',
       summary: typeof spec.summary === 'string' ? spec.summary : '',
       identity: fields.identity,

package/engine/shared.mjs

@@ -115,7 +115,7 @@ export function isFlashModel(modelId) {
 
 /** 模型范围过滤:flash=仅 Flash 家族模型;pro=仅非 Flash;all=全部。 */
 export function matchesModel(scope, model) {
-  if (scope === 'all') return true
+  if (scope == null || scope === 'all') return true
   const isFlash = isFlashModel(model)
   return scope === 'flash' ? isFlash : !isFlash
 }