dsh-plugin-prompt-tool 2.1.0 → 3.0.1

package/engine/compaction-epoch.mjs

@@ -11,6 +11,7 @@
  * `assistant/message`, per the caller's `promoteEvents`) recorded AFTER the
  * last successful `compaction/end` boundary counts as promoted. Before any compaction
  * the boundary is -1, which preserves the original one-shot semantics.
+ * 重置判据看事件不看代次；理由与失效条件见 `isSuccessfulCompactionEnd`。
  *
  * State is memoized per session id and maintained incrementally through
  * `observe()`; a cold session scans its durable log once (so resume and
@@ -32,7 +33,8 @@
  * Non-gate mode keeps the original event-set semantics byte-for-byte.
  */
 
-import { sessionEvents, sessionState } from './shared.mjs'
+import { sessionState } from './shared.mjs'
+import { historyEvents } from './history.mjs'
 
 /** 匹配内容与大小写均由调用方显式声明；空 pattern 不承担任何业务识别。 */
 function reasoningClassifier(options = {}) {
@@ -69,7 +71,21 @@ function firstReasoningMatches(content, classify) {
 
 export function hasAnchoredReasoning(content, options = {}) { return firstReasoningMatches(content, reasoningClassifier(options)) }
 
-/** True only when compaction completed and changed the model-visible surface. */
+/**
+ * True only when compaction completed and changed the model-visible surface.
+ *
+ * 判据刻意是**事件维**（成功 `compaction/end`），不是 surface 的 `replaceGeneration` 代次：
+ * 宿主对「一次已提交的位置替换」只给单调计数（`packages/core/session/src/surface.ts:569-572`），
+ * 不说是哪一种，也不给边界。于是代次判据有三处改语义：① 非压缩的 replace（区域编辑 / 手动裁剪 /
+ * 含 `surfaceOp: { op: 'replace' }` 的插件重写）同样推进代次，门控会被误重置；② 轮询只能得到
+ * 一个整数，定不出边界给 `applyEvent` 的 `seq <= boundary` 守卫，压缩替身落地**之前**的事件会被
+ * 当成新 epoch 的事件重新晋升（5b）；③ 无 surface / 无代次（恢复、重放、其它宿主、既有桩）时
+ * 代次恒 undefined，压缩重置永不触发。压缩的**权威判定**因此还得看事件：宿主只在压缩时写
+ * 无 `error` 的 `compaction/end`，而成功压缩必然伴随一次 replace。
+ * shortcut: 近似而非权威 —— 失效条件：既不写 `compaction/end`、又靠 replace 重写可见上下文，
+ * 或写了成功 `compaction/end` 却没改变可见上下文时，该重置误触发/漏触发。宿主给出「这次 replace
+ * 是否压缩 + 边界 seq」的显式信号时改用它。
+ */
 export function isSuccessfulCompactionEnd(event) {
   return event?.type === 'compaction/end' && event.data?.error === undefined
 }
@@ -142,10 +158,17 @@ export function createEpochPromotion(promoteEvents, options = {}) {
     return entry
   }
 
-  /** Scan a session's durable log from scratch (cold start / resume). */
+  /**
+   * Scan a session's durable log from scratch (cold start / resume).
+   *
+   * 判据来源**刻意是完整历史**（`historyEvents`，不是 `currentEvents`）：语义是「本会话在最后
+   * 一次成功压缩之后**曾经** tool/call 过」——状态性的历史事实。压缩前的信号在 surface 上已
+   * 不可见，按当前上下文冷启动会把 `promoted` 错判为 false，门控重回 bootstrap/锚定阶段、
+   * 工具目录被裁剪。
+   */
   const scan = (session) => {
     let entry = freshEntry(-1)
-    for (const event of sessionEvents(session)) entry = applyEvent(entry, event)
+    for (const event of historyEvents(session)) entry = applyEvent(entry, event)
     state.set(session, entry)
     return entry
   }

package/engine/compositions/source/local/filesystem-editor.yml

@@ -5,11 +5,11 @@
 #
 # 能力提供者边界（T4 文件归属校正）：本行行下的 str-replace-editor 是**官方实现**
 # —— `@deepseek-ai/dsh-tool-str-replace-editor`（官方包，配置声明与注册都在包内），
-# 本仓库**没有**对应的 .mjs。它连同 subagent-tool-policy、tool-config-engine 一起
-# 构成 PLAN T4 的三个能力提供者，三者都不接入 engine/trigger.mjs。
+# 本仓库**没有**对应的 .mjs。它连同 tool-config-engine 一起构成 PLAN T4 的两个
+# 能力提供者，两者都不接入 engine/trigger.mjs。
 # 判据：会给模型提供可调用能力（注册工具/域）的 → 能力提供者；干预流程
 # （改提示词、改装配、裁决、追加）的 → 声明式触发器。
-# 注意 engine/tool-git-bash.mjs 提供的是 `bash` 工具，**不是**这第三个提供者。
+# 注意 engine/tool-git-bash.mjs 提供的是 `bash` 工具，**不是**第二个提供者。
 
 # The bare local filesystem shadows the host's sandboxed provider only for this
 # preset. The editor shares that realm and requires absolute paths.

package/engine/compositions/source/local/instruction-hint.yml

@@ -9,10 +9,8 @@
 # 四个模板必须随行给全（2026-10-05 修）：`instruction-hint.mjs#apply` 的首行是
 #   `if (!enabled || templateOf(source, 'messageTemplate').trim().length === 0) return`
 # 而本行此前只配了 enabled/promoteOn/includeSubagents —— 于是把开关打开**不注册任何
-# 转换**：配置合法、零效果、零报错（与 count.delegated 的静默失效同类）。模板正文取自
-# templates/policies/legacy-defaults.yml#instructionHint，与 rules-migration.ts:102
-# 的迁移默认值同源；两处必须一致，否则「迁移进来的定义」与「新装的组合源」行为分叉。
-# legacy-defaults.yml 自身标注「引擎运行时不得读取」，所以这里必须是实体而非引用。
+# 转换**：配置合法、零效果、零报错（与 count.delegated 的静默失效同类）。四个模板的正文
+# 是本行自己的实体数据；旧业务默认值快照（legacy-defaults.yml）已随旧兼容移除。
 #
 # includeSubagents: true —— 子代理首次请求即视为已晋升（官方相位语义），所以子代理
 # 从第 1 轮就拿提示而非全文。主会话则是首个工具调用/助手消息之后才降级（promoteOn）。

package/engine/compositions/source/local/module-file-tools.yml

@@ -0,0 +1,2 @@
+- id: module-file-tools
+  name: ./engine/module-file-tools.mjs

package/engine/compositions/source/local/module-import-tools.yml

@@ -0,0 +1,4 @@
+# module: module-import-tools
+
+- id: module-import-tools
+  name: ./engine/module-import-tools.mjs

package/engine/compositions/source/local/module-manifest-tools.yml

@@ -0,0 +1,2 @@
+- id: module-manifest-tools
+  name: ./engine/module-manifest-tools.mjs

package/engine/compositions/source/local/module-rule-tools.yml

@@ -0,0 +1,5 @@
+# module: module-rule-tools
+# source: engine/compositions/source/local/module-rule-tools.yml
+
+- id: module-rule-tools
+  name: ./engine/module-rule-tools.mjs

package/engine/compositions/source/local/module-variable-tools.yml

@@ -0,0 +1,5 @@
+# module: module-variable-tools
+# source: engine/compositions/source/local/module-variable-tools.yml
+
+- id: module-variable-tools
+  name: ./engine/module-variable-tools.mjs

package/engine/compositions/source/local/present-as.yml

@@ -0,0 +1,26 @@
+# module: present-as
+# source: engine/compositions/source/local/present-as.yml (本地附加,非官方模块)
+# 让本模块覆盖的 Agent 以 `config.mode` 指定的形态呈现工具（官方 `ctx.tools.presentAs`）：
+# `ptc` 时注册表只贡献保留的 `run_code` 传输与生成的 SDK 段，其余可见能力由程序内绑定
+# （`tools.xxx()`）调用。
+#
+# **行名必须与引擎模块文件同名**：agent-assembly 按 `engine/<行 id>.mjs` 找实现
+# （src/runtime/agent-assembly.ts:186-188 的 engineModuleFile），找不到就**静默跳过这一行**
+# ——官方组合行没有 engine 文件属正常（由会话原有预设提供），所以这条跳过不告警；写错名字
+# 的后果是「行装了等于没装」而毫无提示。本文件因此叫 present-as.yml + id: present-as，
+# 与 engine/present-as.mjs 对齐。
+#
+# 为什么不用官方 `@deepseek-ai/dsh-agent-tool-presentation` 行：这是插件自己的实现
+# （engine/present-as.mjs 调的是同一个 `presentAs`），模块可经 `modules:` 声明它，因此
+# **不需要在预设侧再挂官方行**，也不需要动 `cordis.patch.yml`（那条只用于进程级默认呈现）。
+# 两者落在不同 scope——本行 = Agent scope、官方行 = 预设常驻 scope，`modeFor` 最近者优先；
+# 而**同一 scope 二次声明会被官方拒绝**（挂载期 fail loud，不静默覆盖）。
+#
+# 前置：`mode: ptc` 需要 `ctx.ptcRuntime`（宿主 base bundle 的 `ptc-runtime` 行提供）。缺它时
+# 本行停在 pending，由预设注册表指名报告不可用的行——不静默退回 native。
+
+- id: present-as
+  name: ./engine/present-as.mjs
+  config:
+    enabled: true
+    mode: ptc

package/engine/compositions/source/local/tool-config-engine.yml

@@ -6,9 +6,8 @@
 # 能力提供者边界（T4）：本行是**能力提供者**（把预设声明的自定义工具注册进官方
 # registry），**不接入** engine/trigger.mjs。判据：会给模型提供可调用能力
 # （注册工具/域）的 → 能力提供者；干预流程（改提示词、改装配、裁决、追加）的 →
-# 声明式触发器。登记数据在 engine/tool-config-engine.mjs 的 `engineProvider` 导出
-# （provides.kind = 'dynamic'：工具名在装配期才由 customTools 段决定），与
-# `engineTriggers`（声明式触发器）互斥；守卫见 test/engine/provider-boundary.test.mjs。
+# 声明式触发器。模型可见的工具名在装配期由 module.yml 的 customTools 段决定，
+# 引擎侧无法静态枚举。
 # 模块内 approvalGate 与 withinCwd 是安全边界，改装配方式时不得放宽。
 
 - id: tool-config-engine

package/engine/compositions/source/local/tool-search.yml

@@ -0,0 +1,11 @@
+# module: tool-search
+# source: engine/compositions/source/local/tool-search.yml (本地附加,非官方模块)
+#
+# 工具面的按需发现与解锁。与 assembly 动作的 allowFrom 配对使用：
+#   本工具把解锁名写进持久调用参数（tool/call；PTC 嵌套为 tool/ptc-dispatch）→ allowExtra 读回 → 下次请求起生效。
+# 只挂本行而不配 allowFrom 的话，解锁是一次性的（当次请求用完即被裁掉）。
+#
+# 常驻集由模板声明（见 templates/ 的工具面收窄模板），本行只负责发现入口。
+
+- id: tool-search
+  name: ./engine/tool-search.mjs

package/engine/condition-facts.mjs

@@ -0,0 +1,84 @@
+/**
+ * condition-facts — live 规则条件的文本事实提取（if.text.subject / if.anchor.subject）。
+ *
+ * 声明式 `config.subject` / `config.match` 执行链已退役；这里只保留：
+ *   - subject → 载荷文本字段的映射（conditions/subject 与 availability 共用）；
+ *   - 真实对话消息判据与 pre-step / turn-stop / 子代理事件的文本提取。
+ * 条件判定本身归 conditions/*；本模块不做命中判断、不预编译匹配器。
+ */
+
+import { currentEvents } from './history.mjs'
+import { extractText } from './shared.mjs'
+
+/** 按 subject 取参与匹配的文本；live 条件 conditions/text 消费。 */
+export function subjectTextOf(subject, payload) {
+  if (payload === undefined || payload === null) return ''
+  const field = SUBJECT_FIELDS[subject]
+  return field !== undefined && typeof payload[field] === 'string' ? payload[field] : ''
+}
+
+/** subject → 载荷字段名。改这里等于改所有层的匹配对象。 */
+export const SUBJECT_FIELDS = {
+  toolArgs: 'argsText',
+  toolResult: 'resultText',
+  userMessage: 'userText',
+  assistantText: 'assistantText',
+  subagentInfo: 'subagentText',
+}
+
+/** 工具参数的可匹配文本：对象按 JSON 序列化，字符串原样；序列化失败按空串。 */
+export function toolArgsText(args) {
+  if (typeof args === 'string') return args
+  try {
+    return JSON.stringify(args ?? {})
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * 「真实对话消息」的唯一判据（角色过滤由消费方各自保留）。
+ *
+ * 引擎自己注入的消息同样是 user-role（`executor.mjs` 的 `role: PRE_STEP_ROLE`、
+ * `pluginMessage` 的 `source` 是 `plugin:<name>` 生产者身份），把它们算进来会让
+ * `text.match` / 关键词世界书匹配到自己注入过的正文——正文里出现「重构」「实现」
+ * 这类词就会自我命中，且命中判定在去重之前，`dedupe` 挡不住。
+ * `userMessagesText`、原生关键词世界书的扫描 haystack 与
+ * `context-activation.mjs#conversationMessages` 共用这一份，不再各写各的。
+ */
+export function isConversationMessage(message) {
+  if (message === null || typeof message !== 'object') return false
+  if (message.source?.plugin !== undefined) return false
+  return message.source?.kind === undefined || message.source.kind === 'user'
+}
+
+/**
+ * pre-step 的缺省匹配对象：本批**真实对话**的用户消息文本（判据见
+ * {@link isConversationMessage}）。
+ */
+export function userMessagesText(messages) {
+  if (!Array.isArray(messages)) return ''
+  return messages
+    .filter((message) => message?.role === 'user' && isConversationMessage(message))
+    .map((message) => extractText(message))
+    .filter((text) => text.length > 0)
+    .join('\n')
+}
+
+/** 最后一条 assistant 消息的文本（turn-stop 的缺省匹配对象）；取**当前上下文**里可见的那条。 */
+export function lastAssistantText(session) {
+  const events = currentEvents(session)
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    if (events[index]?.type === 'assistant/message') return extractText(events[index].data)
+  }
+  return ''
+}
+
+/** 子代理事件的匹配文本：事件载荷序列化，取不到即空串。 */
+export function subagentTextOf(info) {
+  try {
+    return JSON.stringify(info ?? {})
+  } catch {
+    return ''
+  }
+}

package/engine/conditions/anchor.mjs

@@ -1,31 +1,71 @@
-import { createAnchorMatcher } from '../anchor-match.mjs'
-import { sessionEvents, sessionState } from '../shared.mjs'
+import { MATCH_LOGIC, createAnchorMatcher } from '../anchor-match.mjs'
+import { findActionDelivery, visibleMessages } from '../delivery.mjs'
 import { sessionOf } from './subject.mjs'
-import { boundOf, keyList } from './values.mjs'
+import { keyList, optionalBoolean } from './values.mjs'
+import { UNAVAILABLE } from './availability.mjs'
 
-/** 首条 assistant reasoning 的确认事实；未到达时不缓存，无 id 会话不共享状态。 */
-export function createAnchorState(options = {}) {
-  const matcher = createAnchorMatcher({ keys: keyList(options.keys, 'anchor.keys'), mode: 'prefix' })
-  const confirmedBySession = sessionState(undefined, () => false)
-  return session => {
-    const assistants = sessionEvents(session).filter(event => event.type === 'assistant/message')
-    let confirmed = confirmedBySession.peek(session)
-    if (confirmed === undefined && assistants.length > 0) {
-      const reasoning = (assistants[0].data?.message?.content ?? []).find(block => block.type === 'reasoning')
-      confirmed = reasoning !== undefined && matcher.scan(String(reasoning.text ?? '')).active
-      confirmedBySession.set(session, confirmed)
-    }
-    return { confirmed: confirmed === true, assistantRounds: assistants.length }
-  }
+const SUBJECTS = ['userMessage', 'assistantReasoning', 'assistantText', 'toolResult']
+const FIELDS = new Set(['subject', 'keys', 'secondaryKeys', 'caseSensitive', 'wholeWords', 'useRegex', 'logic', 'mode', 'wordBoundary', 'fallbackAfter', 'after'])
+
+/** 按所选来源取正文；缺少该来源的内容块不算一次相应输出。 */
+function outputText(subject, event, message) {
+  if (subject === 'userMessage') {
+    if (event.type !== 'user/message' || message.role !== 'user' || message.source?.kind !== 'user' || message.source?.plugin !== undefined) return undefined
+  } else if (subject === 'toolResult') {
+    if (event.type !== 'tool/result') return undefined
+  } else if (event.type !== 'assistant/message' || event.data?.interrupted === true) return undefined
+  const type = subject === 'assistantReasoning' ? 'reasoning' : 'text'
+  const blocks = (Array.isArray(message.content) ? message.content : []).filter(block => block?.type === type)
+  return blocks.length === 0 ? undefined : blocks.map(block => typeof block.text === 'string' ? block.text : '').join('\n')
 }
 
-/** 确认即命中；可选 fallbackAfter 表示超过指定 assistant 消息数后也允许。 */
-export function createAnchorPredicate(options = {}) {
-  const inspect = createAnchorState(options)
-  const fallbackAfter = boundOf(options.fallbackAfter, 'anchor.fallbackAfter')
+/** 从当前可见、已结算消息重建确认；关联只从目标实际投递的日志序号之后开始。 */
+export function createAnchorPredicate(options = {}, context = {}) {
+  for (const key of Object.keys(options)) if (!FIELDS.has(key)) throw new TypeError(`anchor: unknown field ${key}`)
+  const subject = options.subject ?? 'assistantReasoning'
+  if (!SUBJECTS.includes(subject)) throw new TypeError(`anchor.subject must be one of ${SUBJECTS.join(', ')}`)
+  const mode = options.mode ?? 'prefix'
+  if (!['prefix', 'scan'].includes(mode)) throw new TypeError('anchor.mode must be prefix or scan')
+  if (mode === 'prefix' && ['secondaryKeys', 'caseSensitive', 'wholeWords', 'useRegex', 'logic', 'wordBoundary'].some(key => options[key] !== undefined)) {
+    throw new TypeError('anchor prefix matches literal keys only; use scan for other matching options')
+  }
+  if (options.logic !== undefined && !Object.values(MATCH_LOGIC).includes(options.logic)) throw new TypeError('anchor.logic is invalid')
+  const fallbackAfter = options.fallbackAfter
+  if (fallbackAfter !== undefined && (!Number.isSafeInteger(fallbackAfter) || fallbackAfter <= 0)) throw new TypeError('anchor.fallbackAfter must be a positive integer')
+  if (options.after !== undefined && (options.after === null || typeof options.after !== 'object' || Array.isArray(options.after)
+    || Object.keys(options.after).some(key => key !== 'action') || typeof options.after.action !== 'string' || options.after.action.trim().length === 0)) {
+    throw new TypeError('anchor.after must be { action: non-empty string }')
+  }
+  const matcher = createAnchorMatcher({
+    keys: keyList(options.keys, 'anchor.keys'),
+    secondaryKeys: keyList(options.secondaryKeys, 'anchor.secondaryKeys'),
+    caseSensitive: optionalBoolean(options.caseSensitive, 'anchor.caseSensitive', false),
+    wholeWords: optionalBoolean(options.wholeWords, 'anchor.wholeWords', false),
+    useRegex: optionalBoolean(options.useRegex, 'anchor.useRegex', undefined),
+    logic: options.logic,
+    wordBoundary: options.wordBoundary,
+    mode,
+  })
   const predicate = payload => {
-    const status = inspect(sessionOf(payload))
-    return status.confirmed || (fallbackAfter !== undefined && status.assistantRounds > fallbackAfter)
+    const session = sessionOf(payload)
+    if (typeof session?.snapshotEvents !== 'function') return UNAVAILABLE
+    const messages = visibleMessages(session)
+    let start
+    if (options.after !== undefined) {
+      const target = context.resolveAction?.(options.after.action)
+      if (target === undefined) return UNAVAILABLE
+      start = findActionDelivery(session, target, messages)
+      if (start === undefined) return UNAVAILABLE
+    }
+    let outputs = 0
+    for (const { event, seq, message } of messages) {
+      if (start !== undefined && seq <= start.seq) continue
+      const text = outputText(subject, event, message)
+      if (text === undefined) continue
+      if (matcher.scan(text).active) return true
+      if (fallbackAfter !== undefined && ++outputs >= fallbackAfter) return true
+    }
+    return false
   }
   predicate.kind = 'anchor'
   return predicate

package/engine/conditions/availability.mjs

@@ -1,5 +1,5 @@
 import { agentOf, sessionOf } from './subject.mjs'
-import { SUBJECT_FIELDS } from '../condition.mjs'
+import { SUBJECT_FIELDS } from '../condition-facts.mjs'
 
 /** 缺少真实事件事实不是 false；尤其不能经 not 反转成允许。 */
 export const UNAVAILABLE = Symbol('condition-input-unavailable')

package/engine/conditions/composite.mjs

@@ -1,6 +1,6 @@
 import { MATCH_LOGIC } from '../anchor-match.mjs'
 import { UNAVAILABLE } from './availability.mjs'
-const COMPOSITE_OPERATORS = Object.values(MATCH_LOGIC)
+import { COMPOSITE_OPERATORS } from './operators.mjs'
 
 export function composite(node) {
   if (typeof node === 'function') return node
@@ -69,10 +69,10 @@ export function composite(node) {
   predicate.kind = 'composite'
   // 组合层必须**转发子谓词的 observe**（B7 T1 的跨能力缺口修复）：两条挂载路径的观察器
   // 接线都按 `when.observe` 过滤（`trigger.mjs` 的 `wireTriggerObservers`），被组合包住的
-  // phase / count / session 谓词否则永远收不到活的 `session/event`——状态按 `session.id`
+  // phase / count 谓词否则永远收不到活的 `session/event`——状态按 `session.id`
   // 缓存后不再重扫（`shared.mjs` 的 `sessionState`），判定会停在冷扫那一刻（计数恒旧值、
   // 相位永不晋升）。`phase` 有 `subscribe: false` 可绕（代价是每次判定冷扫），
-  // `count` / `session` 没有该档，所以这条转发是它们唯一的活路。
+  // `count` 没有该档，所以这条转发是它唯一的活路。
   const observers = children.filter((child) => typeof child.observe === 'function')
   if (observers.length > 0) {
     predicate.observe = (session, event) => {

package/engine/conditions/count.mjs

@@ -1,4 +1,6 @@
-import { MAX_TRACKED_SESSIONS, extractText, isDelegated, sessionEvents } from '../shared.mjs'
+import { MAX_TRACKED_SESSIONS, extractText, isDelegated } from '../shared.mjs'
+import { SURFACE_MESSAGE_TYPES, currentEvents, historyEvents, viewRestricted } from '../history.mjs'
+import { isSuccessfulCompactionEnd } from '../compaction-epoch.mjs'
 import { sessionOf } from './subject.mjs'
 import { boundOf, optionalBoolean } from './values.mjs'
 
@@ -20,12 +22,18 @@ const TURN_EVENT = 'turn/start'
 /**
  * 计数判断：次数 / 字符数 / 轮次，带上下限与**冷启动重建**。
  *
- *  - `per: 'session'` 计整个 durable log；`per: 'turn'` 只计**最新轮**，当前轮由
+ *  - `per: 'session'` 计本会话全部（视图口径见下条）；`per: 'turn'` 只计**最新轮**，当前轮由
  *    `turn/start` 与计数信号自身带轮号的事件共同推进（与 deliberation-gate 的
  *    `turnOf` 同规则），轮号取自 `event.data.turn`；无轮号的事件不参与轮内计数
- *    （宁可少计，也不把跨轮数据算进当前轮）。
- *  - 冷启动：首次判定冷扫 `sessionEvents(session)` 重建（重启/恢复/重挂后同一结果），
- *    之后 O(1)；`observe` 是增量喂入，**只喂已判定过的会话**，避免「冷扫 + 增量」重复计数。
+ *    （宁可少计，也不把跨轮数据算进当前轮）。消息类信号读当前上下文时看不到 `turn/start`，
+ *    当前轮只由带轮号的可见信号推进。
+ *  - 视图：消息类信号读**当前上下文**——被压缩 / 位置替换遮蔽的消息不再计入；`tool/call` 与
+ *    `turn/start` 不是 surface 承载类型，读**完整历史**，「重启/恢复/重挂后同一结果」由此保住。
+ *  - 冷启动：首次判定冷扫重建（重启/恢复/重挂后同一结果），之后 O(1)；`observe` 是增量喂入，
+ *    **只喂已判定过的会话**，避免「冷扫 + 增量」重复计数。成功压缩或 surface 代次推进时条目
+ *    整体作废、下次求值重建——这条复位只对**消息类**信号生效（它读可见上下文），log-only
+ *    信号重建读完整历史、压缩不改变它；压缩后 `every: N` 的节奏随之重置，可能立刻再命中一次
+ *    （已接受的用户可见行为，见 CHANGELOG）。
  *  - 上下限：`count >= min`（声明时）且 `count <= max`（声明时）。至少要声明一侧，
  *    否则该判定恒真——那是把配置错误伪装成命中。
  *  - 取不到会话 = 无事件 = 计数 0（与空会话同一语义，不发明数据）；无 `id` 的会话
@@ -73,9 +81,12 @@ export function createCountPredicate(options = {}) {
   // **主判据就是 count**，受众不能只挂在 `session` 谓词上——那会迫使声明额外耦合一个
   // durable 事件类型（还要回答「哪种 type 恒真」，而哨兵轮表明甚至可能没有轮事件）。
   const delegated = optionalBoolean(options.delegated, 'delegated', undefined)
-  /** sessionId -> { total, turns, lastTurn }（进程内快路径，真相在 durable 事件流）。 */
+  /** sessionId -> { total, turns, lastTurn, generation }（进程内快路径，真相在 durable 事件流）。 */
   const state = new Map()
-  const fresh = () => ({ total: 0, turns: new Map(), lastTurn: undefined })
+  const fresh = (generation) => ({ total: 0, turns: new Map(), lastTurn: undefined, generation })
+  const generationOf = (session) => session?.surface?.replaceGeneration
+  /** 消息类信号按当前上下文计，log-only 信号按完整历史计（判据见 `SURFACE_MESSAGE_TYPES`）。 */
+  const view = SURFACE_MESSAGE_TYPES.has(signal.type) ? currentEvents : historyEvents
   const measure = (event) => (signal.measure === 'chars' ? extractText(event.data).length : 1)
   /** 轮号推进：与 deliberation-gate 的 turnOf/turnEntryOf 同规则——`turn/start` 与
    *  计数信号自身带轮号的事件都推进当前轮，且取最大值；新轮先落 0，再累加。 */
@@ -111,14 +122,24 @@ export function createCountPredicate(options = {}) {
     ? entry.total
     : (entry.lastTurn === undefined ? 0 : entry.turns.get(entry.lastTurn) ?? 0))
   const rebuild = (session) => {
-    const entry = fresh()
-    for (const event of sessionEvents(session)) applyEvent(entry, event)
+    const entry = fresh(generationOf(session))
+    // 位置替换后同一事件可在 `surface.nodes` 里占多个位置（`history.mjs` 头部）：按条数直数会虚高，
+    // `every: N` 提前触发。增量 `observe` 一次只收一条新事件，无需去重。
+    const seen = new Set()
+    for (const event of view(session)) {
+      if (event?.seq !== undefined) {
+        if (seen.has(event.seq)) continue
+        seen.add(event.seq)
+      }
+      applyEvent(entry, event)
+    }
     return entry
   }
   const entryOf = (session) => {
     if (session?.id === undefined) return rebuild(session)
     const known = state.get(session.id)
-    if (known !== undefined) return known
+    // 位置替换没有对应的 durable 事件可观察，只在 surface 代次上前进：代次变了就按当前上下文重建。
+    if (known !== undefined && known.generation === generationOf(session)) return known
     const entry = rebuild(session)
     if (state.size >= MAX_TRACKED_SESSIONS) state.clear()
     state.set(session.id, entry)
@@ -132,7 +153,17 @@ export function createCountPredicate(options = {}) {
   }
   predicate.kind = 'count'
   predicate.observe = (session, event) => {
-    const entry = session?.id === undefined ? undefined : state.get(session.id)
+    if (session?.id === undefined) return
+    // 失效条件必须与它读的视图一致：只有消息类信号按可见上下文计数，压缩复位对
+    // log-only 信号（重建读 `historyEvents`）不改变任何结果，白白触发一次重建。
+    const flagged = SURFACE_MESSAGE_TYPES.has(signal.type)
+    // 成功压缩换掉了可见历史，而条目按**全部** durable 事件累加过（含被遮蔽的），无法反演
+    // → 整体清条目、下次求值重建（宿主没暴露 `replaceGeneration` 时这是唯一的复位信号）。
+    if (flagged && isSuccessfulCompactionEnd(event)) { state.delete(session.id); return }
+    // 视图受限时重建路径读 `currentEvents`，那里没有 `turn/start` 这类 log-only 事件；
+    // 增量若照单全收就会靠它推进当前轮，同一会话两种结论（「冷启动 == 增量」失效）。
+    if (flagged && viewRestricted(session) && !SURFACE_MESSAGE_TYPES.has(event?.type)) return
+    const entry = state.get(session.id)
     if (entry !== undefined) applyEvent(entry, event)
   }
   return predicate

package/engine/conditions/evaluation.mjs

@@ -1,24 +1,59 @@
 import { subjectOf } from './subject.mjs'
+import { UNAVAILABLE } from './availability.mjs'
 
 /**
  * 一次官方调用的局部判定帧；不按 session、turn 或载荷身份缓存。
- * `ctx` 是判定期服务入口：子代理事件靠它用 `id` 反查 agent（见 subject.mjs 的
- * `subagentFacts`），使 `modelScope`/`audience` 在判定阶段就有事实可用。
+ * `ctx` 是判定期服务入口：子代理事件靠它用 `id` 反查 agent（见 `subject.mjs` 的通道事实表
+ * `CHANNELS`），使 `modelScope`/`audience` 在判定阶段就有事实可用。
+ * `onOutcome` 是可选只读上报（规则、通道、判定类别），供宿主统计「配了没生效」；
+ * 缺省不传即零开销，也不改变任何判定结果。
  */
-export function ruleFrame(channel, args, warnOnce = () => {}, ctx) {
-  return { channel, args, subject: subjectOf(channel, args, warnOnce, ctx), decisions: new Map(), warnOnce }
+export function ruleFrame(channel, args, warnOnce = () => {}, ctx, onOutcome) {
+  return { channel, args, subject: subjectOf(channel, args, warnOnce, ctx), decisions: new Map(), actionDecisions: new Set(), warnOnce, onOutcome }
 }
 
-export function ruleMatches(rule, frame) {
-  if (rule === undefined) return true
-  if (frame.decisions.has(rule)) return frame.decisions.get(rule)
+/** 条件返回值的三值归一：词表与 bridge 的 `RuleOutcomeKind` 共享，故只此一处定义。 */
+function classifyOutcome(decided) {
+  return decided === true ? 'hit' : decided === UNAVAILABLE ? 'unavailable' : 'miss'
+}
+
+/** 只读上报：诊断抛错不得反过来打断判定（调用方可能在记账里访问规则身份）。 */
+function report(frame, rule, outcome) {
+  try { frame.onOutcome?.(rule, frame.channel, outcome) } catch { /* 诊断不得反过来打断判定 */ }
+}
+
+/** 单次规则级判定（帧内缓存，键为规则实例）：三值语义见下；只判定、不上报。 */
+function decideRule(rule, frame) {
+  if (rule === undefined) return { hit: true, outcome: 'hit' }
+  const cached = frame.decisions.get(rule)
+  if (cached !== undefined) return cached
   let hit = rule.enabled !== false
+  let outcome = hit ? 'hit' : 'disabled'
   if (hit && typeof rule.when === 'function') {
-    try { hit = rule.when(frame.subject) === true }
-    catch (error) { hit = false; frame.warnOnce(`rule ${rule.id} condition failed: ${String(error?.message ?? error)}`) }
+    try {
+      const decided = rule.when(frame.subject)
+      hit = decided === true
+      // 三值语义：缺事实（UNAVAILABLE）与「条件为假」在诊断里必须分开——前者是
+      // 「为什么没触发」的答案，后者是条件按设计不满足。
+      outcome = classifyOutcome(decided)
+    } catch (error) {
+      hit = false
+      outcome = 'error'
+      frame.warnOnce(`rule ${rule.id} condition failed: ${String(error?.message ?? error)}`)
+    }
   }
-  frame.decisions.set(rule, hit)
-  return hit
+  const decided = { hit, outcome }
+  frame.decisions.set(rule, decided)
+  return decided
+}
+
+export function ruleMatches(rule, frame) {
+  if (rule === undefined) return true
+  const cached = frame.decisions.get(rule)
+  if (cached !== undefined) return cached.hit
+  const decided = decideRule(rule, frame)
+  report(frame, rule, decided.outcome)
+  return decided.hit
 }
 
 /**
@@ -27,15 +62,35 @@ export function ruleMatches(rule, frame) {
  * `bypassRuleWhen` 的动作来自规则级 `else`——它的条件里已经含 `not(if)`，再叠加
  * `rule.when` 会自相矛盾、令该分支永不执行。动作条件缺省 = 恒真；非 `true`
  * （含 UNAVAILABLE 三值语义）一律不命中，与 `ruleMatches` 同一纪律。
+ *
+ * 上报（方案 A：不加 actionId 维度）：带动作级分支的动作上报「规则∧动作」的**最终**
+ * 判定，按帧对每个动作实例去重一次——分支为真记 `hit`、为假记 `miss`、缺事实记
+ * `unavailable`、异常记 `error`；这类动作不再单独发规则级上报，避免同一事件先记
+ * `hit` 再记 `miss`。没有分支的动作最终判定就是规则级判定，沿用规则级上报。
  */
 export function actionMatches(entry, frame) {
-  if (entry.bypassRuleWhen !== true && !ruleMatches(entry.rule, frame)) return false
-  const when = entry.actionWhen
-  if (when === undefined) return true
-  try {
-    return when(frame.subject) === true
-  } catch (error) {
-    frame.warnOnce(`action ${entry.id} condition failed: ${String(error?.message ?? error)}`)
-    return false
+  const branched = entry.actionWhen !== undefined || entry.bypassRuleWhen === true
+  if (!branched) return ruleMatches(entry.rule, frame)
+  // `else`（bypassRuleWhen）自带 not(if)，不叠加规则级判定；其余带分支的动作自判
+  // 规则级（不发上报），判定仍走同一份帧内缓存，同帧同规则依旧只判一次。
+  const ruled = entry.bypassRuleWhen === true ? { hit: true, outcome: 'hit' } : decideRule(entry.rule, frame)
+  let hit = ruled.hit
+  let outcome = ruled.outcome
+  if (hit) {
+    try {
+      const decided = entry.actionWhen === undefined ? true : entry.actionWhen(frame.subject)
+      hit = decided === true
+      outcome = classifyOutcome(decided)
+    } catch (error) {
+      hit = false
+      outcome = 'error'
+      frame.warnOnce(`action ${entry.id} condition failed: ${String(error?.message ?? error)}`)
+    }
+  }
+  // 只去重上报，不缓存判定结果：同帧内重复求值仍按当次事实判定。
+  if (!frame.actionDecisions.has(entry)) {
+    frame.actionDecisions.add(entry)
+    report(frame, entry.rule, outcome)
   }
+  return hit
 }

package/engine/conditions/examples.mjs

@@ -7,5 +7,6 @@ export const PREDICATE_EXAMPLES = {
   session: { type: 'user/message', present: false },
   preset: { presetId: 'preset-id' },
   scope: { audience: 'main', modelScope: 'all' },
-  anchor: { keys: ['We'], fallbackAfter: 1 },
+  anchor: { subject: 'assistantReasoning', keys: ['确认'], mode: 'prefix' },
+  variable: { key: 'quota', op: 'lte', value: '0', scope: 'effective' },
 }

package/engine/conditions/index.d.mts

@@ -0,0 +1,15 @@
+/** `conditions/index.mjs` 的手写声明：只声明 `src/` 消费的导出。 */
+
+/** 官方 `standingMountFor` 的挂载事实；仅覆盖插件依赖面（引擎只读 `presetId`）。 */
+export interface StandingMount {
+  presetId?: string
+}
+
+/** 官方 `@deepseek-ai/dsh-agent-preset-registry` 的 `standingMountFor` 导出。 */
+export type StandingMountFor = (ctx: unknown) => StandingMount | undefined
+
+/**
+ * 惰性解析官方 `standingMountFor`：包缺席（最小组合、测试）返回 `undefined`，
+ * 不是错误——此时没有兜底，预设条件判定恒不命中。
+ */
+export function loadStandingMountFor(entry?: string): Promise<StandingMountFor | undefined>