dsh-plugin-prompt-tool 3.0.1 → 3.0.2

package/engine/actions/catalog.mjs

@@ -74,7 +74,8 @@ export const ACTION_KINDS = Object.freeze({
     note: '一份声明拥有工具的可见面：allow/deny 名单、requireMatch、发现工具。名单语义对齐官方 '
       + 'ToolRestriction 的 and/or（同时给时先按 allow 保留、再按 deny 剔除）。deny 走 guard（本层与晚到工具）'
       + '与 restrict（继承的全局工具）；allow 只有 restrict 能覆盖全局工具，本层注册无法在执行层「只保留」——'
-      + '这是官方 restrict 的边界，不是本动作的取舍。',
+      + '这是官方 restrict 的边界，不是本动作的取舍。requireMatch 表达「名单与装配面整体错位」：'
+      + '名单里的名字一个都不存在才整面放宽，部分缺失只留诊断；解锁名不参与判定。',
   },
   'request-params': {
     title: '改模型请求参数',

package/engine/actions/shared.mjs

@@ -37,20 +37,28 @@ export function createMask(source, label, plugin, allowExtra) {
     /** 动态白名单的落点（活集合，由调用方每轮重填）；未声明 allowFrom 时不存在。 */
     allowExtra,
     /**
-     * fail-open 兜底开关（**可选**，缺省 false）：原 `tool-bootstrap` 的语义是
-     * 「keep 名单里的工具在本次装配目录里一个都不存在 → 放弃裁剪、暴露完整目录」，而原
-     * `tool-filter` 的同名场景是**照名单裁成空目录**。两种语义都真实存在，所以这里
-     * **不设默认**——要兜底的声明自己写 `requireMatch: true`。把某一个模块的特有语义当成
-     * 通用默认，会让另一个声明路径的行为被悄悄改掉（这正是对拍抓出来的）。
+     * fail-open 兜底开关（**可选**，缺省 false）：判据是「这份名单与装配面整体错位」——
+     * 名单里的名字**一个都不存在**时放弃裁剪、暴露完整目录；部分缺失只留诊断，收窄照常
+     * 生效（提供方被替换或关闭是正常部署差异，见 {@link toolSurfacePlan}）。原
+     * `tool-bootstrap` 的同名语义就是「一个都不存在 → 放弃裁剪」，而原 `tool-filter` 是
+     * 「永远照名单裁」；两种语义都真实存在，所以这里**不设默认**——要兜底的声明自己写
+     * `requireMatch: true`。把某一个模块的特有语义当成通用默认，会让另一个声明路径的行为
+     * 被悄悄改掉（这正是对拍抓出来的）。
      */
     requireMatch: source?.requireMatch === true,
-    /** 与 tool-filter 的名单判据 / Layer.admits 同一判据（tool-filter 模块已删除，判据保留）。 */
-    blocks: (toolName) => {
+    /**
+     * 与 tool-filter 的名单判据 / Layer.admits 同一判据（tool-filter 模块已删除，判据保留）。
+     *
+     * 第二个参数是**解锁项快照**：allowExtra 是跨 agent 共享的活集合，每次装配都会 clear 后
+     * 按当前会话重填；执行闸在该装配之后才被调用，必须读自己会话的冻结快照，否则别的会话
+     * （或探针装配）会把本会话的解锁名抹掉。缺省仍是活集合，供同一次装配内的裁剪使用。
+     */
+    blocks: (toolName, extra = allowExtra) => {
       if (typeof toolName !== 'string' || toolName.length === 0) return false
       // 保留传输不参与任何名单：allow 没点名也必须留下，deny 已在挂载期拒绝。
       if (toolName === RUN_CODE) return false
       if (deny !== undefined && deny.has(toolName)) return true
-      if (allowExtra?.has(toolName) === true) return false
+      if (extra?.has(toolName) === true) return false
       // 声明了 allow、或声明了 allowFrom（= 白名单模式，静态名单视为空集），未点名即裁掉。
       return (allow !== undefined || allowExtra !== undefined) && allow?.has(toolName) !== true
     },
@@ -60,17 +68,23 @@ export function createMask(source, label, plugin, allowExtra) {
 /**
  * 工具可见面的单一判据：装配目录、`tools:sdk` 正文与执行闸共用同一份 fail-open 决定。
  *
- * `available` = 目录名 ∪ SDK 正文名；`required` = 静态 allow ∪ 动态解锁项，再剔掉
+ * `available` = 目录名 ∪ SDK 正文名；`required` 只取**静态 allow**，再剔掉
  * `run_code`（保留传输）与 `mask.blocks()` 为真的名字（deny 覆盖者不该被要求存在）。
- * 缺项时三面必须一起放宽——只放宽一面会让模型看到的与能调的不一致。
+ *
+ * 放宽条件是「名单里的名字**一个都不存在**」：那才说明装配面与声明整体错位（换了一套
+ * 部署/平台）。只缺一部分是提供方被替换或关掉的正常部署差异——照常收窄，缺的工具由发现
+ * 通道补位，替换提供方的名字由部署层名单登记。解锁名（allowExtra）**不参与判定**：它是只做
+ * 加法的提示，若参与，模型解锁一个拼错或已改名的工具就能关掉收窄。
+ *
+ * 放宽时三面必须一起放宽——只放宽一面会让模型看到的与能调的不一致。
  */
 export function toolSurfacePlan(mask, available) {
   // 动作层的挂载期校验（prepareToolVisibility）已拒绝 requireMatch + 无 allow。
   const required = mask.requireMatch
-    ? [...new Set([...(mask.allow ?? []), ...(mask.allowExtra ?? [])])].filter((name) => name !== RUN_CODE && !mask.blocks(name))
+    ? [...new Set(mask.allow ?? [])].filter((name) => name !== RUN_CODE && !mask.blocks(name))
     : []
   const missing = required.filter((name) => !available.has(name))
-  return { failOpen: missing.length > 0, missing }
+  return { failOpen: required.length > 0 && missing.length === required.length, missing }
 }
 
 export function requireString(value, label, plugin) {

package/engine/actions/tool-visibility.mjs

@@ -13,8 +13,10 @@
  *
  * 名单语义对齐官方 ToolRestriction（deepseek-harness packages/core/tools/src/index.ts:701-706）：
  * allow 与 deny 可以同时给，判据是「先按 allow 保留，再按 deny 剔除」。requireMatch 只在
- * allow 模式有意义：名单里任一工具在目录与 SDK 正文的并集里都找不到，就放弃裁剪、暴露完整目录（fail-open）并告警——
- * 收窄错了会让当前工作流调不到工具，比多花上下文严重。
+ * allow 模式有意义，判据是「这份名单与装配面整体错位」：名单里的名字**一个都不在**目录与
+ * SDK 正文的并集里，才放弃裁剪、暴露完整目录（fail-open）并告警。只缺一部分是提供方被
+ * 替换或关闭的正常部署差异，收窄照常生效、缺项只留一条诊断；解锁名是只做加法的提示，
+ * 不参与这个判定。
  *
  * 执行边界：deny 同时用 restrict（继承面）与 guard（本层/晚到）；allow 不用 restrict——
  * 它的 allow 只能收继承面名字，而 `schemas()` 全局视图会漏掉预设/祖先层，局部 allow 会
@@ -110,7 +112,8 @@ export function prepareToolVisibility(action, plugin) {
     const capability = createAgentCapability((agent) => {
       const tools = agent?.ctx?.tools
       if (tools === undefined) return undefined
-      const state = { failOpen: false }
+      // unlocked：本会话装配时冻结的解锁名快照（await next() 期间别的装配会重填共享集合）。
+      const state = { failOpen: false, unlocked: undefined }
       const disposers = []
       try {
         const known = toolScopeSnapshot(tools).globalNames
@@ -135,7 +138,7 @@ export function prepareToolVisibility(action, plugin) {
             const toolName = exec?.name
             if (toolName === RUN_CODE || typeof toolName !== 'string' || toolName.length === 0) return undefined
             if (deny?.has(toolName)) return `${label}: tool ${JSON.stringify(toolName)} is denied by tool-visibility`
-            if (mask.allow !== undefined && !state.failOpen && mask.blocks(toolName)) {
+            if (mask.allow !== undefined && !state.failOpen && mask.blocks(toolName, state.unlocked)) {
               return `${label}: tool ${JSON.stringify(toolName)} is not allowed by tool-visibility`
             }
             return undefined
@@ -148,8 +151,9 @@ export function prepareToolVisibility(action, plugin) {
       return { disposers, data: state }
     })
 
-    const syncGate = (agent) => {
-      const key = `${maskKey(mask)}|unlock:${allowExtra === undefined ? '' : [...allowExtra].sort().join(',')}`
+    // 重挂判定用**本会话的快照**：共享集合在别的装配里会被重填，不能当身份。
+    const syncGate = (agent, unlocked) => {
+      const key = `${maskKey(mask)}|unlock:${unlocked === undefined ? '' : [...unlocked].sort().join(',')}`
       capability.sync(agent, key)
     }
 
@@ -183,8 +187,11 @@ export function prepareToolVisibility(action, plugin) {
           fillUnlocked(allowExtra, context?.session ?? context?.agent?.session, unlock.tool, unlock.key, warnOnce, plugin, label)
         }
       }
+      // 在 await next() 之前冻结本会话的解锁名：之后的裁剪与执行闸都读这一份，
+      // 共享的 allowExtra 可能被并发的另一次装配（别的会话 / 探针）清空重填。
+      const unlocked = allowExtra === undefined ? undefined : new Set(allowExtra)
       try {
-        syncGate(context?.agent)
+        syncGate(context?.agent, unlocked)
       } catch (error) {
         // 闸注册失败必须留痕；呈现面照常结算，绝不把异常抛给装配。
         warnOnce(`${plugin}: tool-visibility action ${label} failed to sync execution gate: ${String(error?.message ?? error)}`)
@@ -204,16 +211,23 @@ export function prepareToolVisibility(action, plugin) {
         // 没有工具面可观（既无目录也无 SDK 正文）时不裁剪、不告警、不动执行闸：
         // 空 surface 不等于「名单全缺」；空目录（tools=[]）仍是真实观测，照旧 fail-open。
         if (!Array.isArray(result.tools) && sdkSection === undefined) return result
-        // 三面（目录 / 正文 / 执行闸）共用这一份判断：缺项就整体放宽，呈现与执行不得两套口径。
+        // 三面（目录 / 正文 / 执行闸）共用这一份判断：名单全缺才整体放宽，呈现与执行不得两套口径。
         const plan = toolSurfacePlan(mask, available)
         const state = capability.get(context?.session ?? context?.agent?.session)
-        if (state !== undefined) state.data.failOpen = plan.failOpen
+        if (state !== undefined) {
+          state.data.failOpen = plan.failOpen
+          state.data.unlocked = unlocked
+        }
         if (plan.failOpen) {
-          // 去重键固定到动作：缺项名随解锁历史变化，不能让每个新集合各占一条 warnOnce。
-          warnOnce(`${plugin}: tool-visibility action ${label}: requireMatch tools absent (${plan.missing.join(', ')}) — exposing the full tool set (fail-open)`, `${plugin}: tool-visibility action ${label}: requireMatch fail-open`)
+          // 去重键固定到动作：缺项名随部署变化，不能让每个新集合各占一条 warnOnce。
+          warnOnce(`${plugin}: tool-visibility action ${label}: none of the resident tools exist (${plan.missing.join(', ')}) — exposing the full tool set (fail-open)`, `${plugin}: tool-visibility action ${label}: requireMatch fail-open`)
         } else {
+          // 部分缺失不改变裁剪，但必须留痕：否则「某个常驻工具为什么不见了」只能靠猜。
+          if (plan.missing.length > 0) {
+            warnOnce(`${plugin}: tool-visibility action ${label}: resident tools absent (${plan.missing.join(', ')}) — narrowing continues; register replacement providers in the deployment allow list`, `${plugin}: tool-visibility action ${label}: resident tools absent`)
+          }
           if (Array.isArray(result.tools)) {
-            const kept = result.tools.filter((tool) => !mask.blocks(tool?.name))
+            const kept = result.tools.filter((tool) => !mask.blocks(tool?.name, unlocked))
             if (kept.length !== result.tools.length) result = { ...result, tools: kept }
           }
           if (Array.isArray(result.sections)) {
@@ -227,7 +241,7 @@ export function prepareToolVisibility(action, plugin) {
               }
               const names = mask.allow === undefined
                 ? mask.deny
-                : new Set([...presentNames()].filter((name) => mask.blocks(name)))
+                : new Set([...presentNames()].filter((name) => mask.blocks(name, unlocked)))
               if (names === undefined || names.size === 0) return section
               const stripped = stripSdkDeclarations(section.text, names)
               if (stripped === section.text) return section

package/engine/fillers.mjs

@@ -4,6 +4,7 @@
  */
 
 import { getService, parseToolNames } from './shared.mjs'
+import { toolScopeSnapshot } from './tool-scope.mjs'
 import { machinePaths } from './machine-paths.mjs'
 import { SAFE_ENV_KEYS } from './env-safety.mjs'
 import { createInstructionHintResolver } from './instruction-hint.mjs'
@@ -16,7 +17,22 @@ function explicitTemplate(config) {
   return texts.length > 0 ? texts.join('\n\n') : typeof config.params?.text === 'string' ? config.params.text : ''
 }
 
-/** 只读同规则工具面声明；文案、条件和投递仍归普通注入动作。 */
+/**
+ * 只读同规则工具面声明；文案、条件和投递仍归普通注入动作。
+ * RESIDENT_TOOLS 只列**当前可见**的常驻工具：部署层名单可以登记替换提供方（如 dsh-ops 的
+ * ops_bash），但该插件未必安装；向模型宣告一个不存在的常驻工具会把「解锁」变成错误前提。
+ * 观测到工具面但一个常驻名都不在时（requireMatch 全缺/放宽场景）跳过提示；
+ * 观测不到工具面（服务缺失或读取失败）才回落声明名单——「没看到」不等于「都没有」。
+ */
+function visibleToolNames(ctx, agent) {
+  try {
+    const tools = getService(ctx, 'tools')
+    if (tools === undefined || typeof tools.schemas !== 'function') return undefined
+    return new Set(toolScopeSnapshot(tools, agent).visible.map((schema) => schema?.name))
+  } catch {
+    return undefined
+  }
+}
 function createToolCatalogResolver(config) {
   if (config.params?.templateEvaluation === true) throw new TypeError('tool-catalog is read-only and does not support templateEvaluation')
   if (typeof config.params?.action !== 'string' || config.params.action.trim().length === 0) {
@@ -28,12 +44,20 @@ function createToolCatalogResolver(config) {
     const source = config.toolCatalogSource
     if (source === undefined) throw new TypeError('tool-catalog requires a same-rule tool-visibility action')
     const deny = new Set(source.deny ?? [])
-    const resident = [...new Set(source.allow)].filter(tool => !deny.has(tool))
+    const declared = [...new Set(source.allow)].filter(tool => !deny.has(tool))
     const adapter = source.discovery === undefined ? undefined
       : getService(ctx, DISCOVERY_SERVICE)?.get?.(agent, source.discovery.kind)
     if (source.discovery !== undefined && typeof adapter?.tool !== 'string') {
       throw new Error(`tool-catalog discovery adapter ${source.discovery.kind} is unavailable`)
     }
+    let resident = declared
+    const visible = visibleToolNames(ctx, agent)
+    if (visible !== undefined) {
+      const present = declared.filter((name) => visible.has(name))
+      // 观测到全缺时不宣告任何常驻工具：与 requireMatch 放宽同源，避免「解锁」建在错误前提上。
+      if (present.length === 0) return null
+      resident = present
+    }
     return { text, variables: { RESIDENT_TOOLS: resident.join(', '), DISCOVERY_TOOL: adapter?.tool ?? '' } }
   }
 }

package/lib/client.js

@@ -10549,7 +10549,7 @@ window.__ModuleLoader__.load({
 			"triggers.label.allowFrom": "按需解锁",
 			"triggers.label.tool": "发现工具",
 			"triggers.label.key": "键名",
-			"triggers.label.requireMatch": "名单工具缺失时保留完整目录",
+			"triggers.label.requireMatch": "名单工具全部缺失时保留完整目录",
 			"triggers.label.keep": "仅保留",
 			"triggers.label.remove": "移除",
 			"triggers.label.clear": "清空全部",
@@ -10773,7 +10773,7 @@ window.__ModuleLoader__.load({
 			"triggers.label.allowFrom": "On-demand unlocking",
 			"triggers.label.tool": "Discovery tool",
 			"triggers.label.key": "Key",
-			"triggers.label.requireMatch": "Keep the full catalog if a listed tool is missing",
+			"triggers.label.requireMatch": "Keep the full catalog only if no listed tool exists",
 			"triggers.label.keep": "Keep only",
 			"triggers.label.remove": "Remove",
 			"triggers.label.clear": "Clear all",
@@ -18457,7 +18457,7 @@ window.__ModuleLoader__.load({
 			"rules.surface.dynamic": "按需解锁",
 			"rules.surface.discoveryTool": "发现工具",
 			"rules.surface.argumentKey": "名单参数",
-			"rules.surface.requireMatch": "工具缺失时保留全部",
+			"rules.surface.requireMatch": "工具全部缺失时保留全部",
 			"rules.surface.textMode": "过滤方式",
 			"rules.surface.unrestricted": "不过滤",
 			"rules.surface.keep": "仅保留",
@@ -18582,7 +18582,7 @@ window.__ModuleLoader__.load({
 			"rules.surface.dynamic": "Unlock on demand",
 			"rules.surface.discoveryTool": "Discovery tool",
 			"rules.surface.argumentKey": "List argument",
-			"rules.surface.requireMatch": "Keep all if any tool is missing",
+			"rules.surface.requireMatch": "Keep all only if no tool exists",
 			"rules.surface.textMode": "Filter",
 			"rules.surface.unrestricted": "No filter",
 			"rules.surface.keep": "Keep only",