dsh-plugin-prompt-tool 2.0.1 → 3.0.0

package/engine/{dev-tool-search.mjs → tool-search.mjs}

@@ -6,8 +6,9 @@
  *
  * 两个动作合一：
  *  - `query` 关键词搜索**完整装配目录**（只回名字 + 一行截断描述，不回 parameters）；
- *  - `toolNames` 按**精确名**解锁。解锁名写进本次 `tool/call` 的持久参数，
- *    `assembly.target.tools.allowFrom` 从那里读回 → 下次请求起生效，且跨压缩保留。
+ *  - `toolNames` 按**精确名**解锁。解锁名写进本次调用的持久参数（顶层 `tool/call`；
+ *    PTC 嵌套为 `tool/ptc-dispatch`），发现消费方的 allowExtra 从那里读回 → 下次请求起
+ *    生效，且跨压缩保留。
  *
  * **能力摘要来自运行时截获，不手工维护**（2026-10-05 用户指出）：空查询时按前缀把
  * `ctx.tools.schemas()` 的可见目录折叠成分组摘要（`mcp__github__* ×46`，实测 433 字符
@@ -15,17 +16,22 @@
  * 名字写错还会让模型照着错名字解锁（那份实现甚至需要一条专门测试来防错名）。
  * 官方注册表只投影 name/description（无分组字段），所以分组只能按前缀在本地折叠。
  *
- * 与原 `dev-tool-search.mjs` 的两处修正照搬：
+ * 与原 `tool-search.mjs` 的两处修正照搬：
  *  1. 匹配是**打分**而非 AND 过滤——长自然语言查询（"file edit write replace"）在
  *     AND 口径下命中零个，等于白搜。现在精确名优先，其次按命中 token 数排序。
  *  2. 描述里显式教解锁路径（"搜索为空 ≠ 工具不存在"）——实测模型只会搜、不会传
  *     toolNames，于是收窄后永远拿不到工具。
  */
-export const name = 'dev-tool-search'
+export const name = 'tool-search'
 
 /** 工具注册表必须先于本工具存在（同 skill-search 的 inject 纪律）。 */
 export const inject = ['tools']
 
+import { toJsonSchema } from './shared.mjs'
+import { renderRows, rankRows, scoreRows, queryTokens } from './discovery.mjs'
+import { toolScopeSnapshot } from './tool-scope.mjs'
+import { DISCOVERY_SERVICE } from './service-names.mjs'
+
 /** 单次搜索结果上限：再多就该让模型收窄关键词。 */
 export const MAX_RESULTS = 25
 
@@ -36,31 +42,17 @@ const DESC_LIMIT = 90
 const MAX_GROUPS = 24
 
 /** 常驻核心集：由工具面收窄模板声明，这里只在描述里如实告知模型。 */
-const RESIDENT = ['pwsh', 'read', 'write', 'edit', 'glob', 'grep', 'todo_write', 'skill_search', 'skill_load']
-
-/** 零依赖的最小 JSON schema 编译器（与 skill-search 同构）。 */
-function toJsonSchema(spec) {
-  const properties = {}
-  const required = []
-  for (const [key, meta] of Object.entries(spec || {})) {
-    const prop = { type: meta.type }
-    if (meta.description) prop.description = meta.description
-    if (meta.items) prop.items = meta.items
-    properties[key] = prop
-    if (meta.required) required.push(key)
-  }
-  return { type: 'object', properties, required, additionalProperties: false }
-}
+const RESIDENT = ['bash', 'pwsh', 'read', 'write', 'edit', 'glob', 'grep', 'todo_write', 'skill_search', 'skill_load']
+
+/** 参数 schema 由 `shared.mjs` 的统一实现生成（与 `skill-search` 同一份）。 */
 
 /**
- * 能力索引：常驻核心集（pwsh / read / write / edit / glob / grep / todo_write /
+ * 能力索引：常驻核心集（bash / pwsh / read / write / edit / glob / grep / todo_write /
  * skill_search / skill_load）覆盖不到的能力。名字全部取自实测工具面。
  */
 
-/** 把查询切成小写 token（Unicode 字母数字与下划线连字符，与 skill-search 同口径）。 */
-export function queryTokens(query) {
-  return (typeof query === 'string' ? query : '').toLowerCase().split(/[^\p{L}\p{N}_-]+/u).filter(Boolean)
-}
+/** 查询分词由发现引擎统一实现（与技能面同一口径）。 */
+export { queryTokens }
 
 /**
  * 一个工具名的分组键：MCP 工具折到服务级（`mcp__github__*`），其余折到首个下划线段
@@ -102,17 +94,10 @@ export function summarizeCatalog(schemas) {
  * `wanted` 为空时返回空数组——调用方据此区分「没给查询」与「没搜到」。
  */
 export function scoreTools(schemas, wanted) {
-  if (!Array.isArray(schemas) || wanted.length === 0) return []
-  return schemas
-    .map((schema) => {
-      const name = typeof schema?.name === 'string' ? schema.name : ''
-      const haystack = `${name} ${schema?.description ?? ''}`.toLowerCase()
-      let score = 0
-      for (const token of wanted) if (haystack.includes(token)) score += 1
-      return { schema, name, score, exact: wanted.includes(name.toLowerCase()) }
-    })
-    .filter((entry) => entry.name.length > 0 && (entry.exact || entry.score >= 1))
-    .sort((a, b) => (b.exact - a.exact) || (b.score - a.score) || a.name.localeCompare(b.name))
+  return rankRows(scoreRows(schemas, wanted, {
+    nameOf: (schema) => schema?.name,
+    haystackOf: (schema) => `${schema?.name ?? ''} ${schema?.description ?? ''}`,
+  })).map((row) => ({ ...row, schema: row.item }))
 }
 
 /** 解锁名单归一：只留非空字符串，去重保序。 */
@@ -129,46 +114,38 @@ export function unlockNames(value) {
 
 /** 把目录搜索结果渲染成给模型的文本（带截断提示与解锁引导）。 */
 export function renderMatches(scored, query) {
-  const lines = []
-  const matches = scored.slice(0, MAX_RESULTS)
-  if (matches.length === 0) {
-    lines.push(
-      `No tools match "${query}". An empty result only means no tool matched your keywords — if you need a specific tool, unlock it directly by exact name, e.g. dev_tool_search({"toolNames":["web_search"]}).`,
-    )
-    return lines
-  }
-  lines.push(`Matching tools (${matches.length}${scored.length > MAX_RESULTS ? ` of ${scored.length}` : ''}):`)
-  for (const { schema, name, exact } of matches) {
-    const desc = String(schema?.description ?? '').split('\n')[0].slice(0, DESC_LIMIT)
-    lines.push(`- ${name}${exact ? ' (exact)' : ''}: ${desc}`)
-  }
-  if (scored.length > MAX_RESULTS) {
-    lines.push(`(truncated at ${MAX_RESULTS} — add tokens to narrow the query)`)
-  }
-  lines.push('Unlock with dev_tool_search({"toolNames": ["<exact name>"]}).')
-  return lines
+  return renderRows(scored, {
+    query,
+    limit: MAX_RESULTS,
+    noun: 'tools',
+    emptyText: `No tools match "${query}". An empty result only means no tool matched your keywords — if you need a specific tool, unlock it directly by exact name, e.g. tool_search({"toolNames":["web_search"]}).`,
+    lineOf: ({ schema, name, exact }) => `- ${name}${exact ? ' (exact)' : ''}: ${String(schema?.description ?? '').split('\n')[0].slice(0, DESC_LIMIT)}`,
+    footer: 'Unlock with tool_search({"toolNames": ["<exact name>"]}).',
+  })
 }
 
-/** 注册模型可见的 `dev_tool_search`。 */
-export function apply(ctx) {
-  ctx.tools.register({
-    name: 'dev_tool_search',
+/** 注册模型可见的 `tool_search`。 */
+export function createToolSearchDefinition(ctx, options = {}) {
+  const resident = options.resident ?? RESIDENT
+  const unlockKey = options.unlockKey ?? 'toolNames'
+  return {
+    name: options.tool ?? 'tool_search',
     description: [
       'Discover and unlock tools that are NOT currently available.',
       '',
-      `This session starts with a minimal resident set: ${RESIDENT.join(', ')}. Everything else is unlocked on demand through this tool.`,
+      `This session starts with a minimal resident set: ${resident.join(', ')}. Everything else is unlocked on demand through this tool.`,
       '',
       'Usage:',
       '- `query` — search the catalog by keyword (matches tool names AND descriptions, 1-2 short words work best).',
       '- call with NO arguments — list the catalog as group counts (`<prefix>_*(count) ...`), so you can see what exists before searching.',
-      '- `toolNames` — unlock exact names. Unlocked tools appear from the NEXT request on and stay unlocked for the session.',
+      `- \`${unlockKey}\` — unlock exact names. Unlocked tools appear from the NEXT request on and stay unlocked for the session.`,
       '',
-      'Example: dev_tool_search({"query":"pull request","toolNames":["mcp__github__create_pull_request"]}) — search AND unlock in one call.',
-      'IMPORTANT: an empty search result does NOT mean the tool does not exist — it only means no tool matched your keywords. Call with no arguments to see the catalog groups, then unlock by exact name.',
+      `Example: ${options.tool ?? 'tool_search'}({"query":"pull request","${unlockKey}":["mcp__github__create_pull_request"]}) — search AND unlock in one call.`,
+      'IMPORTANT: if the task needs a capability outside that resident set — web search, subagents, task boards, MCP servers, anything not listed above — search for it here and unlock it. Do NOT make do with a resident tool when the tool you actually need is merely locked; an empty search result does NOT mean the tool does not exist, it only means no tool matched your keywords. Call with no arguments to see the catalog groups, then unlock by exact name.',
     ].join('\n'),
     parameters: toJsonSchema({
       query: { type: 'string', required: false, description: 'search keywords (e.g. "web", "subagent", "github")' },
-      toolNames: {
+      [unlockKey]: {
         type: 'array',
         required: false,
         items: { type: 'string' },
@@ -181,7 +158,7 @@ export function apply(ctx) {
     },
     async execute(args, exec) {
       const query = typeof args?.query === 'string' ? args.query.trim() : ''
-      const unlock = unlockNames(args?.toolNames)
+      const unlock = unlockNames(args?.[unlockKey])
       const lines = []
       // 解锁动作本身不需要任何运行时服务：引擎的 allowFrom 只读本工具的持久调用参数，
       // 所以即便目录不可用（无 tools 服务/无 agent），解锁也必须照样回报成功。
@@ -191,7 +168,7 @@ export function apply(ctx) {
       try {
         // 执行中的 agent 就是观察作用域：preset 工具注册在 agent scope 层，
         // 不带 scope 的 schemas() 只看全局层，会漏掉它们。
-        schemas = ctx.tools.schemas(exec?.agent)
+        schemas = toolScopeSnapshot(ctx.tools, exec?.agent).visible
       } catch (error) {
         return { text: [...lines, `catalog search unavailable: ${String(error?.message ?? error)}`].join('\n') }
       }
@@ -209,5 +186,26 @@ export function apply(ctx) {
       lines.push(...renderMatches(scoreTools(schemas, queryTokens(query)), query))
       return { text: lines.join('\n') }
     },
-  })
+  }
 }
+
+/** 本引擎向发现注册表提供的元数据：工具名与「解锁名单从哪个参数回收」。 */
+export const discoveryAdapter = Object.freeze({
+  kind: 'tools',
+  tool: 'tool_search',
+  unlock: Object.freeze({ tool: 'tool_search', key: 'toolNames' }),
+})
+
+/**
+ * 组合源入口：注册工具（行语义不变），并向发现注册表登记元数据。
+ * 注册表由宿主 root provide；引擎单独使用时它不存在，跳过登记即可。
+ */
+export function apply(ctx, _config, options = {}) {
+  const registered = ctx.tools.register(createToolSearchDefinition(ctx))
+  const registry = typeof ctx.get === 'function' ? ctx.get(DISCOVERY_SERVICE) : undefined
+  const disposeAdapter = registry === undefined ? undefined : registry.register(options.agent, 'tools', discoveryAdapter)
+  return () => {
+    if (typeof disposeAdapter === 'function') disposeAdapter()
+    if (typeof registered === 'function') registered()
+  }
+}

package/engine/trigger.mjs

@@ -1,245 +1,35 @@
 /**
- * trigger — 触发器引擎（B3）：把「声明」变成「注册」。
+ * trigger — 触发器的两个运行时设施：waterfall 位置取值，与观察者谓词的会话事件接线。
  *
- * 本文件负责调度层，**不含**判断原语与动作实现：
- *   - `when` 由 `engine/predicates.mjs` 提供（七类判断的组合）；
- *   - `do`   由 `engine/actions.mjs` 提供（七类动作）；
- *   - 本文件只做：声明校验（复用 B2 的 fields.mjs）、同通道内的稳定排序、
- *     宿主 waterfall 位置映射、注册与 disposer、降级与统一告警、会话态生命周期。
+ * 本文件不承担声明校验、排序与注册：那些归 `rule-spec.mjs`（编译）与 `rule-runtime.mjs`
+ * （挂载）——规则是唯一的声明载体，`engine/rules` 之外没有第二条触发通道。
  *
- * ## 为什么排序必须由运行时自己做（R13 的权威依据）
+ * ## waterfallPosition 为什么与 channelOrder 分开
  *
  * 官方 Cordis（`node_modules/@deepseek-ai/cordis/src/events.ts`）**没有数字排序**：
- *   - `:254-260` `register()` 只做 `options.prepend ? 'unshift' : 'push'`；
- *   - `:234-243` `waterfall()` 用 `cbs.shift()` 从链首取，所以 unshift 的监听器最先执行
- *     （最外层），而**多个 prepend 之间后注册的更靠前**；
- *   - `:228-229` 注释：不调用 `next()` 的监听器会否决其后整条链（含内置行为）。
+ *   - `register()` 只做 `options.prepend ? 'unshift' : 'push'`；
+ *   - `waterfall()` 用 `cbs.shift()` 从链首取，所以 unshift 的监听器最先执行（最外层），
+ *     而**多个 prepend 之间后注册的更靠前**；不调用 `next()` 的监听器会否决其后整条链。
  *
- * 因此调度必须拆成两个互不混淆的字段，**不得**用一个字段同时承担两件事：
- *   - `channelOrder: number`      —— **同一官方通道内**的声明顺序，本文件做有界稳定排序
- *                                    （升序，同值保持声明序），并标明动作在 `next()` 前还是后；
- *   - `waterfallPosition`         —— 适配器在宿主 waterfall 中的位置，只有 `'outermost'`
- *                                    才映射为 `prepend: true`，**不承担**声明间排序。
+ * 因此两个字段互不混淆，**不得**用一个字段同时承担两件事：
+ *   - `channelOrder: number` —— 同一通道内的声明顺序，由 `rule-spec.mjs` 做有界稳定排序；
+ *   - `waterfallPosition` —— 在宿主 waterfall 中的位置，只有 `'outermost'` 映射为 `prepend: true`。
  *
- * **跨九层的全局调度禁止**：官方九层插入点彼此独立，`prepend` 也不得替代执行层 guard
- * 的单调边界（那是 `ctx.tools.guard()` 的职责，见 B3 T2 的动作 (5)）。
- *
- * ## 声明载体约定（与 T4 的能力提供者边界守卫对齐）
- *
- * 本文件导出的是**引擎本身**（`mountTriggers` / `orderTriggers` / `validateTrigger` /
- * `registrationOptions` / `createDecisionLog` 等函数与常量），**不是**某个模块的触发器声明。
- * 声明由**消费方模块**导出，约定名为 `engineTriggers`（数组，元素交给 `validateTrigger`）；
- * 它与能力提供者的 `engineProvider` 登记**互斥**——同一模块不得同时导出两者，
- * 该互斥由 `test/engine/provider-boundary.test.mjs` 直接断言。
- * 因此「某个模块是触发器还是提供者」看的是它导出了哪一个，而不是它 import 了什么。
- *
- * ## 与 predicates 的接线要点（T1 交付时确认的事实）
- *
- *   - `when` 直接接 `createXxxPredicate(...)` 的返回值——它们是**函数**，`await when(...)` 原生兼容；
- *   - **相位 / 计数**两类谓词带 `observe(session, event)` 入口：本文件在同组声明上**共用一条**
- *     `session/event` 监听喂它们（不按触发器各接一条），且没有这类谓词时**不接**（零开销）；
- *   - **当前预设**类需在**挂载期一次** `await loadStandingMountFor()`，把结果传进
- *     `createPresetPredicate({ ctx, presetId, standingMountFor })`，这样判定期零 IO；
- *   - 谓词**运行期不抛**（配置错误在挂载期 fail loud），所以 `when` 的 try/catch 是兜底而非主路径。
- *
- * ## `state`：会话态声明的最小接口（B4 迁移的契约基准）
- *
- * `state` 是**声明**（该触发器需要什么会话态），不是运行时对象：运行时的会话态一律经
- * `engine/shared.mjs` 的既有读法取得，**不新造接口、不新造存储通道**。B4 迁移既有模块时
- * 只允许依赖下面这一组，超出即是新发明的接口，须先回到本文件扩契约：
- *
- *   | 读取               | 既有实现                          | 最小形状                       |
- *   |--------------------|-----------------------------------|--------------------------------|
- *   | 会话标识（记账键） | `session.id`                      | `string \| undefined`          |
- *   | durable 事件快照   | `shared.sessionEvents(session)`   | `{ type, data? }[]`，缺接口=空 |
- *   | 轮号               | 各模块内联 `event.data.turn`      | 有限 `number`，缺失=无轮号     |
- *   | 子代理判定         | `shared.isDelegated(session)`     | `header.delegationDepth > 0`   |
- *   | 会话态 Map 上限    | `shared.MAX_TRACKED_SESSIONS`     | 超出整体清空（触发冷扫重建）   |
- *
- * 三条纪律：**(1)** 没有 `session.id` 的会话一律不记账（`predicates.mjs:343` 的既有决定：
- * 共用一个 Map 键会让两个会话串味），每次冷扫而非缓存；**(2)** 子代理判定复用
- * `isDelegated`，不写字面量比较（原 `progress-reminder` 的 `== 0` 判定与它是同一语义的
- * 两种写法，B4 迁移时统一到前者，行为不变）；**(3)** `snapshotEvents()` 是正式 API
- * （DSH 0.1.2-alpha.4+），缺失时按空日志处理——**不得**回退读旧的 `events` 数组。
- *
- * **给 B4 的边界（B4 PLAN 的措辞与本文件不一致处，以此为准）**：B4 计划里的
- * `session(create, { resetOn })` **不能放进 `shared.mjs`**——`resetOn` 是复位时机，要落地
- * 就得在挂载期注册 `session/event` 监听，而 `shared.mjs` 是**没有 `ctx` 的纯函数模块**
- * （现有导出全是无状态工具）。B4 的统一访问接口须满足：**(a)** 接收挂载期 `ctx`（或由
- * `mountTriggers` 一侧构造），**(b)** 建在本节这组既有读法之上、**不新造事件类型或持久通道**，
- * **(c)** 逐模块保留原有键类型与淘汰策略（`Map<session.id>` / `WeakMap<session 对象>` /
- * 无上限），**(d)** `resetOn` 按**状态字段**声明，不是按模块（`tool-bootstrap` 的
- * `stage` 与 `promotion` 两个字段策略相反，是这条的现成反例）。
- */
-
-import { subjectOf } from './predicates.mjs'
-
-/**
- * 本文件此前**零 import**（`when` / `do` / `warnOnce` 全由调用方注入，会话态读法经 `ctx`
- * 取得）。唯一新增的依赖是谓词的**输入契约** `subjectOf`：调度层调用 `when` 时必须先把
- * 事件参数表归一为**单个载荷对象**（契约见 `predicates.mjs` 头部），否则除 `names` 外，
- * 各原语在真实通道上都取不到它们要的域——`phase` 曾因此恒为「已晋升」、`count` 恒为 0。
- * 声明路径同源：`actions.mjs` 的 `withWhen` 用同一函数归一。
+ * 跨九层的全局调度禁止：官方九层插入点彼此独立，`prepend` 也不得替代 `ctx.tools.guard()`
+ * 的单调边界。
  */
 
 /** 声明里的合法位置取值（与 events.ts 的布尔注册策略一一对应）。 */
 export const WATERFALL_POSITIONS = new Set(['default', 'outermost'])
 
-/** 动作在 `next()` 之前还是之后执行 —— 影响同通道内的可观测顺序。 */
-export const ACTION_PHASES = new Set(['before-next', 'after-next'])
-
-/**
- * 同通道内的稳定排序：`channelOrder` 升序，同值保持**声明序**。
- * 稳定是硬要求：同值声明的相对顺序若随排序实现变化，声明就不可预测。
- */
-export function orderTriggers(declarations) {
-  const list = Array.isArray(declarations) ? declarations : []
-  return list
-    .map((declaration, index) => ({ declaration, index }))
-    .sort((left, right) => {
-      const delta = (left.declaration.channelOrder ?? 0) - (right.declaration.channelOrder ?? 0)
-      return delta !== 0 ? delta : left.index - right.index
-    })
-    .map((entry) => entry.declaration)
-}
-
-/**
- * 把声明的位置字段映射为 Cordis 的注册选项。
- * 只有 `'outermost'` 才 prepend —— 这是**位置**，不是排序；同通道顺序归 `orderTriggers`。
- */
-export function registrationOptions(declaration) {
-  return declaration.waterfallPosition === 'outermost' ? { prepend: true } : {}
-}
-
-/**
- * 校验一条触发器声明：
- *  - 必填：`id`（非空串）、`channel`（官方事件名）、`when`（判定函数）、`do`（动作函数）；
- *  - `channelOrder` 缺省 0（非负安全整数）、`waterfallPosition` 缺省 `'default'`、
- *    `phase` 缺省 `'after-next'`、`degrade` 缺省告警并跳过本触发器。
- * 未知字段一律 fail loud：声明写错键名是最容易被静默忽略的一类错。
- */
-export function validateTrigger(declaration, plugin) {
-  if (declaration === null || typeof declaration !== 'object' || Array.isArray(declaration)) {
-    throw new TypeError(`${plugin}: trigger declaration must be an object`)
-  }
-  const known = new Set(['id', 'channel', 'channelOrder', 'waterfallPosition', 'phase', 'when', 'do', 'degrade', 'state'])
-  const unknown = Object.keys(declaration).filter((key) => !known.has(key))
-  if (unknown.length > 0) {
-    throw new TypeError(`${plugin}: unknown trigger field(s) ${unknown.join(', ')} — allowed: ${[...known].sort().join(', ')}`)
-  }
-  if (typeof declaration.id !== 'string' || declaration.id.length === 0) {
-    throw new TypeError(`${plugin}: trigger.id must be a non-empty string`)
-  }
-  if (typeof declaration.channel !== 'string' || declaration.channel.length === 0) {
-    throw new TypeError(`${plugin}: trigger ${declaration.id}: channel must be a non-empty event name`)
-  }
-  if (typeof declaration.when !== 'function') {
-    throw new TypeError(`${plugin}: trigger ${declaration.id}: when must be a predicate function`)
-  }
-  if (typeof declaration.do !== 'function') {
-    throw new TypeError(`${plugin}: trigger ${declaration.id}: do must be an action function`)
-  }
-  const channelOrder = declaration.channelOrder ?? 0
-  if (!Number.isSafeInteger(channelOrder) || channelOrder < 0) {
-    throw new TypeError(`${plugin}: trigger ${declaration.id}: channelOrder must be a non-negative safe integer`)
-  }
-  const waterfallPosition = declaration.waterfallPosition ?? 'default'
-  if (!WATERFALL_POSITIONS.has(waterfallPosition)) {
-    throw new TypeError(`${plugin}: trigger ${declaration.id}: waterfallPosition must be one of ${[...WATERFALL_POSITIONS].join(', ')}`)
-  }
-  const phase = declaration.phase ?? 'after-next'
-  if (!ACTION_PHASES.has(phase)) {
-    throw new TypeError(`${plugin}: trigger ${declaration.id}: phase must be one of ${[...ACTION_PHASES].join(', ')}`)
-  }
-  return {
-    id: declaration.id,
-    channel: declaration.channel,
-    channelOrder,
-    waterfallPosition,
-    phase,
-    when: declaration.when,
-    do: declaration.do,
-    degrade: declaration.degrade ?? 'skip',
-    state: declaration.state,
-  }
-}
-
-/**
- * 决策链诊断（T5）：把「这次为什么没生效」变成一次可读的输出。
- *
- * 借鉴 dsh-agent-studio 的 `reportFirstDecision`（`apply.ts:238-250`）：一次装配看起来
- * 没生效时，原因可能有多种而**结果长得一样** —— 取不到 agent/session、触发器未启用、
- * 谓词未命中、动作被外层门控剥离、判定走了降级。逐项试太慢，所以按顺序记一条链。
- *
- * 约束（PLAN T5 的 security）：
- *   - **每会话只输出一次**（按 sessionId 去重）；
- *   - 只记录触发器 id、通道、判定结果、动作是否执行、是否走降级 ——
- *     **绝不打印消息正文、变量值或用户内容**；
- *   - 默认关闭时零额外日志；日志自身抛错不得影响装配。
- *
- * **flush 由调用方驱动**：引擎无法知道「一轮装配」何时结束（同一通道可能有多个触发器、
- * 跨通道还会继续判定），所以 `mountTriggers` 只 `step`（累积到内存），
- * 由最外层监听器在整轮处理结束时调一次 `flush`。在步与步之间提前 flush 会输出**不完整的链**
- * —— 那正是本文件最初实现踩过的坑（被 T5 自己的断言抓出来）。
- */
-export function createDecisionLog({ enabled = false, logger, sessionOf } = {}) {
-  const reported = new Set()
-  const pending = new Map()
-  // args 有两种形状：step 收到的是 handler 的完整参数数组，调用方 flush 时可能只给 payload。
-  // 两种都要归一到同一个 key —— 否则 step 存 's-1'、flush 查 '<no-session>'，链永远输出不出来
-  //（这正是 T5 断言抓到的现象：logged.length 恒为 0）。
-  const keyOf = (args) => {
-    try {
-      const values = Array.isArray(args) ? args : [args]
-      return String(sessionOf?.(...values) ?? '<no-session>')
-    } catch {
-      return '<no-session>'
-    }
-  }
-  return {
-    /** 记一步（只入内存，不输出）。 */
-    step(args, line) {
-      if (!enabled) return
-      const key = keyOf(args)
-      const lines = pending.get(key) ?? []
-      lines.push(line)
-      pending.set(key, lines)
-    },
-    /** 该会话的链只输出一次；失败静默 —— 日志不得影响装配。 */
-    flush(args) {
-      if (!enabled) return
-      const key = keyOf(args)
-      if (reported.has(key)) return
-      const lines = pending.get(key)
-      if (lines === undefined || lines.length === 0) return
-      reported.add(key)
-      try {
-        logger?.info?.(`[trigger-decision] session=${key} :: ${lines.join(' | ')}`)
-      } catch {
-        // 日志失败不得影响装配。
-      }
-    },
-  }
-}
-
-/**
- * 注册一组触发器。
- *
- * 每个触发器在**自己的合法通道**上注册一次；`when` 抛错按 `degrade` 处理
- * （默认 `'skip'`：告警一次并跳过本次，**不吞掉下游异常** —— 只有本触发器自身的
- * 判定失败才降级，`next()` 之后的错误照常向上抛）。
- *
- * @returns disposer：注销本组全部监听器。
- */
 /**
  * 把 `session/event` 喂给带 `observe(session, event)` 入口的谓词（相位 / 计数两类）。
  *
- * 同一组声明**共用一条**监听（不按触发器各接一条，避免 N 倍监听）；没有这类谓词时
- * **不接**（返回 `undefined`，零开销）。观察者自身抛错只告警、不影响其它触发器
+ * 同一组观察者**共用一条**监听（不按规则各接一条，避免 N 倍监听）；没有这类谓词时
+ * **不接**（返回 `undefined`，零开销）。观察者自身抛错只告警、不影响其它观察者
  * ——与判定失败的降级纪律一致。
  *
- * 两条调用路径共用它：`mountTriggers`（`do` 是函数的内联路径）与
- * `trigger-spec.mjs` 的 `mountDeclarations`（`do` 是动作声明的路径）。
+ * 由 `rule-runtime.mjs` 的 `mountRuleSources` 接线：规则条件里的观察者谓词共用这一条监听。
  *
  * @returns disposer，或 `undefined`（本组无观察者）
  */
@@ -257,48 +47,3 @@ export function wireTriggerObservers(ctx, triggers, { plugin, warnOnce } = {}) {
     }
   })
 }
-
-export function mountTriggers(ctx, declarations, { plugin, warnOnce, diagnose } = {}) {
-  const warn = typeof warnOnce === 'function' ? warnOnce : () => {}
-  const disposers = []
-  const ordered = orderTriggers((Array.isArray(declarations) ? declarations : []).map((raw) => validateTrigger(raw, plugin)))
-
-  // 会话态生命周期：共用 `wireTriggerObservers`（与声明路径同一实现）。
-  const observer = wireTriggerObservers(ctx, ordered, { plugin, warnOnce: warn })
-  if (observer !== undefined) disposers.push(observer)
-
-  for (const trigger of ordered) {
-    const handler = async (...args) => {
-      const next = args[args.length - 1]
-      const payload = args.slice(0, -1)
-      const result = trigger.phase === 'after-next' ? await next() : undefined
-      const pass = () => trigger.phase === 'after-next' ? result : next()
-      let decided
-      try {
-        decided = await trigger.when(subjectOf(trigger.channel, payload, warn))
-      } catch (error) {
-        // 判定失败只影响本触发器：告警一次并放行下游（expose-all 语义）。
-        warn(`${plugin}: trigger ${trigger.id} predicate failed: ${String(error?.message ?? error)}`)
-        diagnose?.step(args, `${trigger.id}@${trigger.channel} predicate=error action=skipped`)
-        return pass()
-      }
-      if (decided !== true) {
-        diagnose?.step(args, `${trigger.id}@${trigger.channel} predicate=miss action=skipped`)
-        return pass()
-      }
-      diagnose?.step(args, `${trigger.id}@${trigger.channel} predicate=hit phase=${trigger.phase} action=ran`)
-      if (trigger.phase === 'before-next') {
-        // 返回值参与瀑布：裁决类动作在 `next()` **之前**给出终局（deny/ask），
-        // 不返回值即「无话可说」，交给下游（与「只 guard 自身逻辑」一致）。
-        const early = await trigger.do(...payload)
-        return early === undefined ? next() : early
-      }
-      // 返回值同样参与瀑布：这正是裁决类动作（deny / ask / replace / block）的出口
-      // ——丢弃它会让「命中却拦不住」，是本文件被 trigger-rebuild 对拍抓到的缺陷。
-      const overridden = await trigger.do(...payload, result)
-      return overridden === undefined ? result : overridden
-    }
-    disposers.push(ctx.on(trigger.channel, handler, registrationOptions(trigger)))
-  }
-  return () => { for (const dispose of disposers) dispose() }
-}

package/engine/vendor/yaml/dist/compose/resolve-flow-scalar.js

@@ -64,46 +64,47 @@ function plainValue(source, onError) {
     }
     if (badChar)
         onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
-    return foldLines(source);
+    return unfoldLines(source);
 }
 function singleQuotedValue(source, onError) {
     if (source[source.length - 1] !== "'" || source.length === 1)
         onError(source.length, 'MISSING_CHAR', "Missing closing 'quote");
-    return foldLines(source.slice(1, -1)).replace(/''/g, "'");
+    return unfoldLines(source.slice(1, -1)).replace(/''/g, "'");
 }
-function foldLines(source) {
+function unfoldLines(source) {
+    const line = /(.*?)\r?\n/sy;
+    let match = line.exec(source);
+    if (!match)
+        return source;
     /**
-     * The negative lookbehind here and in the `re` RegExp is to
+     * The negative lookbehinds in these RegExps are to
      * prevent causing a polynomial search time in certain cases.
      *
-     * The try-catch is for Safari, which doesn't support this yet:
+     * The try-catch is for Safari < 16.4 and other old browsers:
      * https://caniuse.com/js-regexp-lookbehind
      */
-    let first, line;
+    let trimEnd, trimBoth;
     try {
-        first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
-        line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
+        trimEnd = new RegExp('(?<![ \t])[ \t]+$');
+        trimBoth = new RegExp('^[ \t]+|(?<![ \t])[ \t]+$', 'g');
     }
     catch {
-        first = /(.*?)[ \t]*\r?\n/sy;
-        line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
+        trimEnd = /[ \t]+$/;
+        trimBoth = /^[ \t]+|[ \t]+$/g;
     }
-    let match = first.exec(source);
-    if (!match)
-        return source;
-    let res = match[1];
+    let res = match[1].replace(trimEnd, '');
     let sep = ' ';
-    let pos = first.lastIndex;
-    line.lastIndex = pos;
+    let pos = line.lastIndex;
     while ((match = line.exec(source))) {
-        if (match[1] === '') {
+        const lm = match[1].replace(trimBoth, '');
+        if (lm === '') {
             if (sep === '\n')
                 res += sep;
             else
                 sep = '\n';
         }
         else {
-            res += sep + match[1];
+            res += sep + lm;
             sep = ' ';
         }
         pos = line.lastIndex;

package/engine/vendor/yaml/dist/nodes/Alias.js

@@ -43,38 +43,40 @@ class Alias extends NodeBase {
             if (node.anchor === this.source)
                 found = node;
         }
+        if (found && ctx) {
+            const { anchors, doc, maxAliasCount } = ctx;
+            let data = anchors.get(found);
+            if (!data) {
+                // Resolve anchors for Node.prototype.toJS()
+                toJS(found, null, ctx);
+                data = anchors.get(found);
+            }
+            /* istanbul ignore if */
+            if (data?.res === undefined) {
+                const msg = 'This should not happen: Alias anchor was not resolved?';
+                throw new ReferenceError(msg);
+            }
+            if (maxAliasCount >= 0) {
+                data.count += 1;
+                if (data.aliasCount === 0)
+                    data.aliasCount = getAliasCount(doc, found, anchors);
+                if (data.count * data.aliasCount > maxAliasCount) {
+                    const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                    throw new ReferenceError(msg);
+                }
+            }
+        }
         return found;
     }
     toJSON(_arg, ctx) {
         if (!ctx)
             return { source: this.source };
-        const { anchors, doc, maxAliasCount } = ctx;
-        const source = this.resolve(doc, ctx);
+        const source = this.resolve(ctx.doc, ctx);
         if (!source) {
             const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
             throw new ReferenceError(msg);
         }
-        let data = anchors.get(source);
-        if (!data) {
-            // Resolve anchors for Node.prototype.toJS()
-            toJS(source, null, ctx);
-            data = anchors.get(source);
-        }
-        /* istanbul ignore if */
-        if (data?.res === undefined) {
-            const msg = 'This should not happen: Alias anchor was not resolved?';
-            throw new ReferenceError(msg);
-        }
-        if (maxAliasCount >= 0) {
-            data.count += 1;
-            if (data.aliasCount === 0)
-                data.aliasCount = getAliasCount(doc, source, anchors);
-            if (data.count * data.aliasCount > maxAliasCount) {
-                const msg = 'Excessive alias count indicates a resource exhaustion attack';
-                throw new ReferenceError(msg);
-            }
-        }
-        return data.res;
+        return ctx.anchors.get(source).res;
     }
     toString(ctx, _onComment, _onChompKeep) {
         const src = `*${this.source}`;

package/engine/vendor/yaml/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaml-vendor",
-  "version": "2.9.0",
+  "version": "2.9.1",
   "private": true,
   "type": "module",
   "description": "Vendored ESM build of npm `yaml` for the generated agent preset runtime (zero external dependency).",