dsh-plugin-prompt-tool 2.1.0 → 3.0.1

package/templates/70-subagent-maintenance.yml

@@ -1,8 +1,9 @@
 # 模板：子代理状态 / 记忆维护（audience=subagent 专用注入）
 # 用途：把 ST 的「角色状态跟踪 + 关系记忆」委派给子代理完成——引擎保持确定性
 #       （插值/匹配/注入），智能判断（何时更新、更新成什么）交给委派子代理，
-#       写入经确定性工具边界（session_var 会话状态 / world_book note 持久记忆）。
-# 接入：模板选择器「消息批层」插入；默认关闭，插入后启用并按需改 stateKeys。
+#       写入经 module_variables 持久变量与 module_file_append 文件工具。
+# 接入：声明 module-variable-tools、module-file-tools；默认关闭。
+# 先在工作台的模块变量卡手动建立 stateKeys，例如「心情, 接受值, 关系进度」。
 id: subagent-maintenance
 name: 子代理状态/记忆维护
 enabled: false
@@ -31,14 +32,12 @@ then:
         value: subagent-maintenance
       text: |-
         你是本会话的「状态与记忆维护者」，与创作类子代理职责互补：
-        - 状态（本会话临时，模板变量注入用）：观察互动中明确的角色状态变化
-          （心情、态度、接受度等），用 session_var 工具 set 更新——变量名见下方
-          「状态变量」清单；状态未变化时不要重复写入。
-        - 记忆（跨会话持久）：有人际关系进展或重要事实时，用 world_book_upsert
-          的 note 参数写入来源角色卡记忆（条目 id 带 chara- 前缀 → 角色卡
-          memory.md，跨会话跟随角色卡）；无归属条目写入模块记忆。
+        - 状态（当前模块跨会话持久）：观察互动中明确的角色状态变化。
+          先用 module_variables 的 scope=module、action=list 读取身份与版本，
+          再用 action=set 和显式字符串 value 更新下方清单中的变量；带回读取时
+          的 expectedModuleId 与 expectedRevisions，冲突时重读，不覆盖未知修改。
+        - 记忆（当前模块 memory.md）：重要事实先用 module_file_read 核对（path 为 memory.md），
+          确有新增时用 module_file_append 追加（path 为 memory.md）；记忆不会自动变成注入规则。
         - 克制：仅在状态确实变化时更新；不确定时保留原值；不编造未发生的内容。
         状态变量清单：{{stateKeys}}
-      variables:
-        stateKeys: 心情, 接受值, 关系进度
       params: {}

package/templates/75-subagent-end.yml

@@ -1,8 +1,8 @@
 # 模板：subagent-end 子代理结束层
 # 默认仅记录。将 params.action 改为 inject-main 并填写 text，
 # 通过官方 Agent.inject 向所属主会话投递上下文；不改写子代理结果、不唤醒空闲主会话。
-# 接入：subject 缺省 subagentInfo（事件载荷序列化文本，含子代理 id/runId）；不写 match
-#       即每个子代理结束都记录。载荷里没有稳定角色名，需要筛的时候按实际 runId 补 match。
+# 接入：条件写在规则 if；subagent-end 不再有 config.subject/match。
+#       载荷里没有稳定角色名，需要筛的时候按实际 runId 在 if 里写条件。
 # 默认关闭：它只写日志，需要审计子代理收尾时再打开。
 id: example-subagent-end
 name: 子代理结束记录（只观察）

package/templates/80-tool-surface.yml

@@ -1,66 +1,50 @@
 # 模板：工具面收窄（核心文件与任务集）+ 按需解锁
 #
-# 为什么：工具面实测 **156 个工具、描述合计 46894 字符（≈12K token）**，每个请求都付。
-# 收窄到核心集后只剩约 10 个工具，其余按需解锁。
+# `tool-visibility` 声明常驻集、目录与 SDK 正文的呈现、执行闸和发现来源。
+# 首轮提示由同规则的普通注入动作组合；常驻名单只写一次。
 #
-# 与已退场的 `tool-bootstrap` 原型的关键差别：那份**只在受控相位收窄**
-# （`promoted: false`），晋升后原样放开；本模板**覆盖全部相位**——晋升后放开等于白省，
-# 而工具描述是每请求的固定开销。若要旧语义，给 `phase` 加 `promoted: false` 并把
-# `compacted` 拆成两条即可。
+# 本模板只带规则、不带 `modules` 声明：装配里没有提供方时 `bash` 就是缺失名，
+# `requireMatch` 反过来把整条收窄废掉——用模板建模块时要自己把提供方行带进装配。
+# 写错名字的后果很隐蔽：allow 里的名字不存在会触发 requireMatch 的 fail-open，
+# 表现为「收窄没生效」而不是报错。
 #
-# 配套两件（缺一不可）：
-#   1. `dev_tool_search` 工具（组合源 engine/compositions/source/local/dev-tool-search.yml）
-#      ——唯一发现入口，模型靠它搜索并解锁。
-#   2. `allowFrom`（engine/actions/assembly.mjs）——从历史 `tool/call` 参数回收解锁名单。
-#      只挂插件不配 allowFrom 的话，解锁是**一次性的**（当次请求用完即被裁）。
-#
-# 工具名必须与**实际装配名**一致。本项目 harness 是 `pwsh`（不是 `bash`）、
-# `edit` + `write`（不是 `str_replace_editor`）。写错名字有两个后果，都很隐蔽：
-#   - 写进 allow 的名字不存在 → `requireMatch` 触发 fail-open，**静默暴露完整目录**；
-#   - 该在的没写进去 → 该工具被裁掉，模型只能用别的方式硬凑。
-#
-# `requireMatch: true` 是刻意的：任一 allow 工具缺失（或模型解锁了一个不存在的名字）
-# 就放弃裁剪、暴露完整目录。宁可多给上下文，也不静默裁成空目录——收窄错了会让当前
-# 工作流调不到工具，那是比多花 token 严重得多的故障。
-#
-# **本模板走规则路径，不能声明 `waterfallPosition`**（那是声明式路径的字段，规则路径会以
-# unknown fields 拒绝）。`assembly` 的改写发生在通道下游结算之后，与相邻动作的先后由规则
-# 顺序与模块顺序决定。需要 `outermost`（`prepend: true`：保证本动作落在普通注册之外、
-# 先看到装配）时，模块层没有出口——`declared-triggers` 与顶层 `triggers` 都已退役
-# （写进 `modules` 或定义顶层即 409），只能回到插件侧声明。
+# 发现适配器由 `tool-search` 行提供（模块必须列该行）；解锁名从持久 `tool/call` 参数回收，
+# 因此下一步请求即可见，压缩遮蔽后仍然保留。
 id: tool-surface-resident
 name: 工具面收窄（核心文件与任务集）
 enabled: true
-if:
-  # 覆盖全部相位。为什么不能只写 `phase: { promoteOn, includeSubagents }`：
-  # `promoted` 的缺省是 **true**（= 只匹配已晋升），不是「任意」；而 `compacted` 未声明才是
-  # 「不判该维度」（engine/conditions/phase.mjs:27-48）。更麻烦的是 `promoted: 'ignore'`
-  # 要求同时声明 `compacted`，而 `compacted` 只接受布尔值——**没有任何单节点组合能表达
-  # 「两个相位都命中」**，必须用 `any` 拼两支（phase.mjs:30-35 的注释正是在讲这个表达力边界）。
-  #   支 1 `promoted: true`          → 已晋升（不论压缩与否）
-  #   支 2 `{compacted: true, promoted: false}` → 压缩后未晋升（受控相位的压缩回退）
-  # 未晋升且未压缩的**首轮不收窄**：与「首轮保全文」同一取舍——先让模型看到完整目录，
-  # 再随相位推进收窄。收窄的价值在于工具描述是**每请求固定开销**（实测 46894 字符），
-  # 而长会话必然进入上面两支，所以省下的正是大头。
-  any:
-    - phase: { promoteOn: either, includeSubagents: true, promoted: true }
-    - phase: { promoteOn: either, includeSubagents: true, compacted: true, promoted: false }
 then:
   - id: narrow-tools
-    kind: assembly
-    target:
-      tools:
-        allow:
-          - pwsh
-          - read
-          - write
-          - edit
-          - glob
-          - grep
-          - todo_write
-          - skill_search
-          - skill_load
-          - dev_tool_search
-        # 解锁项从 dev_tool_search 的持久调用参数回收（{ tool, key } 精确匹配）。
-        allowFrom: { tool: dev_tool_search, key: toolNames }
-        requireMatch: true
+    kind: tool-visibility
+    allow:
+      - pwsh
+      - read
+      - write
+      - edit
+      - glob
+      - grep
+      - todo_write
+      - skill_search
+      - skill_load
+      - tool_search
+      # 平台各自的 bash 名：装配里没有提供方时这里就是缺失名，收窄整体失效。
+      - bash
+    discovery: { kind: tools }
+    # 任一常驻工具缺失就放弃裁剪、暴露完整目录（fail-open），避免静默裁成空目录。
+    requireMatch: true
+  - if:
+      count:
+        of: user-message
+        max: 1
+    then:
+      - id: discovery-notice
+        kind: inject-text
+        config:
+          layer: pre-step
+          strategy: placeholder
+          fill: tool-catalog
+          position: after-all
+          dedupe: session
+          text: 常驻工具：{{RESIDENT_TOOLS}}。缺少所需工具时，先用 {{DISCOVERY_TOOL}} 搜索并解锁。
+          params:
+            action: narrow-tools

package/templates/tools/40-delegate-module-import.yml

@@ -0,0 +1,22 @@
+# 模块导入预览；保存模板时按实际工具目录补装 module-import-tools。
+id: delegate-module-import
+name: my_module_import_preview
+description: 预览模块导入来源、降级报告与版本凭据
+parameters:
+  files:
+    type: json
+    required: true
+    description: 文件数组，每项包含相对 path、content 和可选 encoding
+output:
+  schema:
+    type: object
+    additionalProperties: true
+    properties:
+      ok: { type: boolean }
+      value: { type: json }
+execute:
+  kind: delegate
+  tool: module_import
+  args:
+    files: '{{args.files}}'
+    preview: true

package/templates/tools/50-delegate-module-rules.yml

@@ -0,0 +1,14 @@
+# 完整规则读取；保存模板时补装 module-rule-tools。
+id: delegate-module-rules-read
+name: my_module_rules_read
+description: 读取当前模块的完整规则树和版本
+output:
+  schema:
+    type: object
+    additionalProperties: true
+    properties:
+      ok: { type: boolean }
+      value: { type: json }
+execute:
+  kind: delegate
+  tool: module_rules_read

package/templates/tools/60-delegate-module-variables.yml

@@ -0,0 +1,17 @@
+# 持久变量读取；保存模板时补装 module-variable-tools。
+id: delegate-module-variables
+name: my_module_variables
+description: 列出当前模块的有效持久变量、覆盖来源和版本
+output:
+  schema:
+    type: object
+    additionalProperties: true
+    properties:
+      ok: { type: boolean }
+      value: { type: json }
+execute:
+  kind: delegate
+  tool: module_variables
+  args:
+    scope: module
+    action: list

package/templates/tools/70-delegate-module-rules-edit.yml

@@ -0,0 +1,31 @@
+# 完整规则事务；先读取规则和版本，只改需要的字段。
+id: delegate-module-rules-edit
+name: my_module_rules_edit
+description: 按读取版本编辑当前模块的完整规则
+parameters:
+  moduleId:
+    type: string
+    required: true
+    description: 读取时返回的模块身份
+  revisions:
+    type: json
+    required: true
+    description: 读取时返回的按域版本
+  edits:
+    type: json
+    required: true
+    description: 完整规则修改数组，整规则删除须显式 rule 为 null
+output:
+  schema:
+    type: object
+    additionalProperties: true
+    properties:
+      ok: { type: boolean }
+      value: { type: json }
+execute:
+  kind: delegate
+  tool: module_rules_edit
+  args:
+    expectedModuleId: '{{args.moduleId}}'
+    expectedRevisions: '{{args.revisions}}'
+    edits: '{{args.edits}}'

package/engine/actions/decision.mjs

@@ -1,54 +0,0 @@
-import { labelOf, toolNameSet } from './shared.mjs'
-
-export function prepareDecision(action, plugin) {
-  const label = labelOf(action)
-  const names = toolNameSet(action.toolNames, plugin, `${label}.toolNames`)
-  const matchesTool = (exec) => names === undefined || names.has(exec?.name)
-  const hit = (exec, result) => typeof action.match !== 'function' || action.match(exec, result) === true
-  const phase = action.phase === undefined ? 'pre' : action.phase
-  if (!['pre', 'post'].includes(phase)) {
-    throw new TypeError(`${plugin}: ${label}.phase must be one of pre, post`)
-  }
-  if (phase === 'pre') {
-    const decision = action.decision ?? 'allow'
-    if (!['allow', 'deny', 'ask'].includes(decision)) {
-      throw new TypeError(`${plugin}: ${label}.decision must be one of allow, deny, ask`)
-    }
-    return (_ctx, { warnOnce, on, collect, take }) => collect(on('tools/pre-execute', async (exec, next) => {
-      try {
-        if (!matchesTool(exec) || !hit(exec)) return next()
-        if (decision === 'allow') return next()
-        const outcome = decision === 'deny'
-          ? { kind: 'deny', reason: String(action.reason ?? `${label}: denied by action`) }
-          : { kind: 'ask' }
-        return take(exec) ? outcome : next()
-      } catch (error) {
-        warnOnce(`${plugin}: decision(pre) action ${label} failed: ${String(error?.message ?? error)}`)
-        return next()
-      }
-    }))
-  }
-  const postAction = action.action ?? 'accept'
-  if (!['accept', 'replace', 'block'].includes(postAction)) {
-    throw new TypeError(`${plugin}: ${label}.action must be one of accept, replace, block`)
-  }
-  const text = typeof action.text === 'string' ? action.text : ''
-  return (_ctx, { warnOnce, on, collect, take }) => collect(on('tools/post-execute', async (exec, result, next) => {
-    try {
-      if (!matchesTool(exec) || !hit(exec, result)) return next()
-      if (postAction === 'accept') return next()
-      if (postAction === 'replace' && text.length > 0) {
-        if (!take(exec)) return next()
-        return { kind: 'accept', content: [{ type: 'text', text }] }
-      }
-      if (postAction === 'block') {
-        if (!take(exec)) return next()
-        return { kind: 'block', feedback: [{ type: 'text', text: text.length > 0 ? text : `${label}: blocked by action` }] }
-      }
-      return next()
-    } catch (error) {
-      warnOnce(`${plugin}: decision(post) action ${label} failed: ${String(error?.message ?? error)}`)
-      return next()
-    }
-  }))
-}

package/engine/actions/guard.mjs

@@ -1,80 +0,0 @@
-import { labelOf, createMask, RUN_CODE } from './shared.mjs'
-
-export function prepareGuard(action, plugin) {
-  const label = labelOf(action)
-  const mask = createMask(action.mask ?? action, `${label}.mask`, plugin)
-  const includeSubagents = action.includeSubagents === true
-  const reasonFor = (toolName) => String(action.reason ?? `${label}: tool ${JSON.stringify(toolName)} is denied by action`)
-
-  return (_ctx, { warnOnce, on, collect }) => {
-    /** session -> { ctx, disposers }：同一 agent.ctx 只注册一次，重绑后按新 ctx 重注册。 */
-    const appliedBySession = new WeakMap()
-    const states = new Set()
-    const releaseState = (state) => {
-      states.delete(state)
-      for (const dispose of state.disposers.splice(0)) {
-        try { dispose() } catch { /* 释放失败不得反过来打断卸载 */ }
-      }
-    }
-    const releaseAll = () => { for (const state of [...states]) releaseState(state) }
-
-    const applyTo = (agent) => {
-      const session = agent?.session
-      const scoped = agent?.ctx
-      if (session === undefined || scoped === undefined) return
-      // 受众不在本动作的裁决面内就不注册（子代理的 guard 由它自己的 assembly 决定；
-      // 万一父 guard 经 scope 链被走到，guard 体内的同一道受众判定仍然放行）。
-      const depth = session.header?.delegationDepth ?? 0
-      if (depth > 0 ? !includeSubagents : action.audience === 'subagent') return
-      const existing = appliedBySession.get(session)
-      if (existing !== undefined) {
-        // 预设切换/重绑会换掉 agent.ctx：旧 scope 的 guard 随旧 scope 失效，必须重注册。
-        if (existing.ctx === scoped) return
-        releaseState(existing)
-        appliedBySession.delete(session)
-      }
-      const tools = scoped.tools
-      if (tools === undefined || typeof tools.guard !== 'function') {
-        warnOnce(`${plugin}: guard action ${label} found no agent-scoped tools service — execution guard not registered`)
-        return
-      }
-      const state = { ctx: scoped, disposers: [] }
-      states.add(state)
-      appliedBySession.set(session, state)
-      const denials = {
-        ...(mask.allow !== undefined ? { allow: [...mask.allow] } : {}),
-        ...(mask.deny !== undefined ? { deny: [...mask.deny] } : {}),
-      }
-      // restrict 沿父 scope 链传播且不识别受众；只在子代理也受限时复用。
-      if (includeSubagents && typeof tools.restrict === 'function') {
-        try {
-          const dispose = tools.restrict(denials)
-          if (typeof dispose === 'function') state.disposers.push(dispose)
-        } catch (error) {
-          // restrict 只收继承面：本层/晚到工具不在它的可限制集合里，交给 guard 裁决。
-          warnOnce(`${plugin}: guard action ${label} restrict skipped (own-layer/late tools stay covered by the guard): ${String(error?.message ?? error)}`)
-        }
-      }
-      state.disposers.push(tools.guard((exec) => {
-        const toolName = exec?.name
-        if (toolName === RUN_CODE || typeof toolName !== 'string' || toolName.length === 0) return undefined
-        const depth = exec?.agent?.session?.header?.delegationDepth ?? 0
-        // 主子代理隔离：scope 注册之外再按受众判定一次（子代理 scope 可能挂在父链上）。
-        if (depth > 0 ? !includeSubagents : action.audience === 'subagent') return undefined
-        return mask.blocks(toolName) ? reasonFor(toolName) : undefined
-      }))
-    }
-
-    collect(releaseAll)
-    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 {
-        applyTo(context?.agent)
-      } catch (error) {
-        warnOnce(`${plugin}: guard action ${label} failed to register: ${String(error?.message ?? error)}`)
-      }
-      return assembled
-    }))
-  }
-}

package/engine/actions/sdk-strip.mjs

@@ -1,30 +0,0 @@
-import { labelOf, createMask } from './shared.mjs'
-import { SDK_SECTION_NAME, sdkToolNames, stripSdkDeclarations } from '../sdk-strip.mjs'
-
-export function prepareSdkStrip(action, plugin) {
-  const label = labelOf(action)
-  const mask = createMask(action.mask ?? action, `${label}.mask`, plugin)
-  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 (!Array.isArray(assembled.sections)) return assembled
-      let changed = false
-      const sections = assembled.sections.map((section) => {
-        if (section?.name !== SDK_SECTION_NAME || typeof section.text !== 'string') return section
-        const names = mask.allow === undefined
-          ? mask.deny
-          : new Set([...sdkToolNames(section.text)].filter((toolName) => mask.blocks(toolName)))
-        if (names === undefined || names.size === 0) return section
-        const stripped = stripSdkDeclarations(section.text, names)
-        if (stripped === section.text) return section
-        changed = true
-        return { ...section, text: stripped }
-      })
-      return changed && take(context) ? { ...assembled, sections } : assembled
-    } catch (error) {
-      warnOnce(`${plugin}: sdk-strip action ${label} failed, keeping the original SDK text: ${String(error?.message ?? error)}`)
-      return assembled
-    }
-  }))
-}

package/engine/character-tools.mjs

@@ -1,8 +0,0 @@
-/** 角色卡库工具预设模块。 */
-export const name = "character-tools"
-
-export function apply(ctx) {
-  ctx.inject(["pt-character-tools"], (scopeCtx) => {
-    scopeCtx.effect(() => scopeCtx.get("pt-character-tools").mount(scopeCtx), name + ": mount")
-  })
-}

package/engine/classify-task.mjs

@@ -1,53 +0,0 @@
-/**
- * classify-task — 任务分类器（能力归一）。
- *
- * buildPattern（构建任务正则）与 complexPattern（复杂任务正则）→ 三档分类
- * （complex / build / fix）。锚定策略（first-turn-anchor）三档判定与引导策略
- * （guide-auto）复杂判定共用本分类器——正则构建与判定逻辑单一实现，
- * 避免两个策略各自 new RegExp + test（历史重复实现）。
- *
- * 参数缺省 = 对应分类不生效：buildRe/complexRe 未配置时跳过该分支
- * （classify 落 fix；isComplex 恒 false）。
- */
-export function createTaskClassifier({ buildPattern, complexPattern }) {
-  const buildRe = typeof buildPattern === 'string' && buildPattern.length > 0
-    ? new RegExp(buildPattern, 'i')
-    : undefined
-  const complexRe = typeof complexPattern === 'string' && complexPattern.length > 0
-    ? new RegExp(complexPattern, 'i')
-    : undefined
-  return {
-    /** 锚定三档判定可用：两档正则都配置。 */
-    get ready() {
-      return buildRe !== undefined && complexRe !== undefined
-    },
-    /** 三档分类：complex > build > fix（fix 为兜底档）。 */
-    classify(text) {
-      if (complexRe !== undefined && complexRe.test(text)) return 'complex'
-      if (buildRe !== undefined && buildRe.test(text)) return 'build'
-      return 'fix'
-    },
-    /** 复杂判定（引导 fallback 用；正则未配置 = false）。 */
-    isComplex(text) {
-      return complexRe !== undefined && complexRe.test(text)
-    },
-  }
-}
-
-/**
- * 通用有序任务规则分类器（subagentToolPolicy.taskRules 单一实现）。
- * 规则：order 升序（同 order 按数组顺序）、首个匹配获胜；输入为
- * description + "\n" + prompt；无匹配回落 undefined（调用方用 default）。
- * 规则在保存时已编译（非法 pattern 拒绝整次保存），此处只按顺序 test。
- */
-export function createOrderedTaskClassifier(rules) {
-  const ordered = [...(Array.isArray(rules) ? rules : [])]
-    .filter((rule) => rule !== null && typeof rule === 'object' && typeof rule.re?.test === 'function')
-    .sort((a, b) => (a.order - b.order) || 0)
-  return (text) => {
-    for (const rule of ordered) {
-      if (rule.re.test(String(text ?? ''))) return rule.id
-    }
-    return undefined
-  }
-}

package/engine/compositions/source/local/character-tools.yml

@@ -1,5 +0,0 @@
-# module: character-tools
-# source: engine/compositions/source/local/character-tools.yml (本地附加,非官方模块)
-
-- id: character-tools
-  name: ./engine/character-tools.mjs

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

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

package/engine/compositions/source/local/session-var-tools.yml

@@ -1,5 +0,0 @@
-# module: session-var-tools
-# source: engine/compositions/source/local/session-var-tools.yml (本地附加,非官方模块)
-
-- id: session-var-tools
-  name: ./engine/session-var-tools.mjs

package/engine/compositions/source/local/subagent-tool-policy.yml

@@ -1,21 +0,0 @@
-# module: subagent-tool-policy
-# source: 本地新增（子代理实例级工具策略：agent-scoped subagent/subagent_fork shadow）
-# 策略数据源 = 预设目录 subagent-tools/policy.yml（writePreset 从 preset.yml 顶层
-# subagentToolPolicy 物化）。策略启用时参数桥不再把主代理 toolFilter 写入
-# delegation.toolFilter；未启用策略的预设完全保持官方 delegation 行为。
-#
-# 能力提供者边界（T4）：本行是**能力提供者**（给模型提供 subagent/subagent_fork 两个
-# 可调用工具），**不接入** engine/trigger.mjs。判据：会给模型提供可调用能力
-# （注册工具/域）的 → 能力提供者；干预流程（改提示词、改装配、裁决、追加）的 →
-# 声明式触发器。登记数据在 engine/subagent-tool-policy.mjs 的 `engineProvider`
-# 导出，与 `engineTriggers`（声明式触发器）互斥；守卫见
-# test/engine/provider-boundary.test.mjs。模块内扩权审批门与 fail loud 语义是安全
-# 边界，改装配方式时不得放宽。
-
-- id: subagent-tool-policy
-  name: ./engine/subagent-tool-policy.mjs
-  config:
-    policyFile: ../subagent-tools/policy.yml
-    spawnProvider: spawn
-    forkProvider: fork
-    maxDepth: 3

package/engine/compositions/source/local/world-book-tools.yml

@@ -1,5 +0,0 @@
-# module: world-book-tools
-# source: engine/compositions/source/local/world-book-tools.yml (本地附加,非官方模块)
-
-- id: world-book-tools
-  name: ./engine/world-book-tools.mjs

package/engine/condition.mjs

@@ -1,96 +0,0 @@
-/**
- * condition — 声明式条件判定的共享实现（pre-step / tool-pipeline / 事件层共用）。
- *
- * 匹配语义来自 anchor-match.mjs：键集合由 schema.mjs 在挂载期归一化并预编译为
- * `config.matchScan`（非法 logic / 空键集合 / 非法正则在挂载期 fail loud）。
- * 本模块只负责「按 subject 取文本」与「是否命中」两件事。
- *
- * 语义约定：
- *   - 未声明 match 的配置是**无条件**的（与引入条件判定前逐字一致）；
- *   - 取不到匹配文本（字段缺失、类型不符、序列化失败）一律按空串处理，即不命中；
- *   - 判定异常不抛出：门配错不应该阻断正常链路。
- */
-
-import { extractText, sessionEvents } from './shared.mjs'
-
-/** subject → 载荷字段名。改这里等于改所有层的匹配对象。 */
-export const SUBJECT_FIELDS = {
-  toolArgs: 'argsText',
-  toolResult: 'resultText',
-  userMessage: 'userText',
-  assistantText: 'assistantText',
-  subagentInfo: 'subagentText',
-}
-
-/** 按 subject 取参与匹配的文本；取不到一律空串（不命中，不抛错）。 */
-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] : ''
-}
-
-/**
- * 条件判定：未声明 match 恒真。
- * 消费 schema 预编译的 `config.matchScan`；外部手工构造的 config 没有该函数时按无条件处理。
- */
-export function conditionHit(config, payload) {
-  if (config?.match === undefined) return true
-  const scan = config.matchScan
-  if (typeof scan !== 'function') return true
-  try {
-    return scan(subjectTextOf(config.subject, payload)).active === true
-  } catch {
-    return true
-  }
-}
-
-/** 工具参数的可匹配文本：对象按 JSON 序列化，字符串原样；序列化失败按空串。 */
-export function toolArgsText(args) {
-  if (typeof args === 'string') return args
-  try {
-    return JSON.stringify(args ?? {})
-  } catch {
-    return ''
-  }
-}
-
-/**
- * pre-step 的缺省匹配对象：本批**真实对话**的用户消息文本。
- *
- * 只收真人输入：引擎自己注入的消息同样是 user-role（`executor.mjs` 的
- * `role: PRE_STEP_ROLE`、`pluginMessage` 的 `source` 是 `plugin:<name>` 生产者身份），
- * 把它们算进来会让 `text.match` 匹配到自己注入过的正文——规则正文里出现「重构」
- * 「实现」这类词就会自我命中，且命中判定在去重之前，`dedupe` 挡不住。
- * 过滤判据与 `st-world-book.mjs#stChatMessages` 的同名约定一致（那是最早做对的一处），
- * 两处必须保持同语义。
- */
-export function userMessagesText(messages) {
-  if (!Array.isArray(messages)) return ''
-  return messages
-    .filter((message) => message?.role === 'user'
-      && message.source?.plugin === undefined
-      && message.source?.kind !== 'plugin'
-      && !(typeof message.source?.kind === 'string' && message.source.kind.startsWith('plugin:'))
-      && (message.source?.kind === undefined || message.source.kind === 'user'))
-    .map((message) => extractText(message))
-    .filter((text) => text.length > 0)
-    .join('\n')
-}
-
-/** 最后一条 assistant 消息的文本（turn-stop 的缺省匹配对象）。 */
-export function lastAssistantText(session) {
-  const events = sessionEvents(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 ''
-  }
-}