dsh-plugin-prompt-tool 1.0.0 → 2.0.1

package/engine/strategies.mjs

@@ -1,235 +1,2 @@
-/**
- * strategies — 引擎内容策略绑定(config.resolve)。
- * 内置策略: static / placeholder / first-turn-anchor / guide-auto / custom-fallback / world-book。
- * 策略参数全部来自 config.params（由 preset.yml 单一配置源下发），引擎只负责组装。
- * 仍支持 strategyDir 懒加载自定义模板策略。
- */
-
-import { extractText, sessionEvents, sessionState } from './shared.mjs'
-import { MATCH_LOGIC, createAnchorMatcher } from './anchor-match.mjs'
-import { createTaskClassifier } from './classify-task.mjs'
-import { createPlaceholderResolver } from './fillers.mjs'
-
-const name = 'prompt-config-engine'
-
-/**
- * first-turn-anchor:首条真实用户消息后的一次性任务锚点。
- * 正则与锚句文本全部来自 config.params（由 preset.yml 单一配置源下发）。
- */
-function createFirstTurnAnchorResolver(config) {
-  const useCustom = config.params?.useCustom === true
-  const customText = typeof config.params?.text === 'string' ? config.params.text : ''
-  const buildPattern = typeof config.params?.buildPattern === 'string' ? config.params.buildPattern : ''
-  const complexPattern = typeof config.params?.complexPattern === 'string' ? config.params.complexPattern : ''
-  const firstTurnBuild = typeof config.params?.firstTurnBuild === 'string' ? config.params.firstTurnBuild : ''
-  const firstTurnInspect = typeof config.params?.firstTurnInspect === 'string' ? config.params.firstTurnInspect : ''
-  const firstTurnDeep = typeof config.params?.firstTurnDeep === 'string' ? config.params.firstTurnDeep : ''
-  const classifier = createTaskClassifier({ buildPattern, complexPattern })
-  return ({ messages }) => {
-    if (useCustom) {
-      const text = customText.trim()
-      return text.length > 0 ? { text } : null
-    }
-    if (!classifier.ready || (firstTurnBuild.length === 0 && firstTurnInspect.length === 0 && firstTurnDeep.length === 0)) {
-      return null
-    }
-    const userIndex = messages.findIndex((message) => message?.source?.kind === 'user')
-    if (userIndex < 0) return null
-    const taskText = extractText(messages[userIndex])
-    if (taskText.length === 0) return null
-    const kind = classifier.classify(taskText)
-    const anchor = kind === 'complex' ? firstTurnDeep : kind === 'build' ? firstTurnBuild : firstTurnInspect
-    return anchor.length > 0 ? { text: anchor } : null
-  }
-}
-
-/**
- * guide-auto:晋升后每轮用户消息后的弱/深度引导。
- * 正则与引导文本全部来自 config.params（由 preset.yml 单一配置源下发）。
- * 复杂任务判定 fallback 复用锚定功能的 complexPattern（guideComplexPattern
- * 冗余副本已移除）——锚定与引导是独立功能，仅分类器共用。
- */
-function createGuideAutoResolver(config) {
-  const useCustom = config.params?.useCustom === true
-  const customText = typeof config.params?.text === 'string' ? config.params.text : ''
-  const complexPattern = typeof config.params?.complexPattern === 'string' ? config.params.complexPattern : ''
-  const guideWeak = typeof config.params?.guideWeak === 'string' ? config.params.guideWeak : ''
-  const guideDeep = typeof config.params?.guideDeep === 'string' ? config.params.guideDeep : ''
-  // 复杂判定 fallback 复用锚定分类器（buildPattern 不参与引导判定）。
-  const classifier = createTaskClassifier({ complexPattern })
-  return ({ messages }) => {
-    const userIndex = messages.findIndex((message) => message?.source?.kind === 'user')
-    if (userIndex < 0) return null
-    const text = extractText(messages[userIndex])
-    if (text.length === 0) return null
-    if (useCustom) {
-      const guide = customText.trim()
-      return guide.length > 0 ? { text: guide } : null
-    }
-    if (guideWeak.length === 0 && guideDeep.length === 0) return null
-    return { text: (text.length > 120 || classifier.isComplex(text)) ? guideDeep : guideWeak }
-  }
-}
-
-/**
- * custom-fallback:自定义锚定词命中后注入一次，未命中最多两轮兜底。
- * 参数全部来自 config.params（由 preset.yml 单一配置源下发）。
- */
-function createCustomFallbackResolver(config) {
-  const promptText = config.texts.length > 0
-    ? config.texts.join('\n\n')
-    : (typeof config.params?.text === 'string' && config.params.text.length > 0 ? config.params.text : undefined)
-  // 确认词无内置默认（默认值归模板/预设）：空 = 不做词确认，只走未命中兜底注入。
-  const firstTurnWord = typeof config.params?.firstTurnWord === 'string' ? config.params.firstTurnWord : ''
-  // 确认词集合：writePreset 派生的 anchorWords 优先（锚句信号词多词 prefix，任一命中即
-  // 确认——deep 档 Let…/自定义锚句首词都覆盖）；无 anchorWords 时用显式确认词。
-  const anchorWords = Array.isArray(config.params?.anchorWords) && config.params.anchorWords.length > 0
-    ? config.params.anchorWords.map(String).filter((word) => word.length > 0)
-    : (firstTurnWord.length > 0 ? [firstTurnWord] : [])
-  // 锚定匹配经 anchor-match 引擎（prefix 模式：首轮 reasoning 开头命中任一确认词）。
-  const anchor = createAnchorMatcher({ keys: anchorWords, mode: 'prefix' })
-
-  /**
-   * 锚定确认结果缓存（`sessionState`：统一访问接口，键 / 淘汰 / 复位三项与迁移前逐条相同）。
-   *
-   * - 键类型：`session.id`（进程内快路径，真相仍是 durable 事件流）。
-   * - 淘汰策略：超 `MAX_TRACKED_SESSIONS` 时 `clear()` 全清（`evict` 缺省档）。
-   * - 复位：**不声明**——本缓存纯派生自事件流（首条 assistant/message 的 reasoning 块），
-   *   没有复位语义；未声明 `reset` 时 `sessionState` 不订阅任何事件，`ctx` 完全用不到。
-   *
-   * `create` 不可达（本缓存只用 `peek`/`set`：未命中必须扫 durable 事件，不能凭空造值）。
-   * 缓存值是布尔，`false` 是**有效命中**，所以命中判定必须用 `peek(session) !== undefined`。
-   * 未找到首条 assistant/message 时返回 `false` 且**不写缓存**（决策未定，等下一条事件）。
-   * 无 `session.id` 的会话不记账（`sessionState` 既有决定，见 `predicates.mjs`）：每次重扫
-   * 该会话自己的事件流得同一结论。旧实现把这类会话缓存到共享的 `undefined` 键上，第二个
-   * 无 id 会话会读到第一个的缓存——现在以 durable 事实为准。
-   */
-  const anchorScanned = sessionState(undefined, () => false)
-
-  const isAnchorConfirmed = (agent) => {
-    const session = agent.session
-    const cached = anchorScanned.peek(session)
-    if (cached !== undefined) return cached
-    const first = sessionEvents(session).find((event) => event.type === 'assistant/message')
-    if (first === undefined) return false
-    const content = first.data?.message?.content ?? []
-    const reasoning = content.find((block) => block.type === 'reasoning')
-    const confirmed = reasoning !== undefined && anchor.scan(String(reasoning.text ?? '')).active
-    anchorScanned.set(session, confirmed)
-    return confirmed
-  }
-
-  const assistantRounds = (agent) =>
-    sessionEvents(agent.session).filter((event) => event.type === 'assistant/message').length
-
-  return ({ agent }) => {
-    if (promptText === undefined) return null
-    const session = agent.session
-    const confirmed = isAnchorConfirmed(agent)
-    if (!confirmed && assistantRounds(agent) <= 1) return null
-    return {
-      text: promptText,
-      source: {
-        kind: 'plugin',
-        plugin: config.id,
-        form: 'notice',
-        summary: confirmed
-          ? (firstTurnWord.length > 0 ? `prompt-tool 提示词(「${firstTurnWord}」锚定确认后注入)` : 'prompt-tool 提示词(无确认词,锚定就绪后注入)')
-          : (firstTurnWord.length > 0 ? `prompt-tool 提示词(「${firstTurnWord}」未确认,兜底注入)` : 'prompt-tool 提示词(无确认词,兜底注入)'),
-      },
-    }
-  }
-}
-
-/**
- * world-book:世界书条目(角色卡 lorebook)。constant=true 恒注入(不扫 keys);
- * selective 条目扫描当前消息批文本,keys/secondaryKeys 按 selectiveLogic 组合
- * (any=任一命中 / all=副键全中 / not=副键全不中)。匹配经 anchor-match 引擎。
- */
-function createWorldBookResolver(config) {
-  if (config.params?.stWorldBook) return ({ stWorldBookSelected }) => stWorldBookSelected === true ? { text: config.texts.join('\n\n') } : null
-  const constant = config.params?.constant === true
-  // selectiveLogic：ST world_info_logic 0=AND_ANY 1=NOT_ALL 2=NOT_ANY 3=AND_ALL。
-  const rawLogic = config.params?.selectiveLogic
-  const logic = rawLogic === 3
-    ? MATCH_LOGIC.ALL
-    : (rawLogic === 1
-      ? MATCH_LOGIC.NOT
-      : (rawLogic === 2 ? MATCH_LOGIC.NOT_ANY : MATCH_LOGIC.ANY))
-  const matcher = createAnchorMatcher({
-    keys: Array.isArray(config.params?.keys) ? config.params.keys : [],
-    secondaryKeys: Array.isArray(config.params?.secondaryKeys) ? config.params.secondaryKeys : [],
-    caseSensitive: config.params?.caseSensitive === true,
-    wholeWords: config.params?.wholeWords === true,
-    // 三态透传：undefined=ST 语义自动检测（/regex/ 或含特殊字符键按正则）；
-    // 存量配置显式 true/false 仍强制对应行为。
-    useRegex: config.params?.useRegex,
-    logic,
-  })
-  // ST 语义：constant 或无任何键的条目恒注入（always active）。
-  const hasAnyKey = (Array.isArray(config.params?.keys) ? config.params.keys : [])
-      .some((key) => String(key).trim().length > 0)
-    || (Array.isArray(config.params?.secondaryKeys) ? config.params.secondaryKeys : [])
-      .some((key) => String(key).trim().length > 0)
-  const promptText = config.texts.length > 0
-    ? config.texts.join('\n\n')
-    : (typeof config.params?.text === 'string' && config.params.text.length > 0 ? config.params.text : undefined)
-  return ({ messages }) => {
-    if (promptText === undefined) return null
-    if (constant || !hasAnyKey) return { text: promptText }
-    const haystack = (Array.isArray(messages) ? messages : [])
-      .map((message) => extractText(message))
-      .filter((text) => text.length > 0)
-      .join('\n')
-    if (haystack.length === 0) return null
-    return matcher.scan(haystack).active ? { text: promptText } : null
-  }
-}
-
-/**
- * 为归一化后的提示词配置绑定策略 resolve(策略状态随提示词配置对象,不随 apply)。
- * strategyDir:外部策略模块目录(相对本文件 URL)。未声明时只允许内置策略。
- */
-export function bindResolver(config, strategyDir) {
-  switch (config.strategy) {
-    case 'placeholder': return createPlaceholderResolver(config)
-    case 'first-turn-anchor': return createFirstTurnAnchorResolver(config)
-    case 'guide-auto': return createGuideAutoResolver(config)
-    case 'custom-fallback':
-      return createCustomFallbackResolver(config)
-    case 'world-book':
-      return createWorldBookResolver(config)
-    case 'static': {
-      const texts = config.texts
-      const patch = config.templatePatch ?? {}
-      return () => {
-        if (texts.length > 0) return { ...patch, content: texts.map((item) => ({ type: 'text', text: item })) }
-        return null
-      }
-    }
-    default: {
-      // 模板专属策略:懒加载 <strategyDir>/<strategy>.mjs,模块约定导出
-      // `createResolver(config)` 或默认导出同名工厂。加载失败按单配置失败语义
-      // 抛给调用方(executor 会跳过该配置并 warnOnce)。
-      if (typeof strategyDir !== 'string' || strategyDir.length === 0) {
-        throw new TypeError(`${name}: unknown config strategy ${JSON.stringify(config.strategy)}`)
-      }
-      const moduleUrl = new URL(`${config.strategy}.mjs`, strategyDir.endsWith('/') ? strategyDir : `${strategyDir}/`)
-      let loaded
-      return async (args) => {
-        if (loaded === undefined) {
-          loaded = await import(moduleUrl.href)
-        }
-        const make = typeof loaded.createResolver === 'function'
-          ? loaded.createResolver
-          : typeof loaded.default === 'function'
-            ? loaded.default
-            : undefined
-        if (typeof make !== 'function') {
-          throw new TypeError(`${name}: strategy module ${moduleUrl.href} must export createResolver(config)`)
-        }
-        return make(config)(args)
-      }
-    }
-  }
-}
+/** 历史导入入口；内容生成真实实现归动作目录。 */
+export { bindResolver } from './actions/content.mjs'

package/engine/subagent-tool-policy-core.mjs

@@ -10,7 +10,7 @@
  *
  * 不变量：
  *   - ceiling.deny 永远优先，任何 selector / additional_tools 都不能恢复；
- *   - 有效工具集 = (profile.allow ∪ 已验证扩权) ∩ ceiling.allow ∩ presetAvailable
+ *   - 有效工具集 = (profile.allow ∪ 已验证扩权) ∩ ceiling.allow ∩ availableToolNames
  *                 − profile.deny − restrict_tools − ceiling.deny；
  *   - selector 优先级 tool_profile > character_id > task_type > 自动分类 > default；
  *   - 纯模块：不 import dsh-tools、不写文件，可在 .engine 与 host 两侧加载。
@@ -226,11 +226,11 @@ export function compileSubagentToolPolicy(raw) {
  * 解析一次实例的工具集。request 字段：
  *   tool_profile / character_id / task_type / additional_tools / restrict_tools /
  *   description / prompt（自动分类输入 = description + "\n" + prompt）。
- * availableTools：当前 preset scope 可解析的继承工具名集合。
+ * availableTools：当前 assembly scope 可解析的继承工具名集合；公开位置参数保持不变。
  */
 export function resolveSubagentToolPolicy(compiled, request, availableTools) {
   const requestRecord = request ?? {}
-  const presetAvailable = new Set(Array.isArray(availableTools) ? availableTools : [])
+  const availableToolNames = new Set(Array.isArray(availableTools) ? availableTools : [])
   const adopted = []
   const ignored = []
 
@@ -297,7 +297,7 @@ export function resolveSubagentToolPolicy(compiled, request, availableTools) {
   const profile = compiled.profileMap.get(selectedProfileId) ?? compiled.profileMap.get(compiled.defaultProfileId)
   const baseAllow = profile?.allow ?? []
 
-  // 扩权校验：requestedAdd ∩ modelExpansion.allow ∩ ceiling.allow ∩ presetAvailable。
+  // 扩权校验：requestedAdd ∩ modelExpansion.allow ∩ ceiling.allow ∩ availableToolNames。
   if (requestRecord.additional_tools !== undefined && !Array.isArray(requestRecord.additional_tools)) {
     throw new Error('additional_tools must be an array of tool names')
   }
@@ -320,7 +320,7 @@ export function resolveSubagentToolPolicy(compiled, request, availableTools) {
     for (const tool of uniqueRequestedAdd) {
       if (!compiled.expansion.allow.includes(tool)) throw new Error(`additional tool ${JSON.stringify(tool)} is not expansion-authorized`)
       if (!compiled.ceiling.allow.includes(tool)) throw new Error(`additional tool ${JSON.stringify(tool)} exceeds ceiling.allow`)
-      if (!presetAvailable.has(tool)) throw new Error(`additional tool ${JSON.stringify(tool)} is not available in this preset`)
+      if (!availableToolNames.has(tool)) throw new Error(`additional tool ${JSON.stringify(tool)} is not available in this assembly`)
       validatedAdd.push(tool)
     }
   }
@@ -332,13 +332,13 @@ export function resolveSubagentToolPolicy(compiled, request, availableTools) {
     throw new Error('restrict_tools must contain only non-empty tool names')
   }
 
-  // 有效工具集 = (baseAllow ∪ validatedAdd) ∩ ceiling.allow ∩ presetAvailable − deny 三件套。
+  // 有效工具集 = (baseAllow ∪ validatedAdd) ∩ ceiling.allow ∩ availableToolNames − deny 三件套。
   const effective = new Set([...baseAllow, ...validatedAdd])
   const ceilingAllowSet = new Set(compiled.ceiling.allow)
   const denySet = new Set([...(profile?.deny ?? []), ...requestedDeny, ...compiled.ceiling.deny])
   for (const tool of [...effective]) {
     if (!ceilingAllowSet.has(tool)) effective.delete(tool)
-    if (!presetAvailable.has(tool)) effective.delete(tool)
+    if (!availableToolNames.has(tool)) effective.delete(tool)
     if (denySet.has(tool)) effective.delete(tool)
   }
   return {

package/engine/subagent-tool-policy.mjs

@@ -2,7 +2,7 @@
  * subagent-tool-policy — agent-scoped subagent/subagent_fork shadow 工具。
  *
  * 本模块通过运行中 DSH 入口解析同一份 dsh-tools / dsh-scope，避免生成目录
- * 加载第二份 registry 类型。每个 shadow 只安装到当前 preset generation 的
+ * 加载第二份 registry 类型。每个 shadow 只安装到当前 assembly generation 的
  * descendant Agent；实例权限在 SubagentStartRequest 创建窗口冻结。
  *
  * ── 能力提供者边界（T4）────────────────────────────────────────────────────
@@ -23,7 +23,7 @@
  * 安全边界（T4 明令不得触碰，改动本模块时同样不得放宽）：
  *   - 扩权审批门 expansionApproval：requested additional_tools 必须先拿到
  *     `allowed-once`，无 approval 通道时 fail loud（不静默放行）；
- *   - fail loud 语义：策略文件存在但内容非法一律抛错；只有 ENOENT（用户关掉能力卡）
+ *   - fail loud 语义：显式内联或策略文件内容非法一律抛错；只有路径入口的 ENOENT
  *     才降级为官方委派行为。
  *
  * 登记入口：`engineProvider`（数据导出），供边界守卫消费。提供者登记与声明式触发器
@@ -64,19 +64,28 @@ const SHADOW_TOOL_NAMES = { spawn: 'subagent', fork: 'subagent_fork' }
 
 /**
  * 配置契约：白名单由字段声明派生（此前没有白名单，未知键被静默忽略）。
- * 五个键**全部**用 passthrough：迁移前它们对非字符串/非对象值都是静默取默认或忽略
+ * 五个旧键保留 passthrough：它们对非字符串/非对象值都是静默取默认或忽略
  *（policyFile / spawnProvider / forkProvider 取默认名，agentOptions 非对象则 undefined，
  * maxDepth 原样透传、由下游按 `'provider-managed'` 或数字自行判定），
- * 换成严格字段类型会引入 B2 未授权的行为变更。归一化结果与迁移前逐字段等价，
- * 唯一新增的是「未知键报错」。
+ * 内联 policy 单独完整校验；缺字段才启用路径模式，显式非法值不得降级。
  */
-export const configContract = defineConfig({
+const configFields = defineConfig({
   policyFile: passthrough((value) => (typeof value === 'string' && value.length > 0 ? value : '../subagent-tools/policy.yml')),
+  policy: passthrough(value => value),
   spawnProvider: passthrough((value) => (typeof value === 'string' && value.length > 0 ? value : 'spawn')),
   forkProvider: passthrough((value) => (typeof value === 'string' && value.length > 0 ? value : 'fork')),
   maxDepth: passthrough((value) => value),
   agentOptions: passthrough((value) => value),
 })
+export const configContract = {
+  ...configFields,
+  parse(config, plugin) {
+    const source = configFields.parse(config, plugin)
+    if (Object.hasOwn(config ?? {}, 'policy')) compileSubagentToolPolicy(source.policy)
+    else delete source.policy
+    return source
+  },
+}
 
 /**
  * 能力提供者登记（T4 边界守卫的数据源）。
@@ -98,6 +107,7 @@ function resolvePolicyFile(config) {
 }
 
 function loadCompiledPolicy(config) {
+  if (Object.hasOwn(config, 'policy')) return compileSubagentToolPolicy(config.policy)
   const raw = readFileSync(resolvePolicyFile(config), 'utf8')
   const parsed = parseYaml(raw, { logLevel: 'silent' })
   if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
@@ -210,7 +220,7 @@ async function settleForeground(run) {
   return { kind: 'foreground', runId: run.id, output: result.output }
 }
 
-function availablePresetTools(tools, compositionScope) {
+function availableAssemblyTools(tools, compositionScope) {
   return tools.schemas(compositionScope).map((schema) => schema.name)
 }
 
@@ -226,7 +236,7 @@ function createShadowTool(ctx, tools, compositionScope, compiled, kind, config)
     execute: async (args, run) => {
       validateShadowArgs(args, compiled, kind)
       if (run.agent === undefined) throw new Error('no active agent for subagent start')
-      const resolved = resolveSubagentToolPolicy(compiled, args, availablePresetTools(tools, compositionScope))
+      const resolved = resolveSubagentToolPolicy(compiled, args, availableAssemblyTools(tools, compositionScope))
       if (resolved.requiresApproval) await expansionApproval(ctx, run, toolName, resolved)
       const childProvider = ctx.subagents.getProvider(provider)
       if (childProvider === undefined) throw new Error(`subagent provider ${provider} is not registered`)
@@ -274,7 +284,7 @@ function createShadowTool(ctx, tools, compositionScope, compiled, kind, config)
 }
 
 export function apply(ctx, config) {
-  // 校验入口：未知键在挂载期报错；五个键的归一化结果与迁移前逐字段一致（见 configContract）。
+  // 内联 policy 在准备期即可校验；旧配置字段仍保留历史归一化结果。
   const source = configContract.parse(config, name)
   let compiled
   try {
@@ -290,7 +300,7 @@ export function apply(ctx, config) {
     throw new Error(`${name}: cannot load policy: ${message}`)
   }
   const compositionScope = scopeOf(ctx)
-  if (compositionScope === undefined) throw new Error(`${name}: requires a preset scope`)
+  if (compositionScope === undefined) throw new Error(`${name}: requires an assembly scope`)
   const installs = new Map()
   const installing = new WeakSet()
   let active = true

package/engine/tool-config-engine.mjs

@@ -1,12 +1,12 @@
 /**
  * tool-config-engine — 自定义工具引擎（配置驱动 → ctx.tools.register）。
  *
- * 工具定义从 configsDir 目录加载（writePreset 渲染 custom-tools/*.yml，
- * 源 = preset.yml 顶层 customTools 段），每份一个工具定义：
+ * 工具定义优先从 tools 内联读取，缺字段时兼容 configsDir 目录。
+ * 源 = module.yml 顶层 customTools 段，每份一个工具定义：
  *   id / name / description / timeoutMs / parameters（标准 JSON Schema
- *   object，writePreset 已用官方 @deepseek-ai/dsh-tools 的
+ *   object，装配方已用官方 @deepseek-ai/dsh-tools 的
  *   parameterSchemaSpecToJsonSchema / valueSchemaSpecToJsonSchema 把
- *   preset.yml 的 dsh-tools DSL 转换）/ output.schema / execute.{kind, ...}
+ *   module.yml 的 dsh-tools DSL 转换）/ output.schema / execute.{kind, ...}
  *
  * 执行器（kind）：
  *   shell    — 命令执行（execFile 无 shell 解析，env 白名单，cwd=会话工作区）
@@ -18,7 +18,7 @@
  *   ask-user — approval 通道询问用户（结果文本化）
  *
  * 安全：行 config.requireApproval = [kind...] 时该执行器先过 approval 门
- * （无 approval 服务则拒绝）；单条定义非法 warnOnce 跳过（不挂整行）。
+ * （无 approval 服务则拒绝）；内联定义整批校验，旧路径模式保留逐条告警跳过。
  * 工具注册经 disposer 契约（keepDisposer），插件卸载自动撤销。
  *
  * ── 能力提供者边界（T4）────────────────────────────────────────────────────
@@ -27,7 +27,7 @@
  *   - 会给模型提供可调用能力（注册工具 / 域 / 服务）的 → 能力提供者；
  *   - 干预流程（改提示词、改装配、裁决、追加）的 → 声明式触发器。
  * 因此本模块**不接入** engine/trigger.mjs：它不订阅装配 waterfall，也没有
- * when/do 声明，只在装配期把 preset.yml 的 customTools 段物化出的工具注册进官方
+ * when/do 声明，只在装配期把 module.yml 的 customTools 段编译出的工具注册进官方
  * registry。强行并进触发器会让引擎同时承担「提供能力」与「干预流程」两种职责。
  *
  * 样板收敛：
@@ -347,8 +347,8 @@ function sanitizeDescription(text) {
   return text.replace(/\{\{([^{}]*)\}\}/g, '{$1}')
 }
 
-/** 单份工具定义文件 → 编译为完整官方 ToolDefinition（不含 id）。
- *  parameters/output.schema 已是 writePreset 物化的标准 JSON Schema；无参数
+/** 单份工具定义 → 编译为完整官方 ToolDefinition（不含 id）。
+ *  parameters/output.schema 已是装配方编译的标准 JSON Schema；无参数
  *  工具补空 object Schema（真实 ctx.tools.schemas() 需要 parameters 存在）。 */
 function compileTool(ctx, def, requireApproval) {
   return {
@@ -364,20 +364,20 @@ function compileTool(ctx, def, requireApproval) {
   }
 }
 
-/** 工具定义文件加载（*.yml / *.json；与 prompt-config-engine configsDir 同构）。 */
-function loadToolFiles(dirUrl, presetRootUrl) {
+/** 兼容独立入口的工具定义文件加载（*.yml / *.json）。 */
+function loadToolFiles(dirUrl, resourceRootUrl) {
   const resolved = isAbsolute(dirUrl)
     ? pathToFileURL(dirUrl).href
     : dirUrl
   const dir = new URL(resolved.endsWith('/') ? resolved : `${resolved}/`, import.meta.url)
   const localDir = fileURLToPath(dir)
-  // 相对 configsDir 只允许解析到预设根内：防组合行声明越界目录；绝对路径（显式配置/
-  // 测试桩）保持允许。预设根基准显式注入优先（引擎由插件包提供时必需），缺省沿用
+  // 相对 configsDir 只允许解析到资源允许根内；绝对路径（显式配置/测试桩）保持允许。
+  // 允许根显式注入优先（引擎由插件包提供时必需），缺省沿用
   // 「引擎上一级目录」这一历史布局推导。
   if (!isAbsolute(dirUrl)) {
-    const presetRoot = fileURLToPath(presetRootUrl ?? new URL('../..', import.meta.url)).replace(/[\\\\/]$/, '')
-    if (localDir !== presetRoot && !localDir.startsWith(presetRoot + sep)) {
-      throw new Error(`${name}: configsDir ${JSON.stringify(dirUrl)} escapes preset root`)
+    const resourceRoot = fileURLToPath(resourceRootUrl ?? new URL('../..', import.meta.url)).replace(/[\\\\/]$/, '')
+    if (localDir !== resourceRoot && !localDir.startsWith(resourceRoot + sep)) {
+      throw new Error(`${name}: configsDir ${JSON.stringify(dirUrl)} escapes resource root`)
     }
   }
   const files = readdirSync(localDir, { withFileTypes: true })
@@ -396,40 +396,61 @@ function loadToolFiles(dirUrl, presetRootUrl) {
  * 配置契约：白名单由字段声明派生（此前没有白名单，未知键被静默忽略）。
  * requireApproval 迁移前对**非数组取 `[]`**、对数组**过滤掉非字符串项**（宽容而非报错），
  * configsDir 对非字符串/空串取默认值——两者都用 passthrough 保住该语义。
- * 本任务只新增「未知键报错」，缺键与错类型的既有行为逐字段不变。
+ * tools 是显式内联输入，缺字段与空数组分开处理；旧字段保留原来的宽容语义。
  */
-export const configContract = defineConfig({
+const configFields = defineConfig({
   configsDir: passthrough((value) => (typeof value === 'string' && value.length > 0 ? value : './custom-tools')),
+  tools: passthrough(value => value),
   requireApproval: passthrough((value) => (Array.isArray(value) ? value.filter((kind) => typeof kind === 'string') : [])),
-  // 预设根基准（绝对 file URL）：引擎由插件包提供时由装配期注入，替代引擎位置推导。
+  // 资源允许根（绝对 file URL），保留旧名输入；两者都不改变历史路径授权边界。
+  resourceRoot: passthrough((value) => (typeof value === 'string' && value.length > 0 ? value : undefined)),
   presetRoot: passthrough((value) => (typeof value === 'string' && value.length > 0 ? value : undefined)),
 })
+export const configContract = {
+  ...configFields,
+  parse(config, plugin) {
+    const source = configFields.parse(config, plugin)
+    if (source.resourceRoot !== undefined && source.presetRoot !== undefined && source.resourceRoot !== source.presetRoot) {
+      throw new TypeError(`${plugin}: resourceRoot and presetRoot conflict`)
+    }
+    source.resourceRoot ??= source.presetRoot
+    if (Object.hasOwn(config ?? {}, 'tools')) {
+      if (!Array.isArray(source.tools)) throw new TypeError(`${plugin}: tools must be an array of tool definitions`)
+      // 在任何注册前完整校验，坏内联不得回落旧目录或留下半份工具。
+      for (const definition of source.tools) validateDefinition(definition)
+    } else delete source.tools
+    return source
+  },
+}
 
 /**
  * 能力提供者登记（T4 边界守卫的数据源）。
- * `provides.kind === 'dynamic'`：模型可见的工具名由 preset.yml 的 customTools 段在
- * 装配期决定（物化为 custom-tools/*.yml），引擎侧无法静态枚举——守卫只断言登记形状、
+ * `provides.kind === 'dynamic'`：模型可见的工具名由 module.yml 的 customTools 段在
+ * 装配期决定，引擎侧无法静态枚举——守卫只断言登记形状、
  * 注册通道，以及「提供者不导出触发器声明」这条互斥。
  */
 export const engineProvider = {
   kind: 'provider',
   moduleId: name,
   registers: 'tools',
-  provides: { kind: 'dynamic', source: 'preset.yml#customTools → custom-tools/*.yml' },
+  provides: { kind: 'dynamic', source: 'module.yml#customTools → tools' },
 }
 
-/** 插件入口：扫描 configsDir 注册全部自定义工具。 */
+/** 插件入口：优先注册内联 tools，缺字段时兼容 configsDir。 */
 export function apply(ctx, config) {
-  const { configsDir: dirName, requireApproval, presetRoot: rawPresetRoot } = configContract.parse(config, name)
-  const presetRootUrl = rawPresetRoot === undefined
-    ? undefined
-    : new URL(rawPresetRoot.endsWith('/') ? rawPresetRoot : `${rawPresetRoot}/`)
-  let definitions = []
-  try {
-    definitions = loadToolFiles(dirName, presetRootUrl)
-  } catch (error) {
-    ctx.logger?.warn(`${name}: cannot load ${dirName}: ${error?.message ?? error}`)
-    return
+  const source = configContract.parse(config, name)
+  const { configsDir: dirName, requireApproval, resourceRoot: rawResourceRoot } = source
+  let definitions = source.tools
+  if (!Object.hasOwn(source, 'tools')) {
+    const resourceRootUrl = rawResourceRoot === undefined
+      ? undefined
+      : new URL(rawResourceRoot.endsWith('/') ? rawResourceRoot : `${rawResourceRoot}/`)
+    try {
+      definitions = loadToolFiles(dirName, resourceRootUrl)
+    } catch (error) {
+      ctx.logger?.warn(`${name}: cannot load ${dirName}: ${error?.message ?? error}`)
+      return
+    }
   }
   for (const def of definitions) {
     try {