dsh-plugin-prompt-tool 2.1.0 → 3.0.0

package/engine/actions/assembly.mjs

@@ -1,124 +1,68 @@
-import { NAME_LIST, createMask, labelOf, requireString } from './shared.mjs'
-import { sessionEvents } from '../shared.mjs'
-
 /**
- * 动态白名单：从**本会话已持久化的** `tool/call` 事件里回收解锁名单，填入 `into`。
- *
- * 语义对齐原 `tool-bootstrap.mjs` 的 `unlockedFor(session)`：某个发现工具（如
- * `dev_tool_search`）上一次调用时把要解锁的工具名写进了自己的调用参数，本函数把它读回来
- * 填入 allow，于是**解锁能跨请求保留**——没有它，解锁是一次性的（当次请求用完即被裁掉）。
+ * assembly —— 只改装配结果的 sections / contexts。
  *
- * 判据刻意保守，坏数据只影响该条、绝不上抛：
- *  - 只认 `event.type === 'tool/call'` 且 `event.data.name` **精确等于**声明里的 `tool`；
- *  - `arguments` 是模型产出的任意字符串，`JSON.parse` 必须 try/catch；解析出的必须是对象；
- *  - 只取 `key` 指向的**字符串数组**里的字符串项，非字符串项逐项丢弃，不展开对象、不 eval；
- *  - 任一步不成立就跳过该条事件，其余事件照常累积；全程无异常（读事件本身除外，由调用方兜）。
+ * 工具可见面（目录、SDK 正文、执行闸）已收进 `tool-visibility`：同一个意图不再分散到
+ * 多个动作。`target.tools` 在这里显式拒绝，避免旧声明「编译通过但静默不生效」。
  *
- * `tool` / `key` **按参数传入**而不是向外层读取——这个模块会被多个 assembly 动作各挂一次，
- * 任何模块级可变状态都会让它们互相覆盖。
+ * 语义保持原样：同层 sections 的 keep 与 remove 互斥；contexts 的 clear 与 add/remove 互斥；
+ * 异常一律返回未改动的装配（装配失败不得让会话失去系统段或上下文）。
  */
-function fillUnlocked(into, session, tool, key, warnOnce, plugin, label) {
-  into.clear()
-  let events
-  try {
-    events = sessionEvents(session)
-  } catch (error) {
-    warnOnce(`${plugin}: assembly action ${label}: reading session events for allowFrom failed: ${String(error?.message ?? error)}`)
-    return
-  }
-  for (const event of events) {
-    if (event?.type !== 'tool/call' || event?.data?.name !== tool) continue
-    const raw = event.data.arguments
-    const parsed = typeof raw === 'string' ? safeParse(raw) : raw
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) continue
-    const value = parsed[key]
-    if (!Array.isArray(value)) continue
-    for (const item of value) if (typeof item === 'string' && item.length > 0) into.add(item)
-  }
-}
 
-function safeParse(text) {
-  try {
-    return JSON.parse(text)
-  } catch {
-    return undefined
-  }
-}
+import { NAME_LIST, requireString } from './shared.mjs'
+import { interpolateVariables } from '../interpolate.mjs'
+
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value)
 
 export function prepareAssembly(action, plugin) {
   const target = action.target
-  if (target === null || typeof target !== 'object' || Array.isArray(target)) {
-    throw new TypeError(`${plugin}: assembly requires a target object — { tools } / { sections } / { contexts }`)
+  if (!record(target)) {
+    throw new TypeError(`${plugin}: assembly requires a target object — { sections } / { contexts }`)
   }
-  const toolsSource = target.tools
-  const allowFrom = toolsSource?.allowFrom
-  let allowExtra
-  if (allowFrom !== undefined) {
-    if (allowFrom === null || typeof allowFrom !== 'object' || Array.isArray(allowFrom)) {
-      throw new TypeError(`${plugin}: assembly.tools.allowFrom must be an object — { tool, key }`)
-    }
-    requireString(allowFrom.tool, 'assembly.tools.allowFrom.tool', plugin)
-    requireString(allowFrom.key, 'assembly.tools.allowFrom.key', plugin)
-    // deny 是黑名单、动态项只做加法，同声明的语义不可解释（且 allowFrom 已经覆盖不了 deny
-    // 的名字到底该不该出现），挂载期直接拒，而不是运行期猜。
-    if (Array.isArray(toolsSource.deny) && toolsSource.deny.length > 0) {
-      throw new TypeError(`${plugin}: assembly.tools cannot combine deny with allowFrom — 动态项只做加法，与黑名单语义冲突`)
-    }
-    allowExtra = new Set()
+  if (target.tools !== undefined) {
+    throw new TypeError(`${plugin}: assembly.target.tools 已移除 — 工具可见面改用 tool-visibility 动作（allow/deny/discovery）`)
   }
-  const tools = toolsSource === undefined ? undefined : createMask(toolsSource, 'assembly.tools', plugin, allowExtra)
   const sectionsAdd = target.sections?.add
   const sectionsRemove = NAME_LIST.parse(target.sections?.remove, plugin, 'assembly.sections.remove')
-  // 白名单（2026-09-22 用户拍板「扩动作库」）：`personaSectionsOnly` 一类的语义是
-  // `filter(白名单)`，而 remove 是黑名单——未列名的第三方/晚到段不会被它删掉。
-  // 两种语义**互斥**：同时声明即挂载期 fail loud，而不是静默二选一。
   const sectionsKeep = NAME_LIST.parse(target.sections?.keep, plugin, 'assembly.sections.keep')
-  if (sectionsKeep !== undefined && sectionsRemove !== undefined) {
-    throw new TypeError(`${plugin}: assembly target.sections cannot combine keep with remove — 一种是白名单、一种是黑名单，同时声明语义不明`)
+  const sectionsAppend = target.sections?.append
+  if (sectionsAppend !== undefined) {
+    if (!Array.isArray(sectionsAppend)) throw new TypeError(`${plugin}: assembly.sections.append must be an array of { name, text, once? }`)
+    for (const entry of sectionsAppend) {
+      if (!record(entry)) throw new TypeError(`${plugin}: assembly.sections.append entries must be objects`)
+      for (const key of Object.keys(entry)) {
+        if (!['name', 'text', 'once'].includes(key)) throw new TypeError(`${plugin}: assembly.sections.append[] unknown field ${JSON.stringify(key)}`)
+      }
+      requireString(entry.name, 'assembly.sections.append[].name', plugin)
+      requireString(entry.text, 'assembly.sections.append[].text', plugin)
+      if (entry.once !== undefined && typeof entry.once !== 'boolean') throw new TypeError(`${plugin}: assembly.sections.append[].once must be boolean`)
+      if (sectionsRemove?.has(entry.name)) throw new TypeError(`${plugin}: assembly.sections.append target ${JSON.stringify(entry.name)} cannot also be removed`)
+    }
   }
   const contextsAdd = target.contexts?.add
   const contextsRemove = NAME_LIST.parse(target.contexts?.remove, plugin, 'assembly.contexts.remove')
+  if (target.contexts?.clear !== undefined && typeof target.contexts.clear !== 'boolean') {
+    throw new TypeError(`${plugin}: assembly.contexts.clear must be boolean`)
+  }
   const contextsClear = target.contexts?.clear === true
   for (const [key, list] of [['sections.add', sectionsAdd], ['contexts.add', contextsAdd]]) {
     if (list === undefined) continue
     if (!Array.isArray(list)) throw new TypeError(`${plugin}: assembly.${key} must be an array of { name, text }`)
     for (const entry of list) {
-      if (entry === null || typeof entry !== 'object') throw new TypeError(`${plugin}: assembly.${key} entries must be objects`)
+      if (!record(entry)) throw new TypeError(`${plugin}: assembly.${key} entries must be objects`)
       requireString(entry.name, `assembly.${key}[].name`, plugin)
       requireString(entry.text, `assembly.${key}[].text`, plugin)
     }
   }
+  if (contextsClear && (contextsAdd !== undefined || contextsRemove !== undefined)) {
+    throw new TypeError(`${plugin}: assembly.contexts.clear cannot combine with add or remove — clear 已清空全部条目，同时声明语义不明`)
+  }
+  if (sectionsKeep !== undefined && sectionsRemove !== undefined) {
+    throw new TypeError(`${plugin}: assembly.sections cannot combine keep with remove — 一种是白名单、一种是黑名单，同时声明语义不明`)
+  }
   return (_ctx, { warnOnce, on, collect, take }) => collect(on('system-prompt/assemble', async (assembly, context, next) => {
-    // Downstream errors propagate untouched; only this action's own logic is guarded.
     const assembled = await next()
     try {
-      if (typeof action.match === 'function' && action.match(context, assembled) !== true) return assembled
       let result = assembled
-      if (tools !== undefined && Array.isArray(result.tools)) {
-        // 每轮重算解锁名单：本轮装配要反映**本会话至今**的全部解锁调用。
-        if (allowExtra !== undefined) {
-          fillUnlocked(allowExtra, context?.session ?? context?.agent?.session, allowFrom.tool, allowFrom.key, warnOnce, plugin, labelOf(action))
-        }
-        // keep 名单兜底（2026-09-22 用户拍板，**可选**）：判据与原 `tool-bootstrap` 逐条对齐——
-        // 原模块是 `missing = required.filter(t => !available.has(t))`
-        // 且 `missing.length > 0` 即放弃裁剪，也就是「**任意一个** 名单工具缺失」而不是
-        // 「一个都不存在」（对拍实测：目录 `[bash,read]` + 名单 `[bash,str_replace_editor]` 时
-        // 原模块给完整目录，只判"全缺"会裁成 `[bash]`）。
-        // 声明写 `requireMatch: true` 才启用；**不写就照名单裁**（与 `tool-filter.mjs` 一致）。
-        const available = new Set(result.tools.map((tool) => tool?.name).filter((name) => typeof name === 'string'))
-        // 必需名单 = 静态 allow ∪ 本轮解锁项：解锁项同样是「本该存在」的工具，缺了就 fail-open。
-        const required = tools.allow === undefined && allowExtra === undefined
-          ? undefined
-          : new Set([...(tools.allow ?? []), ...(allowExtra ?? [])])
-        const missingRequired = tools.requireMatch && required !== undefined
-          && [...required].some((name) => !available.has(name))
-        if (missingRequired) {
-          warnOnce(`${plugin}: assembly action ${labelOf(action)}: a requireMatch tool is absent — exposing the full tool set (fail-open)`)
-        } else {
-          const kept = result.tools.filter((tool) => !tools.blocks(tool?.name))
-          if (kept.length !== result.tools.length) result = { ...result, tools: kept }
-        }
-      }
       if (Array.isArray(result.sections) && (sectionsAdd !== undefined || sectionsRemove !== undefined || sectionsKeep !== undefined)) {
         const kept = sectionsKeep !== undefined
           ? result.sections.filter((section) => sectionsKeep.has(section?.name))
@@ -129,6 +73,38 @@ export function prepareAssembly(action, plugin) {
           result = { ...result, sections: sectionsAdd === undefined ? kept : [...kept, ...sectionsAdd] }
         }
       }
+      if (Array.isArray(result.sections) && sectionsAppend !== undefined && sectionsAppend.length > 0) {
+        const seen = new Set()
+        let nextSections = result.sections
+        for (const entry of sectionsAppend) {
+          const index = nextSections.findIndex((section) => section?.name === entry.name)
+          if (index < 0) {
+            warnOnce(`${plugin}: assembly.sections.append target ${JSON.stringify(entry.name)} not found; skipped`)
+            continue
+          }
+          const section = nextSections[index]
+          if (typeof section?.text !== 'string') {
+            warnOnce(`${plugin}: assembly.sections.append target ${JSON.stringify(entry.name)} has no text; skipped`)
+            continue
+          }
+          const rendered = interpolateVariables(entry.text, {}, context?.agent?.session)
+          if (rendered.trim().length === 0 || /\{\{[^}]+\}\}/.test(rendered)) {
+            warnOnce(`${plugin}: assembly.sections.append target ${JSON.stringify(entry.name)} rendered empty; skipped`)
+            continue
+          }
+          if (entry.once !== false) {
+            const key = `${entry.name}\u0000${rendered}`
+            // once 覆盖同一装配内的重复动作/条目；已有贡献者追加过同一段正文时也不重复。
+            if (seen.has(key) || section.text.includes(rendered)) continue
+            seen.add(key)
+          }
+          const text = section.text.length === 0 ? rendered : `${section.text}\n${rendered}`
+          if (text === section.text) continue
+          if (nextSections === result.sections) nextSections = [...result.sections]
+          nextSections[index] = { ...section, text }
+        }
+        if (nextSections !== result.sections) result = { ...result, sections: nextSections }
+      }
       if (Array.isArray(result.contexts)) {
         if (contextsClear) {
           if (result.contexts.length > 0) result = { ...result, contexts: [] }
@@ -141,9 +117,9 @@ export function prepareAssembly(action, plugin) {
           }
         }
       }
-      return result !== assembled && take(context) ? result : assembled
+      return result !== assembled ? result : assembled
     } catch (error) {
-      warnOnce(`${plugin}: assembly action ${labelOf(action)} failed, exposing the full assembly: ${String(error?.message ?? error)}`)
+      warnOnce(`${plugin}: assembly action failed, keeping the assembled sections/contexts: ${String(error?.message ?? error)}`)
       return assembled
     }
   }))

package/engine/actions/catalog.mjs

@@ -6,69 +6,97 @@ export const ACTION_DEGRADE = Object.freeze({
 })
 
 /**
- * 九类动作的声明：**合法事件通道** + **降级语义** + 触发时机。
- * `events` 是动作允许注册的官方事件（注册到声明外的事件在挂载期 fail loud）；
- * `services` 是它允许触碰的宿主服务方法（同一纪律的文档面）。
+ * 十类动作的声明：**合法事件通道** + **降级语义** + 触发时机 + **声明字段**。
+ * `events` 是动作允许注册的官方事件：经 `on(...)` 注册的动作（`channelBinder`）注册到声明外的
+ * 事件在挂载期 fail loud；`inject-text` 不经 `channelBinder`，它的真实通道由
+ * `actionExecutionPoint`（派生自 `schema.mjs` 每层的 `channel`）决定——下面那行 `events`
+ * 对它只是**文档面**（零校验、零消费），判断层是否可注入不要以它为准；
+ * `services` 是它允许触碰的宿主服务方法（同一纪律的文档面）；
+ * `fields` 是该类动作自己的声明键（白名单写在这里**一份**，`rule-spec.mjs` 的未知键
+ * 检查从这里派生）。通用键 `id/kind/channelOrder/waterfallPosition/maxPerTurn` 由
+ * {@link ACTION_FIELDS} 统一补上；`if`/`then`/`else` 刻意不在名单里——带 `kind`
+ * 的动作写分支键会被编译期点名拒绝（`expandActions` 只认无 `kind` 的分支节点）。
  */
 export const ACTION_KINDS = Object.freeze({
   'inject-text': {
     title: '注入文本',
-    events: ['agent/pre-step', 'session/event', 'system-prompt/assemble', 'agent/request', 'llm/stream', 'tools/pre-execute', 'tools/post-execute', 'agent/turn-stopping', 'subagent/start', 'subagent/end'],
+    fields: ['config', 'options'],
+    events: ['agent/pre-step', 'session/event', 'system-prompt/assemble', 'agent/turn-stopping', 'subagent/start', 'subagent/end'],
     services: ['systemPrompt.section', 'systemPrompt.context', 'systemPrompt.variable'],
     degrade: ACTION_DEGRADE.keep,
     timing: '按配置声明的 layer 落到该层官方通道；pre-step 在 agent/pre-step，system-section/runtime-context 在注册期 + 官方 assembly。',
-    note: '复用九层注册通道，不新开通道；显式空正文 = 不注册（empty 情形）。`options` 原样交给该层的既有接线（pre-step 执行器的 `prepend` = 声明的位置策略）；`session/event` 是 pre-step 执行器自带的会话态旁听，不是第二条注入通道。',
+    note: '复用既有注入通道（见 schema 的 `injectionLayers`），不新开通道；工具链的裁决与追加上下文走 `tool-gate` / `tool-result` / `append-context`，请求参数走 `request-params`，模型流走 `stream-output`。显式空正文不注册；`session/event` 是 pre-step 执行器自带的会话态旁听，不是第二条注入通道。',
   },
   assembly: {
     title: '改装配',
+    fields: ['target', 'match'],
     events: ['system-prompt/assemble'],
     services: [],
     degrade: ACTION_DEGRADE.exposeAll,
     timing: 'system-prompt/assemble 的下游结算之后（`await next()` 之后改，装配事实已就绪）。',
     note: '失败时返回未改动的装配 = 对 tools 即暴露完整目录；不改 global，只作用于本次 assembly。',
   },
-  decision: {
-    title: '裁决',
-    events: ['tools/pre-execute', 'tools/post-execute'],
+  'tool-gate': {
+    title: '工具裁决',
+    fields: ['decision', 'reason'],
+    events: ['tools/pre-execute'],
     services: [],
     degrade: ACTION_DEGRADE.keep,
-    timing: 'pre 相在工具执行之前返回 allow|deny|ask；post 相在结果结算之后返回 accept|replace|block。',
-    note: '异常与条件未命中一律 `next()`（放行/接受），绝不让裁决 bug 卡死调用。',
+    timing: 'pre 相在工具执行之前返回 allow|deny|ask。',
+    note: '异常与条件未命中一律 `next()`（放行），绝不让裁决 bug 卡死调用；判据只看本相真正读的字段。',
   },
-  'append-context': {
-    title: '追加上下文与续跑',
-    events: ['tools/post-execute', 'agent/turn-stopping'],
+  'tool-result': {
+    title: '工具结果处理',
+    fields: ['action', 'text'],
+    events: ['tools/post-execute'],
     services: [],
     degrade: ACTION_DEGRADE.keep,
-    timing: 'mode=context 在 post-execute 追加 durable user 通知；mode=continue 在 agent/turn-stopping steer 一步。',
-    note: '续跑共用引擎的续跑预算（每轮 1 次 / 每会话 3 次），无正文时不追加（empty 情形）；绝不伪造 assistant 角色。',
+    timing: 'post 相在结果结算之后返回 accept|replace|block。',
+    note: '异常一律 `next()`（接受）；`text` 仅 replace / block 使用，accept 时被忽略。',
   },
-  guard: {
-    title: '执行层 guard',
-    events: ['system-prompt/assemble'],
-    services: ['tools.guard', 'tools.restrict'],
-    degrade: ACTION_DEGRADE.silent,
-    timing: '首次 assembly 时按 agent scope 惰性注册一次（预设切换/重绑后按新的 agent.ctx 重注册）。',
-    note: '最终拒绝层：注册在 agent.ctx 上（工具本层与晚到工具也被裁决），命中返回拒绝原因；不注册全局 guard。guard 自身不吞异常——异常即失败，绝不退化成"放行"。',
+  'append-context': {
+    title: '追加上下文',
+    fields: ['text', 'match'],
+    events: ['tools/post-execute'],
+    services: [],
+    degrade: ACTION_DEGRADE.keep,
+    timing: '在 post-execute 追加 durable user 通知。',
+    note: '无正文时不追加；绝不伪造 assistant 角色。',
   },
-  'sdk-strip': {
-    title: '裁 SDK 声明文本',
+
+  'tool-visibility': {
+    title: '工具可见面',
+    fields: ['allow', 'deny', 'requireMatch', 'discovery'],
     events: ['system-prompt/assemble'],
-    services: [],
+    services: ['tools.schemas', 'tools.restrict', 'tools.guard', 'tools.register'],
     degrade: ACTION_DEGRADE.keep,
-    timing: 'system-prompt/assemble 下游结算之后，改写名为 tools:sdk 的段文本。',
-    note: '只删不增、保守失败：形态异常/自校验失败一律原样返回；空名单零开销。仅是呈现补救，执行边界在 guard。',
+    timing: 'system-prompt/assemble 的下游结算之后：按当前条件重算目录、SDK 正文与执行闸；条件翻转时撤销上一轮注册的闸。',
+    note: '一份声明拥有工具的可见面：allow/deny 名单、requireMatch、发现工具。名单语义对齐官方 '
+      + 'ToolRestriction 的 and/or（同时给时先按 allow 保留、再按 deny 剔除）。deny 走 guard（本层与晚到工具）'
+      + '与 restrict（继承的全局工具）；allow 只有 restrict 能覆盖全局工具，本层注册无法在执行层「只保留」——'
+      + '这是官方 restrict 的边界，不是本动作的取舍。',
   },
   'request-params': {
     title: '改模型请求参数',
+    fields: ['patch', 'unset', 'replace'],
     events: ['agent/request'],
     services: [],
     degrade: ACTION_DEGRADE.keep,
     timing: 'agent/request 的下游结算之后（`await next()` 拿到已冻结的 LlmCallConfig 再改写）。',
-    note: '与既有 promptConfigs 的 agent-request 层共用 applyAgentRequestParams；只改命中 scope/agent 的请求，删键仅删"本声明注入的那个值"。',
+    note: '请求改写的唯一入口；删键仅删本声明指定的那个值。',
+  },
+  'stream-output': {
+    title: '控制模型输出流',
+    fields: ['mode', 'text'],
+    events: ['llm/stream'],
+    services: [],
+    degrade: ACTION_DEGRADE.keep,
+    timing: 'llm/stream 下游调用前决定透传或替换。',
+    note: '替换输出为合法文本 chunk，不改冻结的请求；空正文透传。',
   },
   'inbox-prepend': {
     title: '前置收件箱消息',
+    fields: ['target', 'text', 'match'],
     events: ['agent/inbox/inserted'],
     services: ['agent.inbox.prepend'],
     degrade: ACTION_DEGRADE.silent,
@@ -78,6 +106,7 @@ export const ACTION_KINDS = Object.freeze({
   },
   'pre-step-filter': {
     title: '过滤 pre-step 注入消息',
+    fields: ['sources', 'keepKinds', 'blockPlugins'],
     events: ['agent/pre-step'],
     services: [],
     degrade: ACTION_DEGRADE.exposeAll,
@@ -90,3 +119,11 @@ export const ACTION_KINDS = Object.freeze({
       + '**永不吞上下文**：异常一律返回未过滤的 decision（`expose-all`）。',
   },
 })
+
+/** 十类动作共用键：身份、同点定位与每轮预算。 */
+const COMMON_ACTION_FIELDS = ['id', 'kind', 'channelOrder', 'waterfallPosition', 'maxPerTurn']
+
+/** 每类动作的允许键集合（通用键 + `ACTION_KINDS[kind].fields`）。 */
+export const ACTION_FIELDS = Object.freeze(Object.fromEntries(
+  Object.entries(ACTION_KINDS).map(([kind, meta]) => [kind, new Set([...COMMON_ACTION_FIELDS, ...meta.fields])]),
+))

package/engine/actions/content.mjs

@@ -1,159 +1,14 @@
 /**
  * strategies — 引擎内容策略绑定(config.resolve)。
- * 内容策略: static / placeholder / first-turn-anchor / guide-auto / anchor-notice / world-book。
+ * 内容策略: static / placeholder / context-activation。
  * 策略参数全部来自 config.params（由 preset.yml 单一配置源下发），引擎只负责组装。
  * 仍支持 strategyDir 懒加载自定义模板策略。
  */
 
-import { extractText } from '../shared.mjs'
-import { MATCH_LOGIC, createAnchorMatcher } from '../anchor-match.mjs'
-import { createTaskClassifier } from '../classify-task.mjs'
 import { createPlaceholderResolver } from '../fillers.mjs'
-import { createAnchorState } from '../conditions/anchor.mjs'
 
 const name = 'prompt-config-engine'
 
-/**
- * first-turn-anchor:首条真实用户消息后的一次性任务锚点。
- * 正则与锚句文本全部来自 config.params（由 preset.yml 单一配置源下发）。
- */
-function createFirstTurnAnchorResolver(config) {
-  const useCustom = config.params?.useCustom === true
-  const customText = typeof config.params?.text === 'string' ? config.params.text : ''
-  const buildPattern = typeof config.params?.buildPattern === 'string' ? config.params.buildPattern : ''
-  const complexPattern = typeof config.params?.complexPattern === 'string' ? config.params.complexPattern : ''
-  const firstTurnBuild = typeof config.params?.firstTurnBuild === 'string' ? config.params.firstTurnBuild : ''
-  const firstTurnInspect = typeof config.params?.firstTurnInspect === 'string' ? config.params.firstTurnInspect : ''
-  const firstTurnDeep = typeof config.params?.firstTurnDeep === 'string' ? config.params.firstTurnDeep : ''
-  const classifier = createTaskClassifier({ buildPattern, complexPattern })
-  return ({ messages }) => {
-    if (useCustom) {
-      const text = customText.trim()
-      return text.length > 0 ? { text } : null
-    }
-    if (!classifier.ready || (firstTurnBuild.length === 0 && firstTurnInspect.length === 0 && firstTurnDeep.length === 0)) {
-      return null
-    }
-    const userIndex = messages.findIndex((message) => message?.source?.kind === 'user')
-    if (userIndex < 0) return null
-    const taskText = extractText(messages[userIndex])
-    if (taskText.length === 0) return null
-    const kind = classifier.classify(taskText)
-    const anchor = kind === 'complex' ? firstTurnDeep : kind === 'build' ? firstTurnBuild : firstTurnInspect
-    return anchor.length > 0 ? { text: anchor } : null
-  }
-}
-
-/**
- * guide-auto:晋升后每轮用户消息后的弱/深度引导。
- * 正则与引导文本全部来自 config.params（由 preset.yml 单一配置源下发）。
- * 复杂任务判定 fallback 复用锚定功能的 complexPattern（guideComplexPattern
- * 冗余副本已移除）——锚定与引导是独立功能，仅分类器共用。
- */
-function createGuideAutoResolver(config) {
-  const useCustom = config.params?.useCustom === true
-  const customText = typeof config.params?.text === 'string' ? config.params.text : ''
-  const complexPattern = typeof config.params?.complexPattern === 'string' ? config.params.complexPattern : ''
-  const guideWeak = typeof config.params?.guideWeak === 'string' ? config.params.guideWeak : ''
-  const guideDeep = typeof config.params?.guideDeep === 'string' ? config.params.guideDeep : ''
-  const rawMinChars = config.params?.complexMinChars
-  const complexMinChars = rawMinChars == null || rawMinChars === '' ? undefined : rawMinChars
-  if (complexMinChars !== undefined && (!Number.isSafeInteger(complexMinChars) || complexMinChars < 0)) throw new TypeError(`${name}: guide-auto complexMinChars must be a non-negative integer`)
-  // 复杂判定 fallback 复用锚定分类器（buildPattern 不参与引导判定）。
-  const classifier = createTaskClassifier({ complexPattern })
-  return ({ messages }) => {
-    const userIndex = messages.findIndex((message) => message?.source?.kind === 'user')
-    if (userIndex < 0) return null
-    const text = extractText(messages[userIndex])
-    if (text.length === 0) return null
-    if (useCustom) {
-      const guide = customText.trim()
-      return guide.length > 0 ? { text: guide } : null
-    }
-    if (guideWeak.length === 0 && guideDeep.length === 0) return null
-    return { text: ((complexMinChars !== undefined && text.length > complexMinChars) || classifier.isComplex(text)) ? guideDeep : guideWeak }
-  }
-}
-
-/**
- * anchor-notice 只生成显式正文与来源说明；资格由规则条件单独负责。
- */
-function createAnchorNoticeResolver(config) {
-  const promptText = config.texts.length > 0
-    ? config.texts.join('\n\n')
-    : (typeof config.params?.text === 'string' && config.params.text.length > 0 ? config.params.text : undefined)
-  // 确认词无内置默认（默认值归模板/预设）：空 = 不做词确认，只走未命中兜底注入。
-  const firstTurnWord = typeof config.params?.firstTurnWord === 'string' ? config.params.firstTurnWord : ''
-  // 确认词集合：writePreset 派生的 anchorWords 优先（锚句信号词多词 prefix，任一命中即
-  // 确认——deep 档 Let…/自定义锚句首词都覆盖）；无 anchorWords 时用显式确认词。
-  const anchorWords = Array.isArray(config.params?.anchorWords) && config.params.anchorWords.length > 0
-    ? config.params.anchorWords.map(String).filter((word) => word.length > 0)
-    : (firstTurnWord.length > 0 ? [firstTurnWord] : [])
-  const inspect = createAnchorState({ keys: anchorWords })
-
-  return ({ agent }) => {
-    if (promptText === undefined) return null
-    const { confirmed } = inspect(agent.session)
-    return {
-      text: promptText,
-      source: {
-        // v4 要求 kind 是生产者名：裸 `plugin` 是退役包装，会被会话格式校验拒绝。
-        kind: `plugin:${config.id}`,
-        plugin: config.id,
-        form: 'notice',
-        summary: confirmed
-          ? (firstTurnWord.length > 0 ? `prompt-tool 提示词(「${firstTurnWord}」锚定确认后注入)` : 'prompt-tool 提示词(无确认词,锚定就绪后注入)')
-          : (firstTurnWord.length > 0 ? `prompt-tool 提示词(「${firstTurnWord}」未确认,兜底注入)` : 'prompt-tool 提示词(无确认词,兜底注入)'),
-      },
-    }
-  }
-}
-
-/**
- * world-book:世界书条目(角色卡 lorebook)。constant=true 恒注入(不扫 keys);
- * selective 条目扫描当前消息批文本,keys/secondaryKeys 按 selectiveLogic 组合
- * (any=任一命中 / all=副键全中 / not=副键全不中)。匹配经 anchor-match 引擎。
- */
-function createWorldBookResolver(config) {
-  if (config.params?.stWorldBook) return ({ stWorldBookSelected }) => stWorldBookSelected === true ? { text: config.texts.join('\n\n') } : null
-  const constant = config.params?.constant === true
-  // selectiveLogic：ST world_info_logic 0=AND_ANY 1=NOT_ALL 2=NOT_ANY 3=AND_ALL。
-  const rawLogic = config.params?.selectiveLogic
-  const logic = rawLogic === 3
-    ? MATCH_LOGIC.ALL
-    : (rawLogic === 1
-      ? MATCH_LOGIC.NOT
-      : (rawLogic === 2 ? MATCH_LOGIC.NOT_ANY : MATCH_LOGIC.ANY))
-  const matcher = createAnchorMatcher({
-    keys: Array.isArray(config.params?.keys) ? config.params.keys : [],
-    secondaryKeys: Array.isArray(config.params?.secondaryKeys) ? config.params.secondaryKeys : [],
-    caseSensitive: config.params?.caseSensitive === true,
-    wholeWords: config.params?.wholeWords === true,
-    // 三态透传：undefined=ST 语义自动检测（/regex/ 或含特殊字符键按正则）；
-    // 存量配置显式 true/false 仍强制对应行为。
-    useRegex: config.params?.useRegex,
-    logic,
-  })
-  // ST 语义：constant 或无任何键的条目恒注入（always active）。
-  const hasAnyKey = (Array.isArray(config.params?.keys) ? config.params.keys : [])
-      .some((key) => String(key).trim().length > 0)
-    || (Array.isArray(config.params?.secondaryKeys) ? config.params.secondaryKeys : [])
-      .some((key) => String(key).trim().length > 0)
-  const promptText = config.texts.length > 0
-    ? config.texts.join('\n\n')
-    : (typeof config.params?.text === 'string' && config.params.text.length > 0 ? config.params.text : undefined)
-  return ({ messages }) => {
-    if (promptText === undefined) return null
-    if (constant || !hasAnyKey) return { text: promptText }
-    const haystack = (Array.isArray(messages) ? messages : [])
-      .map((message) => extractText(message))
-      .filter((text) => text.length > 0)
-      .join('\n')
-    if (haystack.length === 0) return null
-    return matcher.scan(haystack).active ? { text: promptText } : null
-  }
-}
-
 /**
  * 为归一化后的提示词配置绑定策略 resolve(策略状态随提示词配置对象,不随 apply)。
  * strategyDir:外部策略模块目录(相对本文件 URL)。未声明时只允许内置策略。
@@ -161,14 +16,13 @@ function createWorldBookResolver(config) {
 export function bindResolver(config, strategyDir) {
   switch (config.strategy) {
     case 'placeholder': return createPlaceholderResolver(config)
-    case 'first-turn-anchor': return createFirstTurnAnchorResolver(config)
-    case 'guide-auto': return createGuideAutoResolver(config)
+    case 'guide-auto':
     case 'custom-fallback':
-      throw new TypeError(`${name}: migrate custom-fallback to an anchor condition and anchor-notice content`)
+    case 'first-turn-anchor':
     case 'anchor-notice':
-      return createAnchorNoticeResolver(config)
-    case 'world-book':
-      return createWorldBookResolver(config)
+      throw new TypeError(`${name}: retired strategy ${config.strategy}; use rule conditions and static content`)
+    case 'context-activation':
+      return ({ contextActivationSelected }) => contextActivationSelected === true ? { text: config.texts.join('\n\n') } : null
     case 'static': {
       const texts = config.texts
       const patch = config.templatePatch ?? {}
@@ -198,6 +52,8 @@ export function bindResolver(config, strategyDir) {
         if (typeof make !== 'function') {
           throw new TypeError(`${name}: strategy module ${moduleUrl.href} must export createResolver(config)`)
         }
+        // 每次求值重建工厂产物（不缓存 closure）：缓存会同时改变闭包状态跨调用、文件热刷新、
+        // 跨会话串扰三项可观察行为——模块本身仍按上面缓存一次，只省 import。
         return make(config)(args)
       }
     }

package/engine/actions/examples.mjs

@@ -1,10 +1,14 @@
 export const ACTION_EXAMPLES = {
   'inject-text': { config: { id: 'notice', layer: 'pre-step', text: '' } },
   assembly: { target: {} },
-  decision: { phase: 'pre', decision: 'allow' },
-  'append-context': { mode: 'context', text: '' },
-  guard: { mask: { deny: [] } },
-  'sdk-strip': { mask: { deny: [] } },
+  // 工具链拆成两个动作：pre 相的 tool-gate 与 post 相的 tool-result。种子取引擎缺省，
+  // 中性值不替用户选业务值：`reason: ''` 与缺键同义，都落引擎缺省原因（用 `||`）。
+  'tool-gate': { decision: 'allow', reason: '' },
+  'tool-result': { action: 'accept', text: '' },
+  'append-context': { text: '' },
+  'stream-output': { mode: 'pass', text: '' },
+  // 种子给一个合法名单：空名单无法表达「剔哪些工具」（createMask 会拒绝）。
+  'tool-visibility': { deny: ['web_search'] },
   'request-params': { patch: {} },
   'inbox-prepend': { target: 'next-turn', text: '' },
   'pre-step-filter': { blockPlugins: [] },

package/engine/actions/inbox-prepend.mjs

@@ -1,5 +1,6 @@
 import { labelOf, requireString } from './shared.mjs'
 import { newMessageId } from '../shared.mjs'
+import { isPluginKind, pluginKind } from '../source-kind.mjs'
 
 export function prepareInboxPrepend(action, plugin) {
   const label = labelOf(action)
@@ -17,17 +18,15 @@ export function prepareInboxPrepend(action, plugin) {
       // （对拍实测：声明路径多插 2 条）。
       if (agent?.session === undefined) return
       if (typeof agent?.inbox?.prepend !== 'function') return
-      // v4 起插件来源的 kind 是生产者名（`plugin:<name>`）；两种形态一起认，否则换代后
-      // 「插件来源消息永不再次前置」这道防自触发的闸会静默失效。
-      if (typeof message?.source?.kind === 'string' && message.source.kind.startsWith('plugin:')) return
-      if (message?.source?.kind === 'plugin') return
+      // 插件来源（v4 或旧日志）的判定收在 source-kind；漏掉会让防自触发闸静默失效。
+      if (isPluginKind(message?.source?.kind)) return
       if (typeof action.match === 'function' && action.match(agent, message) !== true) return
       if (!take({ agent })) return
       agent.inbox.prepend(target, {
         id: newMessageId(`action-${label}`),
         role: 'user',
         content: [{ type: 'text', text }],
-        source: { kind: `plugin:${label}`, plugin: label, form: 'notice', summary: `${label} ${target}` },
+        source: { kind: pluginKind(label), plugin: label, form: 'notice', summary: `${label} ${target}` },
       })
     } catch (error) {
       warnOnce(`${plugin}: inbox-prepend action ${label} failed: ${String(error?.message ?? error)}`)