dsh-plugin-tool-management 0.12.0 → 0.13.0

package/lib/context-inject.js

@@ -291,7 +291,11 @@ const DOMAIN_FRAME = {
     skills: {
         title: '本机技能目录',
         cue: '需要某项能力时，先在这里找。',
-        how: '本预设没有官方 `skill` 工具：要正文用 `skill_manager_list` 取源文件路径再读；目录只有摘要，读完再照做。',
+        // 两句都只在预设没挂官方 `skill` 工具时出现，差别只在点名不点名那个取正文的工具
+        // （工具被用户在兼容页关掉时不点名 —— 点名一个模型手里没有的工具只会让它去猜名字）。
+        how: (toolHidden) => toolHidden('skill_manager_read')
+            ? '本预设没有官方 `skill` 工具：目录只有摘要，读完再照做。'
+            : '本预设没有官方 `skill` 工具：要正文用 `skill_manager_read`（按名字直接给正文与路径）；目录只有摘要，读完再照做。',
         supersede: '本份目录取代本次会话中更早注入的同类目录；只列当前可调用的技能。',
     },
     subagents: {
@@ -301,7 +305,11 @@ const DOMAIN_FRAME = {
         // 委派工具（`subagent` / `subagent_fork`）不带人设，而此前没有任何一句话说明何时该
         // 用谁 —— 模型在"审查刚读过的 README"时选了 `subagent_fork`（fork 能继承已读内容、
         // 省一次复述）。现在人设通道也有 `inherit`（同一套 fork 机制），分界只剩"要不要后台跑"。
-        how: '贴合人设的任务一律用 `subagent_manager_run`（要它看到本次会话就开 `inherit`）；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。',
+        // 带人设的委派工具被关掉时改说"本会话没有这条通道"：不说的话，模型看到有人设目录却
+        // 找不到对应的工具，会去拿官方那两个凑（它们不接受人设，等于白跑一趟）。
+        how: (toolHidden) => toolHidden('subagent_manager_run')
+            ? '本会话没有带人设的委派工具；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。'
+            : '贴合人设的任务一律用 `subagent_manager_run`（要它看到本次会话就开 `inherit`）；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。',
         supersede: '本份目录取代本次会话中更早注入的同类目录。',
     },
     prompt: {
@@ -357,11 +365,12 @@ export function escapeFrameBody(body) {
  *     同时把**正文也包进标记里**（此前只有引导语在标记内、正文裸奔）—— 官方两条注入行都是
  *     整条包住的，正文里的用户自由文本更需要这层来源标记。
  */
-export function renderDomainText(section) {
+export function renderDomainText(section, toolHidden = () => false) {
     const frame = domainFrame(section.key, section.label);
     const lines = [FRAME_OPEN, `## ${frame.title}`, `**${frame.cue}**`];
-    if (frame.how !== undefined)
-        lines.push(frame.how);
+    const how = typeof frame.how === 'function' ? frame.how(toolHidden) : frame.how;
+    if (how !== undefined)
+        lines.push(how);
     lines.push(frame.supersede, '', escapeFrameBody(section.text), FRAME_CLOSE);
     return lines.join('\n');
 }
@@ -523,12 +532,22 @@ export function createContextInjector(deps) {
     // 最近活跃的会话（WeakRef：诊断用，不阻止会话被回收）。每次 pre-step 都刷新 ——
     // 包括"空 turn 提前返回"和"这一步没有内容可发"的分支，页面才能如实说"没投过"。
     let lastAgent = null;
-    const delivered = { count: 0, lastAt: null, byDomain: {} };
-    // 采纳遥测：每个域一份计数 + 全局观测面。
-    const adoption = {};
-    for (const key of INJECT_DOMAIN_KEYS)
-        adoption[key] = { injected: 0, used: 0, adopted: 0, lastUsedAt: null };
-    const observed = { toolCalls: 0, lastAt: null };
+    const emptyLedger = () => {
+        const adoption = {};
+        for (const key of INJECT_DOMAIN_KEYS)
+            adoption[key] = { injected: 0, used: 0, adopted: 0, lastUsedAt: null };
+        return { delivered: { count: 0, lastAt: null, byDomain: {} }, adoption, observed: { toolCalls: 0, lastAt: null } };
+    };
+    const ledgers = new WeakMap();
+    /** 取（或新建）这个会话的账本。pre-step 与工具调用两条路都从这里过。 */
+    const ledgerFor = (agent) => {
+        let ledger = ledgers.get(agent);
+        if (ledger === undefined) {
+            ledger = emptyLedger();
+            ledgers.set(agent, ledger);
+        }
+        return ledger;
+    };
     // 每个 agent 最近一步"在上下文里"的域集合 —— 采纳判定要回答的是"调用发生时正文在不在眼前"。
     // WeakMap：不阻止会话被回收（与 lastAgent 同一考虑）。
     const liveDomainsByAgent = new WeakMap();
@@ -544,6 +563,8 @@ export function createContextInjector(deps) {
         catch {
             agent = undefined;
         }
+        // 面板读的是**这一段对话**的账本；会话已经被回收了就没有账本可读，全零 + `hasAgent:false`。
+        const ledger = agent === undefined ? emptyLedger() : ledgerFor(agent);
         const visible = agent === undefined
             ? new Map()
             : newestDomainTexts(agent, LIVE_KINDS);
@@ -567,13 +588,29 @@ export function createContextInjector(deps) {
                 state,
                 bytes: bytesOf(text),
                 text,
-                adoption: { ...adoption[key] },
+                adoption: { ...ledger.adoption[key] },
             };
         });
+        // 成本汇总：只做算术，不碰投递语义（这条视图的存在不改任何发送文本，因此不会触发重发）。
+        let liveBytes = 0;
+        let injectedBytes = 0;
+        let topDomain = null;
+        let mostDelivered = null;
+        for (const row of rows) {
+            liveBytes += row.bytes;
+            const sends = ledger.delivered.byDomain[row.key] ?? 0;
+            const spent = row.bytes * sends;
+            injectedBytes += spent;
+            if (spent > 0 && (topDomain === null || spent > topDomain.bytes))
+                topDomain = { key: row.key, label: row.label, bytes: spent };
+            if (sends > 0 && (mostDelivered === null || sends > mostDelivered.count))
+                mostDelivered = { key: row.key, label: row.label, count: sends };
+        }
         return {
             hasAgent: agent !== undefined,
-            delivered: { count: delivered.count, lastAt: delivered.lastAt, byDomain: { ...delivered.byDomain } },
-            observed: { toolCalls: observed.toolCalls, lastAt: observed.lastAt },
+            delivered: { count: ledger.delivered.count, lastAt: ledger.delivered.lastAt, byDomain: { ...ledger.delivered.byDomain } },
+            observed: { toolCalls: ledger.observed.toolCalls, lastAt: ledger.observed.lastAt },
+            cost: { liveBytes, injectedBytes, topDomain, mostDelivered },
             domains: rows,
         };
     };
@@ -583,17 +620,30 @@ export function createContextInjector(deps) {
             if (key === undefined)
                 return;
             const at = Date.now();
-            observed.toolCalls += 1;
-            observed.lastAt = at;
-            const row = adoption[key];
+            // 记在**发起这次调用的那个会话**的账上。`exec.agent` 与 pre-step 的 `payload.agent`
+            // 是同一个对象（dsh-scope 的不变量要求，见 review/后续方向.md §2 末），所以这里
+            // 落账的会话与上面 `liveDomainsByAgent` 记现场的会话必然一致。
+            let owner = typeof agent === 'object' && agent !== null ? agent : undefined;
+            if (owner === undefined) {
+                try {
+                    owner = lastAgent ? lastAgent.deref() : undefined;
+                }
+                catch {
+                    owner = undefined;
+                }
+            }
+            if (owner === undefined)
+                return;
+            const ledger = ledgerFor(owner);
+            ledger.observed.toolCalls += 1;
+            ledger.observed.lastAt = at;
+            const row = ledger.adoption[key];
             row.used += 1;
             row.lastUsedAt = at;
             // 采纳判定：调用发生时该域正文正在这个会话的上下文里。
-            if (typeof agent === 'object' && agent !== null) {
-                const liveKeys = liveDomainsByAgent.get(agent);
-                if (liveKeys !== undefined && liveKeys.has(key))
-                    row.adopted += 1;
-            }
+            const liveKeys = liveDomainsByAgent.get(owner);
+            if (liveKeys !== undefined && liveKeys.has(key))
+                row.adopted += 1;
         }
         catch { /* 遥测绝不能影响工具本身 */ }
     };
@@ -632,6 +682,9 @@ export function createContextInjector(deps) {
             if (!agent)
                 return decision;
             if (typeof agent === 'object') {
+                // 账本先建好：下面任何一条提前返回（空 turn / 没内容可发）都要能在实况里读到
+                // "这一段对话投了 0 次"，而不是读到上一段对话的数字。
+                ledgerFor(agent);
                 try {
                     lastAgent = new WeakRef(agent);
                 }
@@ -687,9 +740,12 @@ export function createContextInjector(deps) {
             const published = new Set();
             // 域声明按 key 索引：来源文件（`files`）只在真要发消息时取，所以要能从这里回查声明。
             const domainOf = new Map(domains.map((domain) => [domain.key, domain]));
+            // 工具表开关本步读一次（同步快照）：`how` 行里点名工具的那几句据此换话术。
+            const hiddenNow = deps.hiddenTools !== undefined ? deps.hiddenTools() : null;
+            const toolHidden = hiddenNow === null ? () => false : (name) => hiddenNow.has(name);
             for (const section of sections) {
                 published.add(section.key);
-                const text = renderDomainText(section);
+                const text = renderDomainText(section, toolHidden);
                 const current = visible.get(section.key);
                 if (current !== undefined && current.text === text)
                     continue;
@@ -708,6 +764,7 @@ export function createContextInjector(deps) {
             }
             // 曾经注入过、这一轮没有内容的域 → 一条「已清空」；从没注入过的域什么都不用说。
             const labelOf = new Map(domains.map((domain) => [domain.key, domain.label]));
+            const clearedKeys = new Set();
             for (const key of INJECT_DOMAIN_KEYS) {
                 if (published.has(key))
                     continue;
@@ -719,17 +776,29 @@ export function createContextInjector(deps) {
                     continue;
                 additions.push(clearedMessage(key, label));
                 appended.push(key);
+                clearedKeys.add(key);
             }
             // 采纳判定要用的现场：**含官方载体**，并并入本步刚投出去的域正文（它们就在这一步的
             // 请求里，模型当场看得到）。判断"发不发"只能用本插件自己的 kind —— 官方正文绝不能
             // 影响去重（见 PLUGIN_KINDS 的注释）；判断"模型眼前有没有这份内容"则必须连官方那份
             // 一起算，标准类预设下技能与提示词正是官方在送。两遍扫描，两种口径各自正确。
+            // **「已清空」通知要从现场里剔掉**：那条消息也带域标记、也占 `newestDomainTexts` 的键，
+            // 但它不是正文。连着它一起算，"用户早把这个域关了、模型凭工具描述去调"的那次调用会被
+            // 记成采纳 —— 于是 `adopted` 实际在说"这个域本会话说过话"，界面文案里那句"正文正在上下文
+            // 里"就成了假话。剔除之后 `used - adopted` 才第一次有意义：调了、但正文不在眼前。
+            // `clearedKeys` 那一步是同一个判据的另一半：通知这会儿还没落到会话表面上，光靠扫表面
+            // 会漏掉"就是这一步刚被清空"的那个域。
             // 位置在"提前返回"之前：这一步没东西可发时，现场依然是当前状态，同样要记。
             try {
                 if (typeof agent === 'object') {
-                    const liveKeys = new Set(newestDomainTexts(agent, LIVE_KINDS).keys());
+                    const liveKeys = new Set();
+                    for (const [key, entry] of newestDomainTexts(agent, LIVE_KINDS))
+                        if (entry.form !== 'notice')
+                            liveKeys.add(key);
                     for (const key of injectedKeys)
                         liveKeys.add(key);
+                    for (const key of clearedKeys)
+                        liveKeys.delete(key);
                     liveDomainsByAgent.set(agent, liveKeys);
                 }
             }
@@ -738,12 +807,13 @@ export function createContextInjector(deps) {
                 // 没有新增时，只有"拦下了官方消息"才需要返回改动后的 decision；否则原样返回。
                 return messages === messagesOf(decision) ? decision : { ...decision, messages: [...messages] };
             }
-            delivered.count += additions.length;
-            delivered.lastAt = Date.now();
+            const ledger = ledgerFor(agent);
+            ledger.delivered.count += additions.length;
+            ledger.delivered.lastAt = Date.now();
             for (const key of appended)
-                delivered.byDomain[key] = (delivered.byDomain[key] || 0) + 1;
+                ledger.delivered.byDomain[key] = (ledger.delivered.byDomain[key] || 0) + 1;
             for (const key of injectedKeys)
-                adoption[key].injected += 1;
+                ledger.adoption[key].injected += 1;
             return { ...decision, messages: [...messages, ...additions] };
         }
         catch (error) {