dsh-plugin-prompt-tool 2.0.1 → 3.0.0

package/engine/schema.mjs

@@ -3,14 +3,15 @@
  * 只负责"配置长什么样";执行语义见 executor.mjs,内容策略见 strategies.mjs。
  */
 
-import { readFileSync, readdirSync } from 'node:fs'
+import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { sep } from 'node:path'
 import { parse as parseYaml } from './vendor/yaml/index.js'
 import { bindResolver } from './strategies.mjs'
-import { attachStRenderers } from './st-render.mjs'
-import { FILE_SEQUENCE, compareConfigSequence } from './order.mjs'
-import { MATCH_LOGIC, createAnchorMatcher } from './anchor-match.mjs'
+import { compareConfigSequence } from './order.mjs'
+import { SUBJECT_FIELDS } from './condition-facts.mjs'
+import { pluginKind, pluginOwner } from './source-kind.mjs'
+import { CONTEXT_ACTIVATION_STRATEGY } from './strategy-ids.mjs'
 
 const name = 'rule-engine'
 
@@ -70,83 +71,7 @@ function loadTemplate(file, baseUrl = import.meta.url, presetRootUrl) {
   return { text: raw }
 }
 
-/**
- * 完整 YAML 解析(vendored yaml 包):提示词配置文件直接使用标准 YAML。
- * 支持缩进 map、列表、block scalar、行尾注释、引号转义等全部语法。
- */
-export function parsePromptConfigYaml(raw) {
-  const parsed = parseYaml(raw)
-  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new TypeError(`${name}: prompt config yaml must contain a single object`)
-  }
-  return parsed
-}
-
-/**
- * 枚举提示词配置候选文件：**两条加载路径共用同一份枚举规则**。
- *
- * 扩展名、排序与跳过名单必须两侧一致——否则 host（编辑/列举）与引擎（注入）会看到不同的
- * 文件集：host 让人编辑 A 文件、引擎却加载 B 文件。`variables.yml` 是模板变量源而非配置，
- * 两侧都跳过（引擎另行读取它做合并，见 `loadPromptConfigFiles`）。
- *
- * 只共享**枚举**这一层：解析、结构校验、错误类型与包装都留在各自边界——两边的入参类型
- * （URL vs 字符串路径）、空路径短路与异常消息本来就不同，强行合并会改变其中一侧的行为。
- *
- * @param entries `readdirSync(dir, { withFileTypes: true })` 的结果
- * @returns 按名排序的文件名（含扩展名），已剔除 `variables.yml`
- */
-export function promptConfigFileNames(entries) {
-  return entries
-    .filter((entry) => entry.isFile() && /\.(ya?ml|json)$/i.test(entry.name))
-    .sort((a, b) => a.name.localeCompare(b.name))
-    .map((entry) => entry.name)
-    .filter((fileName) => fileName !== 'variables.yml')
-}
-
-/**
- * 从提示词配置模块目录加载全部提示词配置描述:按文件名排序扫描 *.yml / *.yaml / *.json。
- * 文件名用数字前缀表达引擎执行顺序(00-…、10-…)。
- */
-export function loadPromptConfigFiles(dirUrl) {
-  let entries
-  try {
-    entries = readdirSync(dirUrl, { withFileTypes: true })
-  } catch (error) {
-    throw new TypeError(`${name}: configsDir ${String(dirUrl)} is not readable: ${String(error?.message ?? error)}`)
-  }
-  // 预设级模板变量（writePreset 生成 variables.yml）：读入后合并进每条配置
-  // variables（配置自身优先）；variables.yml 本身不当作配置解析。缺失或损坏
-  // 时为空变量源，不阻断加载。
-  let presetVariables = {}
-  try {
-    const parsed = parseYaml(readFileSync(new URL('variables.yml', dirUrl), 'utf8'))
-    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) presetVariables = parsed
-  } catch {
-    // 无 variables.yml（旧产物/手写目录）或解析失败：保持空变量源。
-  }
-  const specs = []
-  for (const fileName of promptConfigFileNames(entries)) {
-    const raw = readFileSync(new URL(fileName, dirUrl), 'utf8')
-    const spec = /\.json$/i.test(fileName) ? JSON.parse(raw) : parsePromptConfigYaml(raw)
-    const prefix = /^(\d+)-/.exec(fileName)
-    if (prefix !== null && spec !== null && typeof spec === 'object' && !Array.isArray(spec)) {
-      const sequence = Number(prefix[1])
-      if (!Number.isSafeInteger(sequence)) throw new TypeError(`${name}: unsafe config sequence in ${fileName}`)
-      Object.defineProperty(spec, FILE_SEQUENCE, { value: sequence })
-    }
-    specs.push(spec)
-  }
-  for (const spec of specs) {
-    if (spec === null || typeof spec !== 'object' || Array.isArray(spec)) continue
-    const own = spec.variables !== null && typeof spec.variables === 'object' && !Array.isArray(spec.variables)
-      ? spec.variables
-      : {}
-    spec.variables = { ...presetVariables, ...own }
-  }
-  return specs
-}
-
-export const KNOWN_STRATEGIES = new Set(['static', 'placeholder', 'first-turn-anchor', 'guide-auto', 'anchor-notice', 'world-book'])
+export const KNOWN_STRATEGIES = new Set(['static', 'placeholder', CONTEXT_ACTIVATION_STRATEGY])
 /**
  * 策略 × 层支持矩阵：`config.resolve` 只在 pre-step（executor）与 runtime-context 的
  * placeholder（layers）被消费，其他层声明非 static 策略会绑定 resolver 却无人调用，
@@ -156,123 +81,111 @@ export const KNOWN_STRATEGIES = new Set(['static', 'placeholder', 'first-turn-an
 export const STRATEGY_LAYER_SUPPORT = {
   static: null,
   placeholder: ['pre-step', 'runtime-context'],
-  'first-turn-anchor': ['pre-step'],
-  'guide-auto': ['pre-step'],
-  'anchor-notice': ['pre-step'],
-  'world-book': ['pre-step'],
+  [CONTEXT_ACTIVATION_STRATEGY]: ['pre-step'],
 }
 /** 模板专属策略允许的层：resolver 同样只在 pre-step / runtime-context 被调用。 */
 const TEMPLATE_STRATEGY_LAYERS = ['pre-step', 'runtime-context']
 export const KNOWN_SLOT_KINDS = new Set(['ordered', 'anchor'])
 /**
  * 九个官方注入层的**唯一权威定义**（B5 T1：原 `LAYER_ORDER` / `LAYER_FIELD_POLICIES` /
- * `LAYER_EDITING` / `LAYER_LABELS` / `LAYER_DEFAULT_SUBJECT` 五处事实合一）。
+ * `LAYER_EDITING` / `LAYER_LABELS` 四处事实合一）。
  *
  * 新增或改一层只动这里一处：
  *   - 数组顺序即 `layerOrder`（**产品定义**，改顺序等于改 UI 组织，不要只为排序调整）；
- *   - `fields` 是层能力矩阵（11 项，客户端表单据此动态渲染）；
- *   - `editing` 是字段能力表（subjects / content / variables / messageMetadata / params）；
- *   - `label` 是由引擎统一下发给客户端的显示名与说明；
- *   - `defaultSubject` 是该条件层的缺省匹配对象（不声明 = 该层没有匹配对象）。
+ *   - `channel` / `phase` 是该层 `inject-text` 的**唯一注册点**（缺 `channel` 的层不可注入：
+ *     `tool-pipeline` 的工具链裁决改用 `tool-gate` / `append-context` 动作）；
+ *   - `fields` 是层能力矩阵（9 项，客户端表单据此动态渲染）；
+ *   - `editing` 是字段能力表（content / variables / messageMetadata / params）；
+ *   - `label` 是由引擎统一下发给客户端的显示名与说明。
  *
  * 下面所有导出都由本表**派生**，并保持既有名字与形状，外部消费方不受影响。
- * `defaultSubject` 必须落在本层 `editing.subjects` 内——就近声明 + 加载期断言，
- * 避免「缺省值不在允许集合里」这种只能靠运行期才发现的错配。
  */
 const LAYER_DEFINITIONS = [
   {
     layer: 'pre-step',
-    fields: { position: true, dedupe: true, promotion: true, audience: true, modelScope: true, merge: true, order: true, role: true, placeholder: true, subject: true, match: true },
-    editing: { subjects: ['userMessage'], content: 'text', variables: true, messageMetadata: true, params: {} },
+    channel: 'agent/pre-step', phase: 'after-next',
+    fields: { position: true, dedupe: true, promotion: true, audience: true, modelScope: true, merge: true, order: true, role: true, placeholder: true },
+    editing: { content: 'text', variables: true, messageMetadata: true, params: {} },
     label: { title: '消息批层', detail: '官方默认层：agent/pre-step 消息批。支持 position / dedupe / promotion / audience / mergeMode 与文本插值。' },
-    defaultSubject: 'userMessage',
   },
   {
     layer: 'system-section',
-    fields: { position: false, dedupe: false, promotion: false, audience: true, modelScope: false, merge: true, order: true, role: false, placeholder: false, subject: false, match: false },
-    editing: { subjects: [], content: 'text', variables: true, messageMetadata: false,
+    channel: 'system-prompt/assemble', phase: 'before-next',
+    fields: { position: false, dedupe: false, promotion: false, audience: true, modelScope: false, merge: true, order: true, role: false, placeholder: false },
+    editing: { content: 'text', variables: true, messageMetadata: false,
       params: { sectionName: { type: 'string' }, complete: { type: 'boolean' }, suppressRuntimeContext: { type: 'boolean' } } },
     label: { title: '系统段层', detail: 'system-section 静态层：注册即全局，由 order 与 params.complete / sectionName 控制。' },
   },
   {
     layer: 'runtime-context',
-    fields: { position: false, dedupe: false, promotion: false, audience: false, modelScope: false, merge: true, order: true, role: false, placeholder: true, subject: false, match: false },
-    editing: { subjects: [], content: 'text', variables: true, messageMetadata: false, params: { contextName: { type: 'string' } } },
+    channel: 'system-prompt/assemble', phase: 'before-next',
+    fields: { position: false, dedupe: false, promotion: false, audience: false, modelScope: false, merge: true, order: true, role: false, placeholder: true },
+    editing: { content: 'text', variables: true, messageMetadata: false, params: { contextName: { type: 'string' } } },
     label: { title: '运行上下文', detail: 'runtime-context 层：static 按 order 注册，placeholder 单条生效，由 params.contextName 控制。' },
   },
   {
     layer: 'agent-request',
-    fields: { position: false, dedupe: false, promotion: false, audience: true, modelScope: true, merge: false, order: true, role: false, placeholder: false, subject: false, match: false },
-    editing: { subjects: [], content: 'request', variables: false, messageMetadata: false,
-      params: { patch: { type: 'object' }, replace: { type: 'boolean' } } },
-    label: { title: '调用配置层', detail: 'agent-request 层：按 order 注册，params.patch 改写请求配置。' },
+    fields: { position: false, dedupe: false, promotion: false, audience: true, modelScope: true, merge: false, order: true, role: false, placeholder: false },
+    editing: { content: 'request', variables: false, messageMetadata: false, params: {} },
+    label: { title: '调用配置层', detail: 'agent/request 的请求参数由 request-params 动作修改。' },
   },
   {
     layer: 'llm-stream',
-    fields: { position: false, dedupe: false, promotion: false, audience: false, modelScope: true, merge: false, order: true, role: false, placeholder: false, subject: false, match: false },
-    editing: { subjects: [], content: 'stream', variables: false, messageMetadata: false,
-      params: { mode: { type: 'enum', values: ['pass', 'replace'] } } },
-    label: { title: '模型流层', detail: 'llm/stream 层：按 order 注册，params.mode = pass | replace。' },
+    fields: { position: false, dedupe: false, promotion: false, audience: false, modelScope: true, merge: false, order: true, role: false, placeholder: false },
+    editing: { content: 'stream', variables: false, messageMetadata: false, params: {} },
+    label: { title: '模型流层', detail: 'llm/stream 的透传与替换由 stream-output 动作处理。' },
   },
   {
     layer: 'tool-pipeline',
-    fields: { position: false, dedupe: false, promotion: false, audience: true, modelScope: true, merge: false, order: true, role: false, placeholder: false, subject: true, match: true },
-    editing: { subjects: ['toolArgs', 'toolResult'], content: 'tool-result', variables: false, messageMetadata: false,
-      params: { toolNames: { type: 'string' }, preDecision: { type: 'enum', values: ['allow', 'deny', 'ask'] },
-        denyReason: { type: 'string' }, postAction: { type: 'enum', values: ['accept', 'replace', 'block'] } } },
-    label: { title: '工具管线层', detail: 'tools/* 层：按 order 注册，params.toolNames 与 preDecision / postAction 控制；subject / match 可选，命中才裁决。' },
-    defaultSubject: 'toolArgs',
+    fields: { position: false, dedupe: false, promotion: false, audience: true, modelScope: true, merge: false, order: true, role: false, placeholder: false },
+    editing: { content: 'tool-result', variables: false, messageMetadata: false,
+      // 该层没有注入通道：旧的四项工具链参数（toolNames / preDecision / denyReason / postAction）
+      // 没有任何消费者，已删除；工具链行为由 tool-gate / tool-result 动作承担。
+      params: {} },
+    label: { title: '工具管线层', detail: '工具链层：只作规则级展示归属（无 inject-text 通道）——工具链的裁决与追加上下文由 tool-gate / tool-result / append-context 动作承担。' },
   },
   {
     layer: 'turn-stop',
-    fields: { position: false, dedupe: false, promotion: false, audience: false, modelScope: true, merge: false, order: true, role: false, placeholder: false, subject: true, match: true },
-    editing: { subjects: ['assistantText'], content: 'text', variables: true, messageMetadata: false, params: {} },
+    channel: 'agent/turn-stopping', phase: 'before-next',
+    fields: { position: false, dedupe: true, promotion: false, audience: false, modelScope: true, merge: false, order: true, role: false, placeholder: false },
+    editing: { content: 'text', variables: true, messageMetadata: false, params: {} },
     label: { title: '轮次停止层', detail: 'agent/turn-stopping 层：命中条件时强制续跑一步；引擎内置续跑上限，不可用配置关闭。' },
-    defaultSubject: 'assistantText',
   },
   {
     layer: 'subagent-start',
-    fields: { position: false, dedupe: false, promotion: false, audience: false, modelScope: true, merge: false, order: true, role: false, placeholder: false, subject: true, match: true },
-    editing: { subjects: ['subagentInfo'], content: 'text', variables: true, messageMetadata: false, params: {} },
+    channel: 'subagent/start', phase: 'before-next',
+    fields: { position: false, dedupe: false, promotion: false, audience: false, modelScope: true, merge: false, order: true, role: false, placeholder: false },
+    editing: { content: 'text', variables: true, messageMetadata: false, params: {} },
     label: { title: '子代理启动层', detail: 'subagent/start 层：命中条件时向该子代理注入上下文。' },
-    defaultSubject: 'subagentInfo',
   },
   {
     layer: 'subagent-end',
-    fields: { position: false, dedupe: false, promotion: false, audience: false, modelScope: true, merge: false, order: true, role: false, placeholder: false, subject: true, match: true },
-    editing: { subjects: ['subagentInfo'], content: 'subagent-result', variables: true, messageMetadata: false,
+    channel: 'subagent/end', phase: 'before-next',
+    fields: { position: false, dedupe: false, promotion: false, audience: false, modelScope: true, merge: false, order: true, role: false, placeholder: false },
+    editing: { content: 'subagent-result', variables: true, messageMetadata: false,
       params: { action: { type: 'enum', values: ['observe', 'inject-main'] } } },
     label: { title: '子代理结束层', detail: 'subagent/end 层：默认记录；action=inject-main 时向所属主会话注入配置文本，不改写子代理返回结果。' },
-    defaultSubject: 'subagentInfo',
   },
 ]
 
-/** 就近断言：缺省匹配对象必须在本层允许的 subjects 内（新增层时最先撞到这里）。 */
-for (const definition of LAYER_DEFINITIONS) {
-  if (definition.defaultSubject === undefined) continue
-  if (!definition.editing.subjects.includes(definition.defaultSubject)) {
-    throw new TypeError(
-      `schema: layer ${definition.layer} defaultSubject ${definition.defaultSubject} must be one of its subjects`,
-    )
-  }
-}
-
 /** 九个官方注入层的固定顺序：/meta 的 layerOrder、UI 层序与模板菜单共用这一份。 */
 export const LAYER_ORDER = LAYER_DEFINITIONS.map((definition) => definition.layer)
 export const KNOWN_LAYERS = new Set(LAYER_ORDER)
 /**
- * 条件判定的匹配对象：决定把哪段文本交给 anchor-match 匹配器。
- * 取值与 DSH 扩展点一一对应，各层缺省值见 LAYER_DEFAULT_SUBJECT。
+ * `inject-text` 可绑定的层与注册点（由 {@link LAYER_DEFINITIONS} 的 `channel` 派生，不另写层表）：
+ * 没有通道的 `tool-pipeline` 不可注入——工具链的裁决与结果处理走 `tool-gate` / `tool-result` / `append-context` 动作。
+ * `LAYER_ORDER` 九层供展示；六个注入层供 `config.layer`，其余由独立动作承担。
  */
-export const KNOWN_SUBJECTS = new Set(['toolArgs', 'toolResult', 'userMessage', 'assistantText', 'subagentInfo'])
-/** 各条件层的缺省匹配对象；不在此表的层没有匹配对象。 */
-export const LAYER_DEFAULT_SUBJECT = Object.fromEntries(
-  LAYER_DEFINITIONS
-    .filter((definition) => definition.defaultSubject !== undefined)
-    .map((definition) => [definition.layer, definition.defaultSubject]),
+const INJECTION_DEFINITIONS = LAYER_DEFINITIONS.filter((definition) => definition.channel !== undefined)
+export const INJECTION_LAYERS = INJECTION_DEFINITIONS.map((definition) => definition.layer)
+export const INJECTION_CHANNELS = Object.fromEntries(
+  INJECTION_DEFINITIONS.map((definition) => [definition.layer, { channel: definition.channel, phase: definition.phase }]),
 )
-/** 支持 subject / match 的层；其余层声明这两个字段即 fail loud（避免误以为是门）。 */
-export const CONDITIONAL_LAYERS = new Set(Object.keys(LAYER_DEFAULT_SUBJECT))
+/**
+ * live 规则条件的匹配对象（if.text.subject / if.anchor.subject）：
+ * 由 condition-facts 的 SUBJECT_FIELDS 派生，单一来源；不再用于旧 config.subject。
+ */
+export const KNOWN_SUBJECTS = new Set(Object.keys(SUBJECT_FIELDS))
 export const KNOWN_POSITIONS = new Set(['after-user', 'before-all', 'after-all'])
 export const KNOWN_DEDUPES = new Set(['session', 'batch', 'none'])
 export const KNOWN_PROMOTIONS = new Set(['none', 'main', 'include-subagents'])
@@ -285,7 +198,7 @@ export const KNOWN_MODEL_SCOPES = new Set(['all', 'pro', 'flash'])
  * 自定义策略或模板 patch 的角色仍由 executor 在出口校验，避免写出非法事件。
  */
 export const KNOWN_ROLES = new Set(['user'])
-export const KNOWN_FILLS = new Set(['instruction-hint', 'env-facts', 'skill-catalog'])
+export const KNOWN_FILLS = new Set(['instruction-hint', 'env-facts', 'skill-catalog', 'tool-catalog'])
 
 /** 层能力矩阵：每个字段只在对应注入层生效。客户端表单据此动态渲染。 */
 export const LAYER_FIELD_POLICIES = Object.fromEntries(
@@ -310,9 +223,11 @@ export const LAYER_LABELS = Object.fromEntries(
 /** 引擎能力矩阵：作为 /meta 的唯一数据源，客户端表单据此动态渲染。 */
 export function getEngineMeta() {
   return {
-    // layerOrder = 固定九层顺序（UI 组织用）；layers = 合法层集合（校验与旧消费方用）。
+    // layerOrder = 固定九层顺序（UI 组织用）；layers = 合法层集合（校验与旧消费方用）；
+    // injectionLayers 只含实际文本注入层；请求、流与工具管线使用独立动作。
     layerOrder: [...LAYER_ORDER],
     layers: [...KNOWN_LAYERS].sort(),
+    injectionLayers: [...INJECTION_LAYERS],
     strategies: [...KNOWN_STRATEGIES].sort(),
     slotKinds: [...KNOWN_SLOT_KINDS].sort(),
     positions: [...KNOWN_POSITIONS].sort(),
@@ -324,7 +239,6 @@ export function getEngineMeta() {
     mergeModes: [...KNOWN_MERGE_MODES].sort(),
     fills: [...KNOWN_FILLS].sort(),
     subjects: [...KNOWN_SUBJECTS].sort(),
-    layerDefaultSubjects: { ...LAYER_DEFAULT_SUBJECT },
     layerFieldPolicies: LAYER_FIELD_POLICIES,
     layerLabels: LAYER_LABELS,
     layerContracts: structuredClone(LAYER_CONTRACTS),
@@ -332,62 +246,47 @@ export function getEngineMeta() {
 }
 
 /**
- * 归一化并预编译条件判定的 match 段：键集合直接交给 anchor-match 的匹配器，
- * 非法 logic、非法正则与空键集合都在挂载期 fail loud——运行时静默不命中会让
- * "配了门却没拦住"变成不可见的失效。
- * @returns 归一化后的匹配参数；未声明 match 时返回 undefined（= 无条件）。
+ * 官方 `LlmCallConfig` 允许被改写的键：不能把消息、工具或 system 塞进请求配置。
+ * `request-params` 动作的 `patch`/`unset` 共用这一份。
+ *
+ * 核对到 `@deepseek-ai/dsh-llm@0.2.1-alpha.2`（上游 `packages/llm/llm/src/call-config.ts`）：
+ * `provider`/`model` 属 `LlmCallConfig`，其余四个自 0.2.1 起拆在 `LlmCallControls`，字段集未变。
+ * 上游同处留了 `TODO(call-config-shape)`（讨论 epoch 级字段与 provider 专属选项的归属），
+ * 所以这张表将来可能扩——它漂了本项目不会变红，升级 `dsh-llm` 时要手动再对一次。
  */
-function normalizeMatch(raw, label) {
-  if (raw === undefined || raw === null) return undefined
-  if (typeof raw !== 'object' || Array.isArray(raw)) {
-    throw new TypeError(`${label}.match must be an object when present`)
-  }
-  const stringList = (value, field) => {
-    if (value === undefined || value === null) return []
-    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
-      throw new TypeError(`${label}.match.${field} must be an array of strings when present`)
-    }
-    return value.map((item) => item.trim()).filter((item) => item.length > 0)
-  }
-  const keys = stringList(raw.keys, 'keys')
-  const secondaryKeys = stringList(raw.secondaryKeys, 'secondaryKeys')
-  if (keys.length === 0 && secondaryKeys.length === 0) {
-    throw new TypeError(`${label}.match needs at least one non-empty key`)
-  }
-  const logic = raw.logic ?? MATCH_LOGIC.ANY
-  if (!Object.values(MATCH_LOGIC).includes(logic)) {
-    throw new TypeError(`${label}.match.logic must be one of ${Object.values(MATCH_LOGIC).join(', ')}`)
-  }
-  for (const field of ['caseSensitive', 'wholeWords', 'useRegex']) {
-    if (raw[field] !== undefined && typeof raw[field] !== 'boolean') {
-      throw new TypeError(`${label}.match.${field} must be a boolean when present`)
-    }
-  }
-  const match = {
-    keys,
-    secondaryKeys,
-    logic,
-    caseSensitive: raw.caseSensitive === true,
-    wholeWords: raw.wholeWords === true,
-    useRegex: raw.useRegex,
+const LLM_CALL_FIELDS = new Set(['provider', 'model', 'reasoningEffort', 'temperature', 'maxTokens', 'stop'])
+
+/**
+ * 校验请求配置补丁的子键与值；拼错的键与非法值在保存/挂载前拒绝。
+ * @param label 已拼好的报错前缀（`<config label>.params.patch` 或 `action <id>.patch`）
+ */
+export function assertLlmCallPatch(patch, label) {
+  if (patch === null || typeof patch !== 'object' || Array.isArray(patch)) throw new TypeError(`${label} must be an object`)
+  for (const [key, value] of Object.entries(patch)) {
+    if (!LLM_CALL_FIELDS.has(key)) throw new TypeError(`${label}.${key} is not a LlmCallConfig field`)
+    const valid = key === 'temperature' ? typeof value === 'number' && Number.isFinite(value)
+      : key === 'maxTokens' ? Number.isSafeInteger(value) && value > 0
+        : key === 'stop' ? Array.isArray(value) && value.every(item => typeof item === 'string')
+          : typeof value === 'string' && value.trim().length > 0
+    if (!valid) throw new TypeError(`${label}.${key} has an invalid value`)
   }
-  // 预编译：useRegex、/pattern/flags 形态与整词包装里的正则错误在此暴露。
-  try {
-    createAnchorMatcher(match)
-  } catch (error) {
-    throw new TypeError(`${label}.match is not compilable: ${error instanceof Error ? error.message : String(error)}`)
+}
+
+/**
+ * `replace=true` 的不变量：整体替换会丢掉下游 provider/model，缺一即不可用。
+ * 由 request-params 动作消费；报错前缀由 label 承载。
+ * @param label 已拼好的报错前缀（`<config label>.params.patch` 或 `action <id>.patch`）
+ */
+export function assertReplacePatch(patch, replace, label) {
+  if (replace === true && (!patch?.provider || !patch?.model)) {
+    throw new TypeError(`${label} requires provider and model when replace=true`)
   }
-  return match
 }
 
 function normalizeLayerParams(raw, layer, label) {
   if (raw === undefined || raw === null) return {}
   if (typeof raw !== 'object' || Array.isArray(raw)) throw new TypeError(`${label}.params must be an object`)
-  let params = raw
-  if (layer === 'tool-pipeline' && Array.isArray(raw.toolNames)) {
-    if (raw.toolNames.some(item => typeof item !== 'string')) throw new TypeError(`${label}.params.toolNames must contain only strings`)
-    params = { ...raw, toolNames: raw.toolNames.join(',') }
-  }
+  const params = raw
   for (const [key, rule] of Object.entries(LAYER_CONTRACTS[layer].params)) {
     const value = params[key]
     if (value === undefined) continue
@@ -396,22 +295,6 @@ function normalizeLayerParams(raw, layer, label) {
         : typeof value === rule.type
     if (!valid) throw new TypeError(`${label}.params.${key} must be ${rule.type === 'enum' ? rule.values.join(' | ') : rule.type}`)
   }
-  if (layer === 'agent-request') {
-    const patch = params.patch ?? {}
-    // 官方 0.1.6 LlmCallConfig；不能把消息、工具或 system 塞进请求配置。
-    const keys = new Set(['provider', 'model', 'reasoningEffort', 'temperature', 'maxTokens', 'stop'])
-    for (const [key, value] of Object.entries(patch)) {
-      if (!keys.has(key)) throw new TypeError(`${label}.params.patch.${key} is not a LlmCallConfig field`)
-      const valid = key === 'temperature' ? typeof value === 'number' && Number.isFinite(value)
-        : key === 'maxTokens' ? Number.isSafeInteger(value) && value > 0
-          : key === 'stop' ? Array.isArray(value) && value.every(item => typeof item === 'string')
-            : typeof value === 'string' && value.trim().length > 0
-      if (!valid) throw new TypeError(`${label}.params.patch.${key} has an invalid value`)
-    }
-    if (params.replace === true && (!patch.provider || !patch.model)) {
-      throw new TypeError(`${label}.params.patch requires provider and model when replace=true`)
-    }
-  }
   return params
 }
 
@@ -430,12 +313,11 @@ const isNonEmptyString = (value) => typeof value === 'string' && value.length >
  *     undefined 不是同一档）；
  *   - `optional`：缺失即不设置；一旦存在（**含 null**）就按 `validate` 校验形态。
  *
- * 表里需要额外上下文的项用 `resolve`（subject 有「全局集合 + 层内允许集」两条语义与层缺省
- * 回退）。**表顺序 = 报错顺序**：与手写版逐个检查的先后完全一致，同一组非法输入必须先报同一处。
+ * 表里需要额外上下文的项用 `resolve`。**表顺序 = 报错顺序**：与手写版逐个检查的先后完全一致，
+ * 同一组非法输入必须先报同一处。
  *
- * 不在此表（各自领域的权威，留在原处）：`params`（`normalizeLayerParams`）、`match`
- * （`normalizeMatch`）、`text`/`texts`（多来源合并）、`strategy`/`configKind`/`layer`
- * （各自带额外上下文校验）。
+ * 不在此表（各自领域的权威，留在原处）：`params`（`normalizeLayerParams`）、
+ * `text`/`texts`（多来源合并）、`strategy`/`configKind`/`layer`（各自带额外上下文校验）。
  */
 export const CONFIG_FIELDS = [
   { field: 'position', known: KNOWN_POSITIONS, default: 'after-user' },
@@ -444,19 +326,6 @@ export const CONFIG_FIELDS = [
   { field: 'audience', known: KNOWN_AUDIENCES, keepNull: true, keepMissing: true },
   { field: 'modelScope', known: KNOWN_MODEL_SCOPES, default: 'all' },
   { field: 'role', known: KNOWN_ROLES, default: 'user' },
-  {
-    field: 'subject',
-    resolve: (spec, { label, layer }) => {
-      // 条件判定：subject 决定把哪段文本交给匹配器（缺省由层决定），match 缺省 = 无条件。
-      if (spec.subject !== undefined && !KNOWN_SUBJECTS.has(spec.subject)) {
-        throw new TypeError(`${name}: ${label} unknown subject ${JSON.stringify(spec.subject)} — known subjects: ${[...KNOWN_SUBJECTS].sort().join(', ')}`)
-      }
-      if (spec.subject !== undefined && !LAYER_CONTRACTS[layer].subjects.includes(spec.subject)) {
-        throw new TypeError(`${name}: ${label}.subject ${JSON.stringify(spec.subject)} is unavailable on layer ${JSON.stringify(layer)}`)
-      }
-      return spec.subject ?? LAYER_DEFAULT_SUBJECT[layer]
-    },
-  },
   {
     field: 'identity',
     resolve: (spec, { label }) => {
@@ -494,6 +363,26 @@ export const CONFIG_FIELDS = [
   { field: 'mergeMode', known: KNOWN_MERGE_MODES, default: 'separate' },
 ]
 
+/**
+ * 「本模块停用了模板变量」的引擎内部标记：`rule-spec.mjs#compileRules` 在配置**通过校验之后**打上它，
+ * 执行期据此跳过会话变量合并（见 `executor.mjs#runPromptConfigBatch`）。它**不在**
+ * {@link INJECT_CONFIG_FIELDS} 里——作者写同名键会按未知键 fail loud，键名只在这里定义一次。
+ */
+export const SESSION_VARIABLES_DISABLED = 'variablesDisabled'
+
+/**
+ * `inject-text.config` 的允许键：{@link CONFIG_FIELDS} 的声明键 + {@link createPromptConfigs}
+ * 直读键。规则动作的配置是同一份提示词配置，因此白名单只能从这里派生——另写一份会漂移。
+ * `enabled` 不在表里（`group`/`exclusive` 由 CONFIG_FIELDS 带进来）：这三个键在
+ * `rule-spec.mjs#normalizeActionGates` 一律点名拒绝，它们属于规则层，运行期
+ * `rule-runtime.mjs` 会覆盖它们。
+ */
+export const INJECT_CONFIG_FIELDS = new Set([
+  ...CONFIG_FIELDS.map((rule) => rule.field),
+  'id', 'layer', 'strategy', 'configKind', 'text', 'templateFile', 'fill',
+  'sourceKind', 'form', 'summary', 'params',
+])
+
 /** 按 {@link CONFIG_FIELDS} 遍历一次，产出全部标量字段的归一值（或按表顺序 fail loud）。 */
 function resolveConfigFields(spec, label, layer) {
   const resolved = {}
@@ -526,6 +415,45 @@ function resolveConfigFields(spec, label, layer) {
   return resolved
 }
 
+const ACTIVATION_FIELDS = new Set(['scan', 'scanDepth', 'scanVariables', 'selective', 'probability', 'useProbability', 'selectionGroup', 'groupOverride', 'groupWeight', 'useGroupScoring', 'sticky', 'cooldown', 'delay', 'excludeRecursion', 'preventRecursion', 'delayUntilRecursion'])
+const ACTIVATION_LOGIC = new Set(['AND_ANY', 'NOT_ALL', 'NOT_ANY', 'AND_ALL'])
+function validateActivation(params, strategy, label) {
+  for (const key of ['stWorldBook', 'stMacros', 'stSource', 'stWords']) {
+    if (Object.hasOwn(params, key)) throw new TypeError(`${label}.params.${key} is retired; reimport or explicitly convert to native context/template fields`)
+  }
+  if (params.templateEvaluation !== undefined && typeof params.templateEvaluation !== 'boolean') throw new TypeError(`${label}.params.templateEvaluation must be boolean`)
+  if (strategy !== CONTEXT_ACTIVATION_STRATEGY) {
+    if (params.activation !== undefined) throw new TypeError(`${label}.params.activation requires strategy ${CONTEXT_ACTIVATION_STRATEGY}`)
+    return
+  }
+  const activation = params.activation
+  if (activation === null || typeof activation !== 'object' || Array.isArray(activation)) throw new TypeError(`${label}.params.activation must be an object`)
+  const invalid = Object.keys(activation).filter(key => !ACTIVATION_FIELDS.has(key))
+  if (invalid.length) throw new TypeError(`${label}.params.activation unknown fields: ${invalid.join(', ')}`)
+  if (!['batch', 'history'].includes(activation.scan)) throw new TypeError(`${label}.params.activation.scan must be batch or history`)
+  for (const key of ['scanDepth', 'sticky', 'cooldown', 'delay']) {
+    if (activation[key] !== undefined && (!Number.isSafeInteger(activation[key]) || activation[key] < 0)) throw new TypeError(`${label}.params.activation.${key} must be a non-negative integer`)
+  }
+  if (activation.delayUntilRecursion !== undefined && typeof activation.delayUntilRecursion !== 'boolean'
+    && (!Number.isSafeInteger(activation.delayUntilRecursion) || activation.delayUntilRecursion < 0)) throw new TypeError(`${label}.params.activation.delayUntilRecursion must be boolean or a non-negative integer`)
+  for (const key of ['selective', 'useProbability', 'groupOverride', 'useGroupScoring', 'excludeRecursion', 'preventRecursion']) {
+    if (activation[key] !== undefined && typeof activation[key] !== 'boolean') throw new TypeError(`${label}.params.activation.${key} must be boolean`)
+  }
+  for (const key of ['probability', 'groupWeight']) {
+    if (activation[key] !== undefined && (!Number.isFinite(activation[key]) || activation[key] < 0 || (key === 'probability' && activation[key] > 100))) throw new TypeError(`${label}.params.activation.${key} is out of range`)
+  }
+  if (activation.selectionGroup !== undefined && typeof activation.selectionGroup !== 'string') throw new TypeError(`${label}.params.activation.selectionGroup must be string`)
+  if (activation.scanVariables !== undefined && (!Array.isArray(activation.scanVariables) || activation.scanVariables.some(key => typeof key !== 'string' || key.length === 0))) throw new TypeError(`${label}.params.activation.scanVariables must contain variable names`)
+  for (const key of ['keys', 'secondaryKeys']) {
+    if (params[key] !== undefined && (!Array.isArray(params[key]) || params[key].some(value => typeof value !== 'string'))) throw new TypeError(`${label}.params.${key} must contain strings`)
+  }
+  for (const key of ['constant', 'caseSensitive', 'wholeWords', 'useRegex']) {
+    if (params[key] !== undefined && typeof params[key] !== 'boolean') throw new TypeError(`${label}.params.${key} must be boolean`)
+  }
+  if (params.selectiveLogic !== undefined && !ACTIVATION_LOGIC.has(params.selectiveLogic)) throw new TypeError(`${label}.params.selectiveLogic must use a named logic`)
+  if (params.wordBoundary !== undefined && !['ascii-token', 'unicode'].includes(params.wordBoundary)) throw new TypeError(`${label}.params.wordBoundary must be ascii-token or unicode`)
+}
+
 /** 从 YAML 提示词配置描述构造运行时提示词配置。配置错误必须在挂载时暴露(fail loud)。 */
 export function createPromptConfigs(specs, options = {}) {
   if (options.templateModuleRoot !== undefined && options.templatePresetRoot !== undefined
@@ -553,7 +481,8 @@ 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 (strategy === 'world-book') throw new TypeError(`${name}: world-book is retired; reimport or explicitly convert to context-activation`)
+    if (['custom-fallback', 'first-turn-anchor', 'anchor-notice', 'guide-auto'].includes(strategy)) throw new TypeError(`${name}: retired strategy ${strategy}; use rule conditions and static content`)
     if (!KNOWN_STRATEGIES.has(strategy)) {
       // 模板专属策略:声明了 strategyDir 时由 strategies.bindResolver 懒加载,
       // 否则视为未知策略 fail loud。
@@ -566,6 +495,7 @@ export function createPromptConfigs(specs, options = {}) {
       throw new TypeError(`${name}: ${label} unknown configKind ${JSON.stringify(configKind)}`)
     }
     const layer = spec.layer ?? 'pre-step'
+    if (layer === 'agent-request' || layer === 'llm-stream') throw new TypeError(`${name}: layer ${layer} is not an inject-text channel; use ${layer === 'agent-request' ? 'request-params' : 'stream-output'} action`)
     if (!KNOWN_LAYERS.has(layer)) {
       throw new TypeError(`${name}: ${label} unknown layer ${JSON.stringify(layer)} — known layers: ${[...KNOWN_LAYERS].sort().join(', ')}`)
     }
@@ -576,7 +506,7 @@ export function createPromptConfigs(specs, options = {}) {
     }
     // 层能力矩阵同时是引擎校验源：矩阵标记 false 的字段在对应层不生效，
     // 显式提供时 fail loud（UI 表单已按矩阵隐藏，此处兜底手写配置）。
-    const restricted = ['position', 'dedupe', 'promotion', 'audience', 'modelScope', 'merge', 'role', 'subject', 'match']
+    const restricted = ['position', 'dedupe', 'promotion', 'audience', 'modelScope', 'merge', 'role']
       .filter((field) => LAYER_FIELD_POLICIES[layer][field] === false && spec[field === 'merge' ? 'mergeMode' : field] != null)
     if (restricted.length > 0) {
       throw new TypeError(`${name}: ${label} layer ${JSON.stringify(layer)} does not support field(s): ${restricted.join(', ')}`)
@@ -584,8 +514,6 @@ export function createPromptConfigs(specs, options = {}) {
     // 标量字段统一校验与归一（B5 T2：原 15 段同型校验收敛为一次遍历，表顺序即报错顺序）。
     // 传**裸 label**：前缀 `${name}: ` 由 resolveConfigFields 与各 resolve 自行补齐。
     const fields = resolveConfigFields(spec, label, layer)
-    // subject 已由 fields 归一（含「全局集合 + 层内允许集」两条语义与层缺省回退）。
-    const match = normalizeMatch(spec.match, `${name}: ${label}`)
     // placeholder 的层限制由上面的 STRATEGY_LAYER_SUPPORT 统一校验（此处不再重复）。
     let fill
     if (strategy === 'placeholder') {
@@ -599,10 +527,9 @@ export function createPromptConfigs(specs, options = {}) {
     const templatePatch = template !== null && typeof template === 'object'
       ? { id: template.id, role: template.role, content: template.content, source: template.source }
       : undefined
-    // tool-pipeline 的 toolNames 是逗号分隔字符串（parseToolNames 只认字符串）：
-    // 数组写法会被静默解析为空 = 匹配所有工具，把一条定向门扩大成全工具门，
-    // 与条件判定叠加后危害更大，这里归一化而不是留给运行时。
+    // 内容和层参数保留各自验证，条件只由规则树负责。
     const params = normalizeLayerParams(spec.params, layer, `${name}: ${label}`)
+    validateActivation(params, strategy, `${name}: ${label}`)
     const config = {
       id: spec.id,
       name: fields.name ?? spec.id,
@@ -620,15 +547,13 @@ export function createPromptConfigs(specs, options = {}) {
       promotion: fields.promotion,
       audience: fields.audience,
       modelScope: fields.modelScope,
-      subject: fields.subject,
-      match,
       // 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}`
+        return pluginOwner(declared) !== undefined ? declared : pluginKind(declared)
       })(),
       form: typeof spec.form === 'string' ? spec.form : 'notice',
       summary: typeof spec.summary === 'string' ? spec.summary : '',
@@ -647,18 +572,15 @@ export function createPromptConfigs(specs, options = {}) {
       templatePatch,
       params,
     }
-    const sequence = (Object.hasOwn(options.configOrder ?? {}, spec.id) ? options.configOrder[spec.id] : undefined) ?? spec[FILE_SEQUENCE]
+    const sequence = (Object.hasOwn(options.configOrder ?? {}, spec.id) ? options.configOrder[spec.id] : undefined)
       ?? (typeof options.sourceModuleId === 'string' ? index * 10 : undefined)
     if (sequence !== undefined) config.sequence = sequence
     if (typeof options.sourceModuleId === 'string') config.sourceModuleId = options.sourceModuleId
-    // 条件判定的匹配器在挂载期编译一次，执行侧（condition.mjs）直接复用：
-    // normalizeMatch 已用同一份参数试编译过，这里是同源的第二句（失败会抛出）。
-    config.matchScan = match === undefined ? undefined : createAnchorMatcher(match).scan
     config.resolve = bindResolver(config, options.strategyDir)
     return config
   })
   // 模块/物化来源按持久序号；没有文件来源的独立数组继续采用 anchor + order 契约。
-  return attachStRenderers(configs
+  return configs
     .map((config, fileOrder) => ({ config, fileOrder }))
     .sort((a, b) => {
       if (a.config.sequence !== undefined || b.config.sequence !== undefined) {
@@ -670,5 +592,5 @@ export function createPromptConfigs(specs, options = {}) {
       if (aAnchor === 1 && a.config.order !== b.config.order) return a.config.order - b.config.order
       return a.fileOrder - b.fileOrder
     })
-    .map(({ config }) => config))
+    .map(({ config }) => config)
 }