dsh-plugin-prompt-tool 2.0.1 → 3.0.0

package/engine/executor.mjs

@@ -4,8 +4,9 @@
  * 任一提示词配置失败只跳过该提示词配置并 warnOnce,绝不让注入 bug 卡死会话。
  *
  * 装配路径有两条，批执行算法只有一份（runPreStepBatch）：
- *   - 管理路径：宿主 prompt-tool 插件提供 `promptToolPreStep` 协调服务时，本来源
- *     （预设 mount）把配置注册给协调器，由协调器统一执行预设来源与独立指令文件来源；
+ *   - 管理路径：宿主 prompt-tool 插件提供 pre-step 协调服务（服务名见 `service-names.mjs`）时，本来源
+ *     （预设 mount）把配置注册给协调器，由协调器统一执行各预设来源；官方指令正文的
+ *     逐文件过滤归协调器的 prepend 监听器，旧生成卡的 `agents-file-*` 按 id 前缀跳过；
  *   - 独立路径：没有协调服务（引擎被复制到无宿主的目录复用）时，本行 ctx 注册本地
  *     pre-step 监听器，只执行自身预设配置。
  * 协调服务迟到或消失时按「先撤旧再启新」切换，任一时刻每 scope 只有一条执行路径。
@@ -20,21 +21,28 @@ import {
   keepDisposer,
   matchesModel,
   newMessageId,
-  sessionEvents,
 } from './shared.mjs'
+// 去重判据读**当前模型可见上下文**（视图①），不读完整历史：被压缩遮蔽的注入要重新注入。
+import { eventMessage, moduleIdOf, moduleOf, pluginIdentityOf, identityOf, identityStampOf, identityHit, injectedMessage, actionStamp, findActionDelivery } from './delivery.mjs'
 import { interpolateVariables } from './interpolate.mjs'
-import { conditionHit, userMessagesText } from './condition.mjs'
 import { createEpochPromotion } from './compaction-epoch.mjs'
 import { wireLayers } from './layers.mjs'
-import { sessionVarsSnapshot } from './session-vars.mjs'
-import { selectStWorldBook } from './st-world-book.mjs'
+import { renderTemplate } from './template-frame.mjs'
+import { selectContextActivation } from './context-activation.mjs'
 import { compareConfigSequence } from './order.mjs'
-import { ruleFrame, ruleMatches, actionMatches } from './conditions/evaluation.mjs'
+import { ruleFrame, actionMatches } from './conditions/evaluation.mjs'
+import { composePreStepSources, promotionOwnerOf } from './pre-step-source.mjs'
+// 标记键名与「已登记进 config 白名单」同源（schema.mjs），此处不另写字面量。
+import { SESSION_VARIABLES_DISABLED } from './schema.mjs'
+import { PRE_STEP_COORDINATOR_SERVICE } from './service-names.mjs'
 
 const name = 'prompt-config-engine'
 
-/** 已确认投递身份的进程内快路径上限;真相在持久事件流。 */
-// ponytail: 身份条数上限防无界增长（Map 按投递身份累积）；若需精确淘汰改 LRU。
+/**
+ * 「已确认投递」快路径的条目上限。真相是**当前上下文扫描**（见 injectedMessage）：
+ * 这份 memo 只省一次扫描，丢了只是多扫一次，清空不改变任何判定结果，也不再需要淘汰策略。
+ */
+// shortcut: 上限防无界增长（Map 按「身份 × 代次」累积）；若需精确淘汰改 LRU。
 const MAX_MEMO_CONFIGS = 4096
 
 /**
@@ -42,64 +50,52 @@ const MAX_MEMO_CONFIGS = 4096
  * 缺失/形状不符时返回 undefined：本行回退独立执行路径。
  */
 function coordinatorOf(ctx) {
-  const service = getService(ctx, 'promptToolPreStep')
+  const service = getService(ctx, PRE_STEP_COORDINATOR_SERVICE)
   return service !== null && typeof service === 'object' && typeof service.registerPreset === 'function'
     ? service
     : undefined
 }
 
-/** 事件数据兼容两层形状:event.data 本身是消息,或 event.data.message 是消息。 */
-function eventMessage(event) {
-  const data = event?.data
-  if (data === null || typeof data !== 'object') return undefined
-  const message = data.message !== null && typeof data.message === 'object' ? data.message : data
-  return message?.source !== null && typeof message?.source === 'object' ? message : undefined
-}
-
-/** 合并身份:merged 模式按位置分组(merged:<position>);separate 模式保持自身身份。 */
-function mergedIdentity(config) {
-  if (config.mergeMode !== 'merged') return config.id
-  return `merged:${config.position}`
-}
-
-/** 去重身份:merged 组用位置命名空间,独立配置用自身身份。 */
-function identityOf(config) {
-  return config.mergeMode === 'merged' ? mergedIdentity(config) : config.identity.value
+/** 当前消息批内是否已有该提示词配置注入(每轮去重)。 */
+function hasInBatch(config, messages) {
+  const value = identityOf(config)
+  return messages.some((message) => identityHit(message?.source, config, value))
 }
 
 /**
- * 消息来源的插件身份（去重身份）。v4 起 `source.kind` 是生产者名（`plugin:<name>`），
- * `source.plugin` 只作为旧日志字段保留——两条通道都要认，否则去重记账会在格式换代后静默失效。
+ * 快路径条目键：通道 + 模块维 + 有效期戳 + 值。分隔符用 NUL（身份值里可能带 `:`）。
+ *
+ * 位置替换与内容投影的代次共同组成戳；任一变化都重新查询当前可见投递。
+ * 无 surface（降级到完整历史）时戳恒为 `-`：完整历史不会丢事件，条目一直有效。
  */
-function pluginIdentityOf(source) {
-  if (source === null || typeof source !== 'object') return undefined
-  if (typeof source.plugin === 'string' && source.plugin.length > 0) return source.plugin
-  return typeof source.kind === 'string' && source.kind.startsWith('plugin:')
-    ? source.kind.slice('plugin:'.length)
-    : undefined
+function memoKey(field, moduleId, value, stamp) {
+  // 戳不可用（null）时调用方不查也不记。
+  return `${field}\u0000${moduleId ?? ''}\u0000${stamp}\u0000${value}`
 }
 
-function hasInjected(config, session) {
-  const value = identityOf(config)
-  return sessionEvents(session).some((event) => {
-    const message = eventMessage(event)
-    // 双通道去重：kind（外来/第三方消息，如 context-gate 的 instruction-hint）或
-    // plugin（本引擎注入的命名空间，merged 组用 merged:<position>）。
-    return message?.source?.kind === config.sourceKind || pluginIdentityOf(message?.source) === value
-  })
-}
-
-/** 当前消息批内是否已有该提示词配置注入(每轮去重)。 */
-function hasInBatch(config, messages) {
-  const value = identityOf(config)
-  return messages.some((message) =>
-    message?.source?.kind === config.sourceKind || pluginIdentityOf(message?.source) === value)
+/**
+ * 本会话当前可见上下文的代次戳，也是 memo 键的失效维。
+ *
+ * - 代次对：surface 的 `replaceGeneration:contentGeneration`；
+ * - `'-'`：无 surface（降级到完整历史），事件不会消失，条目一直有效；
+ * - `null`：**有 `surface.nodes` 却没有数字代次** —— memo 此时不可用：代次是它唯一的失效
+ *   信号，而真相（`currentEvents`）仍跟着 `nodes` 走，快路径会把被压缩移走的注入永久记成
+ *   「已投递」。这种宿主形态是真实情形（恢复、重放、其它宿主、既有桩；见
+ *   `compaction-epoch.mjs` 的失效条件③），调用方据此跳过 memo、退回当前上下文扫描
+ *   —— memo 只是省一次扫描的缓存，跳过不改变任何判定结果。
+ */
+function contextStamp(session) {
+  const generation = session?.surface?.replaceGeneration
+  if (typeof generation === 'number') return `${generation}:${session.surface.contentGeneration ?? 0}`
+  return Array.isArray(session?.surface?.nodes) ? null : '-'
 }
 
 /**
- * 按投递身份取「已确认投递」的会话集合。记账只发生在宿主真正接纳并持久化该消息之后
- * （见 confirmDelivered）：候选在瀑布外层被门控/策略剥离时不算已投递，否则晋升后
- * （门控放行时）正文会永久缺失。集合上限按会话数截断，真相仍在持久事件流。
+ * 按投递身份取「已确认投递」的会话集合 —— 纯性能缓存（省一次当前上下文扫描），
+ * **不是**真相：条目可随时丢弃（上限、`release()`、`clear()`），丢了只多扫一次。
+ *
+ * 记账只发生在宿主真正接纳并持久化该消息之后（见 confirmDelivered）：候选在瀑布外层被
+ * 门控/策略剥离时不算已投递，否则晋升后（门控放行时）正文会永久缺失。
  */
 function deliveredSessions(memo, key) {
   let set = memo.get(key)
@@ -114,30 +110,49 @@ function deliveredSessions(memo, key) {
 
 /**
  * 记录一次宿主已接纳的注入消息（由调用方在 session/event 里转发）。
- * plugin（本引擎身份，merged 组用 merged:<position>）与 kind（外来通道，如
- * context-gate 的 instruction-hint）都以会话为界记账，与 hasInjected 的双通道语义一致。
+ * plugin（本引擎身份，merged 组用 merged:<position>）、kind（外来通道，如
+ * context-gate 的 instruction-hint）与消息的模块维都以会话为界记账，
+ * 与 identityHit 的三元组判据一致。
  */
 export function confirmDelivered(memo, session, event) {
   if (memo === null || memo === undefined || session === null || session === undefined) return
   const source = eventMessage(event)?.source
   if (source === null || typeof source !== 'object') return
+  const moduleId = moduleOf(source)
+  const stamp = contextStamp(session)
+  // 戳不可用 → 不记账：这条快路径无法在视图变化时失效，判定改由当前上下文扫描给出。
+  if (stamp === null) return
   for (const field of ['plugin', 'kind']) {
     const value = source[field]
     if (typeof value !== 'string' || value.length === 0) continue
-    deliveredSessions(memo, `${field}:${value}`).add(session.id)
+    deliveredSessions(memo, memoKey(field, moduleId, value, stamp)).add(session.id)
   }
   // v4 起生产者身份挂在 kind（`plugin:<name>`），旧日志才有 plugin 字段；
   // 两种形态都补记到 plugin: 账本，alreadyDelivered 的 `confirmed('plugin', …)` 才不会漏。
   const plugin = pluginIdentityOf(source)
-  if (plugin !== undefined && source.plugin === undefined) deliveredSessions(memo, `plugin:${plugin}`).add(session.id)
+  if (plugin !== undefined && source.plugin === undefined) {
+    deliveredSessions(memo, memoKey('plugin', moduleId, plugin, stamp)).add(session.id)
+  }
 }
 
-/** dedupe=session：本会话是否已有该身份的已确认投递（快路径 + 持久事件真相）。 */
+/** dedupe=session：本会话**当前上下文**里是否已有该身份的已确认投递（快路径 + 当前上下文真相）。 */
 function alreadyDelivered(config, session, memo) {
-  const confirmed = (field, value) => memo.get(`${field}:${value}`)?.has(session.id) === true
+  if (config.linkedDelivery) return config.mergeMode === 'merged'
+    ? injectedMessage(config, session) !== undefined : findActionDelivery(session, config) !== undefined
+  const stamp = contextStamp(session)
+  // 模块维有两种命中：本模块的键，以及升级前注入（无模块维）那份的保守键。
+  const modules = [moduleIdOf(config, 'sourceModuleId') ?? '', '']
+  // 戳不可用（有 surface 却无代次）→ 不查 memo：那里记的「已投递」可能已被视图改写。
+  const confirmed = (field, value) => stamp !== null && modules.some((moduleId) =>
+    memo.get(memoKey(field, moduleId, value, stamp))?.has(session.id) === true)
   if (confirmed('plugin', identityOf(config))) return true
   if (typeof config.sourceKind === 'string' && confirmed('kind', config.sourceKind)) return true
-  return hasInjected(config, session)
+  const message = injectedMessage(config, session)
+  if (message === undefined) return false
+  // 慢路径命中即按既有入口回填快路径（真相仍是当前上下文，不直接写 memo）：
+  // 无 id 的会话不记账——memo 的键就是 session.id，记了会让两个无 id 会话串味。
+  if (session.id !== undefined) confirmDelivered(memo, session, { data: { message } })
+  return true
 }
 
 /**
@@ -148,7 +163,7 @@ const PRE_STEP_ROLE = 'user'
 
 /**
  * 记录一次角色降级：保留原角色、明确告警、不改正文，也不把非法值传给宿主。
- * 同一配置只告警一次（warnOnce），且不记录正文或用户内容。
+ * 同一句告警只记一次（warnOnce 按消息去重），且不记录正文或用户内容。
  */
 function downgradeRole(config, requested, warnOnce) {
   if (typeof requested !== 'string' || requested === PRE_STEP_ROLE) return undefined
@@ -157,21 +172,33 @@ function downgradeRole(config, requested, warnOnce) {
 }
 
 /** 构造默认 user 消息;策略返回完整 patch 时覆盖对应字段,但非法角色在出口兜底降级。 */
-function buildMessage(config, resolved, warnOnce) {
+function buildMessage(config, resolved, warnOnce, session) {
   const text = typeof resolved.text === 'string' ? resolved.text : ''
   const defaultContent = config.texts.length > 0
     ? config.texts.map((item) => ({ type: 'text', text: item }))
     : [{ type: 'text', text }]
-  const sourceValue = mergedIdentity(config)
+  // 盖章身份与 alreadyDelivered 的查找键同源（identityOf）：显式 identity 才真正共享去重，
+  // 也不会与他卡的 id 误撞；merged 组 identityOf 本就等于 mergedIdentity，存量输出不变。
+  const sourceValue = identityOf(config)
   // 策略 patch（templateFile 的 role 等）与配置声明都必须经过同一出口判定。
   const requested = downgradeRole(config, typeof resolved.role === 'string' ? resolved.role : config.role, warnOnce)
-  const base = resolved.source !== null && typeof resolved.source === 'object'
-    ? resolved.source
+  // 模块维与 `identityStampOf` 同源（`moduleIdOf`：空串与缺失同等）：两条分支必须盖同一份章，
+  // 否则解析器自带 source 的消息比合成分支多带一个空模块维，memo 与判定就会分叉。
+  const moduleId = moduleIdOf(config, 'sourceModuleId')
+  const source = resolved.source !== null && typeof resolved.source === 'object'
+    // 解析器自带的 source 也要盖章：否则这类消息（如 fill=instruction-hint 的
+    // `{ kind: 'instruction-hint' }`）只带 kind 通道，dedupe=session 每步重复注入。
+    // 解析器自带的 kind 优先（缺省 kind 只在它缺席时补），plugin 只在其非空时覆盖身份。
+    ? {
+        ...resolved.source,
+        plugin: typeof resolved.source.plugin === 'string' && resolved.source.plugin.length > 0 ? resolved.source.plugin : sourceValue,
+        ...(resolved.source.kind === undefined ? { kind: identityStampOf({ ...config, sourceKind: undefined }).kind } : {}),
+        ...(moduleId === undefined ? {} : { moduleId }),
+      }
     : {
-        // v4 要求 kind 是**生产者名**：声明了 sourceKind 就用它，否则用与 pluginMessage 同一形状的
-        // `plugin:<身份>`。裸 kind（undefined / 'plugin'）都会被 codec 拒绝，历史走的是同一个坑。
-        kind: typeof config.sourceKind === 'string' && config.sourceKind.length > 0 ? config.sourceKind : `plugin:${sourceValue}`,
-        plugin: sourceValue,
+        // 模块维是身份判据的新一维，但**不并进身份字符串**：`source.plugin` 的格式是
+        // blockPlugins 的精确匹配契约，一字不改；整模块复制的区分只靠这个独立字段。
+        ...identityStampOf(config),
         ...(typeof config.form === 'string' ? { form: config.form } : {}),
         ...(typeof config.summary === 'string' && config.summary.length > 0 ? { summary: config.summary } : {}),
       }
@@ -179,7 +206,41 @@ function buildMessage(config, resolved, warnOnce) {
     id: typeof resolved.id === 'string' && resolved.id.length > 0 ? resolved.id : newMessageId(config.id),
     role: PRE_STEP_ROLE,
     content: Array.isArray(resolved.content) ? resolved.content : defaultContent,
-    source: requested === undefined ? base : { ...base, requestedRole: requested },
+    source: { ...source, ...actionStamp(config, session), ...(requested === undefined ? {} : { requestedRole: requested }) },
+  }
+}
+
+/**
+ * 本步（一个 pre-step 批次，含被 `ruleActions` 切开的多次 flush）的批级快照：
+ * 合格配置集合、模板位置身份集合与 ST 世界书选择，全部在批首取定一次。
+ *
+ * 三者必须同一集合：`qualified` 每配置只判一次（R02），ST 世界书的组互斥与概率/
+ * 粘滞窗口按**步**成立——旧实现每个 flush 各选一次，同组两条会各赢一条（F06）。
+ * 返回 undefined = 本批无法执行（reject / 无 agent / 无 session），调用方原样返回。
+ */
+function batchScope(options, frame) {
+  const { agent, decision, configs, promotion, warnOnce } = options
+  const session = agent?.session
+  if (decision === null || typeof decision !== 'object' || decision.kind === 'reject'
+    || agent === undefined || session === undefined) return undefined
+  const messages = Array.isArray(decision.messages) ? [...decision.messages] : []
+  const { main, withSubagents } = promotion
+  const delegated = isDelegated(session)
+  // 本批资格判定（唯一实现）：层通道、受众、模型、晋升与 live 规则条件。
+  // 条件判定放在去重之前：未命中的配置不算「已注入」，条件恢复后仍应能注入。
+  // ST 模板的跨配置变量帧按 order 预求值，但只有这里的获准集合才允许产生副作用
+  // （未命中的 setter 提前 setvar 会污染同批 reader）——渲染器不再复制判定。
+  const qualified = configs.filter((config) => config.layer === 'pre-step'
+    && !(config.audience === 'main' && delegated)
+    && !(config.audience === 'subagent' && !delegated)
+    && matchesModel(config.modelScope, agent.options?.model)
+    && (config.promotion !== 'main' || main.status(agent).promoted)
+    && (config.promotion !== 'include-subagents' || withSubagents.status(agent).promoted)
+    && actionMatches(config, frame))
+  return {
+    qualified: new Set(qualified),
+    contextActivation: selectContextActivation(qualified, session, messages, warnOnce, config => config[SESSION_VARIABLES_DISABLED] === true
+      ? { module: {}, global: {} } : config.variableStore?.read(config.sourceModuleId) ?? { module: config.variables, global: {} }),
   }
 }
 
@@ -193,65 +254,74 @@ function buildMessage(config, resolved, warnOnce) {
  *
  * @param options.configs 已过滤 enabled 与互斥组的最终提示词配置列表。
  * @param options.promotion { main, withSubagents } 晋升追踪器(真相在持久事件流)。
- * @param options.memo 已确认投递身份的进程内 session 去重快路径（见 confirmDelivered）。
+ * @param options.memo 已确认投递身份的进程内 session 去重快路径（纯缓存，丢了只多一次
+ *   当前上下文扫描；见 confirmDelivered）。
  * @returns 注入后的 decision；reject、缺 agent/session、全部跳过或异常时原样返回。
  */
 export async function runPreStepBatch(options) {
-  const initialFrame = options.ruleFrame ?? ruleFrame('agent/pre-step', [{ agent: options.agent, messages: options.decision?.messages ?? [] }], options.warnOnce, options.ctx)
-  if (!options.ruleActions?.length) return runPromptConfigBatch({ ...options, ruleFrame: initialFrame })
-  const entries = [...options.configs.map(config => ({ ...config, config })), ...options.ruleActions].sort(compareConfigSequence)
+  if (!Array.isArray(options.sources)) {
+    throw new TypeError('runPreStepBatch requires a sources array')
+  }
+  const sources = options.sources
+  const composed = composePreStepSources(sources)
+  if (composed.configs.length === 0 && composed.ruleActions.length === 0) return options.decision
+  const ctx = options.ctx ?? sources[0]?.ctx
+  const initialFrame = options.ruleFrame ?? ruleFrame('agent/pre-step', [{ agent: options.agent, messages: options.decision?.messages ?? [] }], options.warnOnce, ctx, composed.report)
+  // 批级快照与单配置失败同款 fail-safe：资格判定或 ST 世界书选择抛错时只告警一次并跳过本步
+  // 注入（scope 留空 → runPromptConfigBatch 原样返回 decision），绝不把异常抛进
+  // agent/pre-step waterfall。世界书键的 `interpolateVariables` 在 selectStWorldBook 的
+  // per-config try 之外，配置错误不得卡死会话。
+  const batchOptions = { ...options, ...composed, ctx }
+  let scope
+  try {
+    scope = batchScope(batchOptions, initialFrame)
+  } catch (error) {
+    options.warnOnce?.(`${name}: prompt config failed, skipping: ${String((error && error.message) || error)}`)
+  }
+  // 同一批的配置与动作按配置序号统一排序；没有规则动作时也必须排，不能依赖来源注册顺序。
+  const orderedConfigs = [...composed.configs].sort(compareConfigSequence)
+  if (composed.ruleActions.length === 0) {
+    return runPromptConfigBatch({ ...batchOptions, configs: orderedConfigs, ruleFrame: initialFrame, scope })
+  }
+  const entries = [...orderedConfigs.map(config => ({ ...config, config })), ...composed.ruleActions].sort(compareConfigSequence)
   let decision = options.decision
   if (decision?.kind === 'reject') return decision
   let pending = []
   const placement = { beforeAll: new Set(), afterUser: new Set() }
   const flush = async () => {
-    if (pending.length) decision = await runPromptConfigBatch({ ...options, decision, configs: pending, ruleFrame: initialFrame, placement })
+    if (pending.length) decision = await runPromptConfigBatch({ ...batchOptions, decision, configs: pending, ruleFrame: initialFrame, placement, scope })
     pending = []
   }
   for (const entry of entries) {
     if (entry.config) { pending.push(entry.config); continue }
     await flush()
-    if (ruleMatches(entry.rule, initialFrame)) decision = await entry.handler(options.payload ?? initialFrame.args[0], () => decision, initialFrame)
+    if (actionMatches(entry, initialFrame)) decision = await entry.handler(options.payload ?? initialFrame.args[0], () => decision, initialFrame)
   }
   await flush()
   return decision
 }
 
 async function runPromptConfigBatch(options) {
-  const { ctx, agent, decision, configs, promotion, memo, warnOnce } = options
+  const { ctx, agent, decision, configs, memo, warnOnce, scope } = options
   if (decision === null || typeof decision !== 'object') return decision
   if (decision.kind === 'reject') return decision
   if (agent === undefined) return decision
   const session = agent.session
   if (session === undefined) return decision
-  const { main, withSubagents } = promotion
+  // 批级快照由 runPreStepBatch 在批首取定；这里只消费，不再重新判定。
+  if (scope === undefined) return decision
   try {
     const messages = Array.isArray(decision.messages) ? [...decision.messages] : []
-    // 条件判定的匹配对象在本批进入时取定：批次内后续注入不改变本批的判定依据。
-    const userText = userMessagesText(messages)
     let changed = false
 
     const due = []
-    // 本批资格判定（唯一实现）：层通道、受众、模型、晋升与声明式条件。
-    // 条件判定放在去重之前：未命中的配置不算「已注入」，条件恢复后仍应能注入。
-    // ST 模板的跨配置变量帧按 order 预求值，但只有这里的获准集合才允许产生副作用
-    // （未命中的 setter 提前 setvar 会污染同批 reader）——渲染器不再复制判定。
-    const delegated = isDelegated(session)
-    const qualified = (config) => config.layer === 'pre-step'
-      && !(config.audience === 'main' && delegated)
-      && !(config.audience === 'subagent' && !delegated)
-      && matchesModel(config.modelScope, agent.options?.model)
-      && (config.promotion !== 'main' || main.status(agent).promoted)
-      && (config.promotion !== 'include-subagents' || withSubagents.status(agent).promoted)
-      && conditionHit(config, { userText })
-      && actionMatches(config, options.ruleFrame)
-    const qualifiedConfigs = configs.filter(qualified)
-    // 协调器为绑定来源 ctx 会复制 config；renderSt 函数身份在副本间保持不变。
-    const eligible = new Set(qualifiedConfigs.map(config => config.renderSt))
-    const stWorldBook = selectStWorldBook(qualifiedConfigs, session, messages, warnOnce)
     for (const config of configs) {
       try {
-        if (!qualified(config)) continue
+        if (!scope.qualified.has(config)) continue
+        if (config.position === 'after-user' && !messages.some(message => message?.source?.kind === 'user')) {
+          warnOnce(`${name}: after-user config(s) ${config.id} skipped this batch — no user message anchor`)
+          continue
+        }
 
         if (config.dedupe === 'session') {
           if (alreadyDelivered(config, session, memo)) continue
@@ -259,31 +329,33 @@ async function runPromptConfigBatch(options) {
           continue
         }
 
-        const resolved = await config.resolve({ ctx, agent, session, decision, messages, stWorldBookSelected: stWorldBook.has(config) })
+        const signal = options.payload?.signal
+        if (signal?.aborted) continue
+        const resolved = await config.resolve({ ctx, agent, session, signal, decision, messages, contextActivationSelected: scope.contextActivation.has(config) })
+        if (signal?.aborted) continue
         if (resolved === null || resolved === undefined) continue
         const patched = { ...resolved }
-        // params 并入插值变量：ST 变量（setvar/getvar 收集 + 预设参数）顶层 key 直接可插值
-        //（含中文 key 如 {{接受值}}——引擎正则已支持 Unicode 字母）。
-        // 会话变量（session_var 工具维护）覆盖配置/预设默认：resolved > 会话 > params > 配置。
+        // 按来源读取最新持久值；无变量正文不因另一个坏候选的读盘失败撤回。
         const mergedVars = {
-          ...config.variables,
-          ...config.params,
-          ...sessionVarsSnapshot(session),
+          ...(config[SESSION_VARIABLES_DISABLED] === true ? {} : config.params?.templateEvaluation !== true && [patched.text, ...config.texts].some(text => typeof text === 'string' && text.includes('{{'))
+            ? config.variableStore?.read(config.sourceModuleId).effective ?? config.variables : config.variables),
           ...(resolved.variables !== null && typeof resolved.variables === 'object' ? resolved.variables : {}),
         }
-        if (typeof config.renderSt === 'function') {
-          patched.text = config.renderSt(agent, messages, warnOnce, options, eligible)
+        if (config.params?.templateEvaluation === true) {
+          patched.text = renderTemplate({ ...config, texts: config.texts.length ? config.texts : [patched.text ?? ''] }, { agent, signal }, { enabled: config[SESSION_VARIABLES_DISABLED] !== true, warn: warnOnce })
           patched.content = patched.text.length > 0 ? [{ type: 'text', text: patched.text }] : []
         } else if (typeof patched.text === 'string') {
           // 提示词配置级模板变量 + filler 变量 + 内置环境变量插值。
-          patched.text = interpolateVariables(patched.text, mergedVars, session)
+          // 第 5 参是模板位置身份（本配置的 id）：{{pick}} 的 seed 只认「同会话 + 同模板位置 + 同一次出现」，
+          // 缺省空串会让不同配置的首个 pick 退化成同一个 seed。
+          patched.text = interpolateVariables(patched.text, mergedVars, session, undefined, config.id)
         }
-        if (config.texts.length > 0 && typeof config.renderSt !== 'function') {
+        if (config.texts.length > 0 && config.params?.templateEvaluation !== true) {
           const blocks = config.texts
-            .map((item) => interpolateVariables(item, mergedVars, session))
+            .map((item, index) => interpolateVariables(item, mergedVars, session, undefined, `${config.id}#${index}`))
             .filter((item) => item.length > 0)
             .map((item) => ({ type: 'text', text: item }))
-          if (blocks.length > 0) patched.content = blocks
+          patched.content = blocks
         }
         const hasText = typeof patched.text === 'string' && patched.text.length > 0
         const hasContent = Array.isArray(patched.content) && patched.content.length > 0
@@ -317,7 +389,7 @@ async function runPromptConfigBatch(options) {
     const planned = []
     for (const group of orderedGroups) {
       const base = group[0]
-      const message = buildMessage(base.config, base.resolved, warnOnce)
+      const message = buildMessage(base.config, base.resolved, warnOnce, agent.session)
       if (group.length > 1) {
         message.content = group.flatMap((entry) => {
           if (Array.isArray(entry.resolved.content)) return entry.resolved.content
@@ -326,7 +398,7 @@ async function runPromptConfigBatch(options) {
             : []
         })
         if (message.source !== null && typeof message.source === 'object') {
-          message.source = { ...message.source, plugin: mergedIdentity(base.config) }
+          message.source = { ...message.source, plugin: identityOf(base.config) }
         }
         // 合并组的角色由首条配置决定;其余成员声明的非法角色同样要告警并留下降级事实。
         for (const entry of group.slice(1)) {
@@ -345,7 +417,7 @@ async function runPromptConfigBatch(options) {
     // 同位置批量插入:planned 已按 order 升序,多元素 splice/unshift/push 保持该顺序。
     // 去重记账不在这里：候选被外层门控剥离时也必须保持「未投递」，由 confirmDelivered 确认。
     const markGroup = (group) => {
-      for (const entry of group) stWorldBook.commit?.(entry.config)
+      for (const entry of group) scope.contextActivation.commit?.(entry.config)
     }
     const beforeAll = planned.filter((item) => item.position === 'before-all')
     const afterUser = planned.filter((item) => item.position !== 'before-all' && item.position !== 'after-all')
@@ -359,6 +431,12 @@ async function runPromptConfigBatch(options) {
       changed = true
     }
     const userIndex = messages.findIndex((item) => item?.source?.kind === 'user')
+    if (afterUser.length > 0 && userIndex < 0) {
+      // 本批没有真实用户消息可锚定：本步跳过（不记账，next 含 user 的批仍会注入）。不兜底到
+      // before-all / after-all —— 「锚点是真实用户消息、不挂到插件消息之后」是插入点契约。
+      // 按消息去重后，不同配置组合各记一次，不再互相占名额。
+      warnOnce(`${name}: after-user config(s) ${afterUser.map((item) => item.group[0].config.id).join(', ')} skipped this batch — no user message anchor`)
+    }
     if (afterUser.length > 0 && userIndex >= 0) {
       const last = options.placement === undefined ? -1 : messages.findLastIndex(message => options.placement.afterUser.has(message))
       messages.splice(Math.max(userIndex, last) + 1, 0, ...afterUser.map((item) => item.message))
@@ -379,14 +457,6 @@ async function runPromptConfigBatch(options) {
   }
 }
 
-/**
- * 把一组运行时提示词配置装配为注入执行器（独立模式 / 协调器管理模式的接线口）。
- *
- * @param options.prepend 是否以 prepend 注册本地 pre-step(合并行恒 true;由参数决定)。
- * @param options.sourceId 协调器里的来源 id(默认取首条配置 id 派生)。
- * @param options.officialInstructions 本 mount 的组合是否仍挂着官方指令加载行
- *   (负责人冲突事实;协调器据此拒绝同时注入文件正文)。
- */
 function effectivePromptConfigs(configs) {
   const list = configs.filter((config) => config !== undefined && config !== null)
   const claimedGroups = new Set()
@@ -400,120 +470,135 @@ function effectivePromptConfigs(configs) {
   })
 }
 
-/** 多模块仍各自拥有来源/互斥组；只有非 pre-step 层汇总接线，避免模块块状执行。 */
-export function applyPromptConfigSources(ctx, sources, options = {}) {
+/**
+ * 唯一的 pre-step 装配入口：来源自带 ctx/onOutcome/promotion，本函数只做固定效果接线、
+ * 协调器注册与（无协调器时的）单 listener 批执行。
+ *
+ * 所有来源必须共享同一个 ctx；没有 promotion 时由协调器或本次调用补一个 fallback owner，
+ * 已有 owner 不一致则 fail loud。
+ */
+export function applyPromptConfigSources(sources, options = {}) {
+  if (!Array.isArray(sources) || sources.length === 0) return () => {}
+  const ctx = sources[0].ctx
+  if (sources.some(source => source.ctx !== ctx)) {
+    throw new TypeError('prompt-tool: all pre-step sources in one apply call must share the same ctx')
+  }
+  const warnOnce = createWarnOnce(ctx, name)
   const selected = sources.map(source => ({ ...source, configs: effectivePromptConfigs(source.configs) }))
-  const releases = selected.map(source => applyPromptConfigs(ctx, source.configs, { ...options, ...source, layers: false }))
-  const releaseLayers = options.layers === false ? () => {} : wireLayers(ctx, selected.flatMap(source => source.configs)
-    .filter(config => config.layer !== 'pre-step'), createWarnOnce(ctx, name))
-  return () => {
-    for (const release of releases) release()
-    releaseLayers()
+  const owner = promotionOwnerOf(selected)
+  const coordinator = coordinatorOf(ctx)
+  const coordinatorPromotion = coordinator?.promotion
+  if (coordinator !== undefined && coordinatorPromotion === undefined) {
+    throw new TypeError('prompt-tool: pre-step coordinator v2 must expose a promotion owner')
   }
-}
-
-export function applyPromptConfigs(ctx, configs, options = {}) {
-  const list = configs.filter((config) => config !== undefined && config !== null)
-  const sourceId = typeof options.sourceId === 'string' && options.sourceId.length > 0
-    ? options.sourceId
-    : `preset:${String(list[0]?.id ?? 'unknown')}`
-  // 互斥组仍在本来源内筛选；空来源也保留协调器迟到/HMR 接管。
-  const effectiveList = effectivePromptConfigs(list)
+  if (coordinatorPromotion !== undefined && owner !== undefined && owner !== coordinatorPromotion) {
+    throw new TypeError('prompt-tool: pre-step sources must use the active coordinator promotion owner')
+  }
+  // 执行 owner 唯一：有来源 owner 就用它，否则由本次 apply 建 fallback pair；协调器存在时
+  // 批执行与注册统一用协调器 pair，协调器消失/替换时再切回 standalone/新 pair。
+  const fallbackBacked = owner === undefined
+  const fallbackPromotion = fallbackBacked
+    ? {
+      main: createEpochPromotion(PROMOTE_EVENTS.either, { includeSubagents: false }),
+      withSubagents: createEpochPromotion(PROMOTE_EVENTS.either, { includeSubagents: true }),
+    }
+    : undefined
+  const standalonePromotion = owner ?? fallbackPromotion
+  let activePromotion = coordinatorPromotion ?? standalonePromotion
+  let prepared = selected.map(source => ({ ...source, promotion: activePromotion }))
+  let feedsPromotion = fallbackBacked && activePromotion === fallbackPromotion
+  // 先验证固定效果的目标并完成 owner 解析；owner 不一致时不能留下 wireLayers 监听。
+  const releaseLayers = options.layers === false ? () => {} : wireLayers(ctx, selected.flatMap(source => source.configs)
+    .filter(config => config.layer !== 'pre-step'), warnOnce, { agent: options.agent })
   const injectedMemo = new Map()
-  const main = createEpochPromotion(PROMOTE_EVENTS.either, { includeSubagents: false })
-  const withSubagents = createEpochPromotion(PROMOTE_EVENTS.either, { includeSubagents: true })
   const observerDisposer = ctx.on('session/event', (session, event) => {
-    main.observe(session, event)
-    withSubagents.observe(session, event)
-    // 独立路径的去重记账：只有宿主真正持久化的注入消息才确认投递（门控剥离的候选不算）。
+    if (feedsPromotion) {
+      activePromotion.main.observe(session, event)
+      activePromotion.withSubagents.observe(session, event)
+    }
     confirmDelivered(injectedMemo, session, event)
   })
-
-  const warnOnce = createWarnOnce(ctx, name)
-  const prepend = options.prepend === true || list.some((config) => config.prepend === true)
-  const promotion = { main, withSubagents }
-  const source = {
-    configs: effectiveList,
-    ruleActions: options.ruleActions ?? [],
-    officialInstructions: options.officialInstructions === true,
+  // shortcut: prepend 只认 options 与 configs；纯 ruleAction 的 pre-step-filter 在无协调器的
+  // standalone 路径拿不到。出现第二个无协调器的 pre-step 消费者时，把「需要最外层」上收到动作语义再统一。
+  const prepend = options.prepend === true || prepared.some(source => source.configs.some(config => config.prepend === true))
+  const registrations = new Map()
+  let active = true
+  const releaseRegistrations = () => {
+    for (const dispose of registrations.values()) {
+      try { dispose() } catch {}
+    }
+    registrations.clear()
   }
-  /** 已交给协调器的注册(仅管理路径非空)。 */
-  let registration = null
-  const releaseRegistration = () => {
-    if (registration === null) return
-    const dispose = registration
-    registration = null
+  const setOwner = (promotion) => {
+    activePromotion = promotion
+    feedsPromotion = fallbackBacked && promotion === fallbackPromotion
+    prepared = selected.map(source => ({ ...source, promotion }))
+  }
+  const registerAll = (target) => {
     try {
-      dispose()
-    } catch {
-      // 协调器自身已释放:忽略。
+      for (const source of prepared) {
+        if (registrations.has(source.sourceId)) throw new TypeError(`prompt-tool: duplicate pre-step sourceId ${source.sourceId}`)
+        registrations.set(source.sourceId, target.registerPreset(source.sourceId, source) ?? (() => {}))
+      }
+    } catch (error) {
+      releaseRegistrations()
+      throw error
     }
   }
-  let active = true
-  /** 释放本执行器：失效来源不再注入，也不再向新协调器重新注册。 */
-  const release = () => {
-    active = false
-    releaseRegistration()
-    injectedMemo.clear()
-  }
-  keepDisposer(ctx, release)
-
-  // 非 pre-step 提示词配置接入各自声明的官方层级通道(system-section /
-  // runtime-context / agent-request / llm-stream / tool-pipeline)。
-  const releaseLayers = options.layers === false ? () => {}
-    : wireLayers(ctx, effectiveList.filter((config) => config.layer !== 'pre-step'), warnOnce)
-
-  // 协调器已在（正常装配顺序：插件先加载、预设后挂载）时立即登记来源；
-  // 迟到/消失由下面的监听器按「先撤旧再启新」处理。
-  let registeredCoordinator = coordinatorOf(ctx)
-  if (registeredCoordinator !== undefined) {
-    registration = registeredCoordinator.registerPreset(ctx, sourceId, source) ?? null
+  let registeredCoordinator = coordinator
+  if (coordinator !== undefined) {
+    try {
+      registerAll(coordinator)
+    } catch (error) {
+      try { observerDisposer() } catch {}
+      releaseLayers()
+      throw error
+    }
   }
-
   const preStepDisposer = ctx.on('agent/pre-step', async (payload, next) => {
-    // waterfall 可已捕获随后被释放的回调；失效来源不得向新协调器重新注册。
     if (!active) return next()
-    const coordinator = coordinatorOf(ctx)
-    // HMR 可在相邻两步之间替换服务：旧句柄非空不代表仍向当前实例注册。
-    if (coordinator !== registeredCoordinator) {
-      releaseRegistration()
-      if (coordinator === undefined) {
+    const current = coordinatorOf(ctx)
+    if (current !== registeredCoordinator) {
+      releaseRegistrations()
+      if (current === undefined) {
         warnOnce(`${name}: pre-step coordinator unavailable, resuming standalone execution`)
+        setOwner(standalonePromotion)
+      } else {
+        if (current.promotion === undefined) {
+          warnOnce(`${name}: pre-step coordinator v2 owner unavailable, keeping standalone execution`)
+          setOwner(standalonePromotion)
+        } else {
+          setOwner(current.promotion)
+        }
       }
-      registeredCoordinator = coordinator
+      registeredCoordinator = current
     }
-    if (coordinator !== undefined) {
-      // 管理路径:先登记本来源,再交出唯一执行权(本监听器不再注入)。
-      if (registration === null) registration = coordinator.registerPreset(ctx, sourceId, source) ?? null
+    if (current !== undefined && current.promotion !== undefined) {
+      if (registrations.size === 0) registerAll(current)
       return next()
     }
     const decision = await next()
     if (!active) return decision
     return runPreStepBatch({
+      sources: prepared,
       ctx,
       payload,
       agent: payload?.agent,
       decision,
-      configs: effectiveList,
-      ruleActions: source.ruleActions,
-      promotion,
       memo: injectedMemo,
       warnOnce,
     })
   }, { prepend })
-  // 释放边界：先摘监听器，再撤层级注册，最后丢弃去重快路径（顺序与 keepDisposer 内的 release 一致）。
+  const release = () => {
+    active = false
+    releaseRegistrations()
+    injectedMemo.clear()
+  }
+  keepDisposer(ctx, release)
   return () => {
     release()
-    try {
-      preStepDisposer()
-    } catch {
-      // 宿主已释放该 fiber 时监听器可能已不在：忽略。
-    }
-    try {
-      observerDisposer()
-    } catch {
-      // 同上。
-    }
+    try { preStepDisposer() } catch {}
+    try { observerDisposer() } catch {}
     releaseLayers()
   }
 }