dsh-plugin-tool-management 0.17.0 → 0.18.5

package/lib/context-inject.js

@@ -71,436 +71,17 @@
 // 注入永远不能让这一步失败：任何异常都在监听器里吞掉、原样返回 decision。
 // 遥测同理（`noteToolUse` 自己吞异常）：它绝不能影响工具本身。
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
-import { SessionSeq } from '@deepseek-ai/dsh-session';
 import { clearRuntimeNote, noteRuntime } from './compat/runtime-notes.js';
-/**
- * 权威域顺序（界面勾选、注入消息先后都按它）。
- * 场景排第一、记忆紧跟：场景是"当前模式"的**框架**（有哪些场景、各自是什么约定），
- * 记忆是各场景下的**内容** —— 先给框架再给内容。
- */
-export const INJECT_DOMAIN_KEYS = ['scene', 'memory', 'mcp', 'skills', 'subagents', 'prompt'];
-/**
- * 域 → 消息来源 kind（轨迹行标签，也是去重时的身份）。
- *
- * 命名对齐官方 `*-catalog` 风格与本插件的工具族（`*_manager_*`）；改名等于换身份，
- * 旧消息会被当成"不在上下文里"而重发一次，所以这几个字符串是稳定契约。
- *
- * ⚠️ 0.14.0 把 `memory` 的 kind 从 `scene-memory-manager-catalog` 改成
- * `memory-manager-catalog`，并把场景拆成独立的 `scene` 域 —— 升级后每个会话**会重发一次**
- * 这两段（旧消息认不出来）。一次性代价，换来的是两段能各自开关、各自去重。
- */
-export const INJECT_KIND_OF = {
-    scene: 'scene-manager-catalog',
-    memory: 'memory-manager-catalog',
-    mcp: 'mcp-manager-catalog',
-    skills: 'skill-manager-catalog',
-    subagents: 'subagent-manager-catalog',
-    prompt: 'prompt-manager-catalog',
-};
-/**
- * 域 → 该域在模型工具表里的**工具名前缀**（采纳遥测的唯一映射）。
- *
- * 为什么要这张表：注入只解决"内容到没到"，不解决"模型用没用"。「注入实况」此前
- * 只能答前半句 —— 勾了开关、正文也在上下文里，但模型从头到尾没伸手，界面上和
- * 「用了」长得一模一样。有了映射，就能把「投递 N 次 / 调用 M 次」并排摆出来，
- * 措辞与形式的调整才有依据（否则改文案就是猜）。
- *
- * 前缀而不是精确名：`memory_manager_*` 有 list/read/switch/save 等，任何一个
- * 都说明模型确实在读这一域。改工具名等于换身份，这几个字符串是稳定契约。
- *
- * 为什么值是**数组**：工具族与注入域不是一一对应的概念 —— 域是"给模型看的信息分组"
- * （界面上的勾选），族是"操作哪类对象"。0.14.0 里场景与记忆就一度同域两族
- * （`memory_manager_*` + `scene_manager_*`），拆开后现在每个域各一个前缀。留着数组是
- * 为了让"一个域挂多个族"在类型上成立，将来加族不必改类型。顺序不影响判定。
- */
-export const DOMAIN_TOOL_PREFIX = {
-    scene: ['scene_manager_'],
-    memory: ['memory_manager_'],
-    mcp: ['mcp_manager_'],
-    skills: ['skill_manager_'],
-    subagents: ['subagent_manager_'],
-    prompt: ['prompt_manager_'],
-};
-/** 工具名 → 域（`undefined` = 不是本插件的域工具）。纯函数，便于单独推理。 */
-export function domainOfTool(toolName) {
-    const name = String(toolName ?? '');
-    for (const key of INJECT_DOMAIN_KEYS) {
-        for (const prefix of DOMAIN_TOOL_PREFIX[key]) {
-            if (name.startsWith(prefix))
-                return key;
-        }
-    }
-    return undefined;
-}
-/**
- * 这个 agent 在委派链上的**深度**（0 = 顶层会话，1 = 子会话，2 = 孙会话…）。
- *
- * 为什么需要它：`agent/pre-step` 挂在宿主平面，天然覆盖所有 agent（含子智能体）——
- * 这是当初选这条通道的代价。而人设目录该不该注入，取决于会话**有多深**（人设的
- * `catalogDepth` 决定"目录注入到几层"，默认 1 = 只在顶层），那是个关于深度的判断，
- * 不是一个布尔的身份标签。
- *
- * 口径照抄官方 `delegationDepthOf()`（`dsh-subagent/lib/index.js:144`）：持久化头
- * `session.header.delegationDepth` 与运行期选项 `agent.options.subagentDepth` 取较大者
- * —— 单看头会让"恢复的子会话"重新变成顶层（官方注释明说这是它要防的事）。
- * `header.origin === 'subagent'` 是"是子会话"的硬信号，深度至少算 1（头里没记深度时
- * 不能退回 0）。任一探针取不到或不是有限数都当它缺席：宁可把深度算浅一次（多注入一域），
- * 也不要把正常会话误判成子会话而静默少一域。
- */
-export function subagentDepthOf(agent) {
-    try {
-        const a = agent;
-        const header = a?.session?.header;
-        const finite = (value) => typeof value === 'number' && Number.isFinite(value) ? value : 0;
-        const persisted = header !== undefined && header !== null ? finite(header.delegationDepth) : 0;
-        const runtime = finite(a?.options?.subagentDepth);
-        const floor = header !== undefined && header !== null && header.origin === 'subagent' ? 1 : 0;
-        return Math.max(floor, persisted, runtime);
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * 这个 agent 是不是**子会话**（子代理派生的会话）。深度判定的布尔投影。
- *
- * ⚠️ 生产代码现在只用 `subagentDepthOf` —— 判据是"目录该不该注入到这么深的会话"，
- * 需要的是**深度数字**，不是一个布尔身份（2026-09-17 方案 A：委派可行性由官方决定，
- * 与"是不是子会话"无关）。这个投影留给真正需要布尔判断的场合，以及测试。
- */
-export function isSubagentSession(agent) {
-    return subagentDepthOf(agent) >= 1;
-}
-/**
- * 「官方已经送得到就别再送」的域 → 对应预设事实的键。
- *
- * 这两个域的内容官方也有：提示词（AGENTS.md 正文；场景期间换成场景提示词）由
- * `dsh-agent-instructions` 连着文件一起送，技能目录由 `dsh-tool-skill` 送。预设挂得到官方
- * 那条行时本插件不重复注入（否则同一段正文进上下文两次）；挂不到（极简两行都没挂）时才
- * 由本插件兜底 —— 于是"极简也能选择是否注入"成立，而普通预设下不会出现两份。
- */
-const CARRIER_FACT_OF = {
-    prompt: 'carriesAgentsMd',
-    skills: 'carriesSkillCatalog',
-};
-export const DEFAULT_INJECT_SETTINGS = {
-    underSuppressingPresets: false,
-    domains: { scene: true, memory: true, mcp: true, skills: true, subagents: true, prompt: true },
-};
-/** 把任意输入夹成合法设置（缺项/类型不对一律退回默认；默认从不阻止注入）。 */
-export function normalizeInjectSettings(raw) {
-    const obj = (raw && typeof raw === 'object' ? raw : {});
-    const domainsRaw = (obj.domains && typeof obj.domains === 'object' ? obj.domains : {});
-    const domains = {};
-    for (const key of INJECT_DOMAIN_KEYS) {
-        domains[key] = typeof domainsRaw[key] === 'boolean' ? domainsRaw[key] : DEFAULT_INJECT_SETTINGS.domains[key];
-    }
-    return {
-        underSuppressingPresets: typeof obj.underSuppressingPresets === 'boolean'
-            ? obj.underSuppressingPresets
-            : DEFAULT_INJECT_SETTINGS.underSuppressingPresets,
-        domains,
-    };
-}
-/**
- * 纯函数：按设置 + 预设事实 + 目标 agent 挑出本次要注入的域。
- *
- * 规则（设计 2026-09-16；目录注入深度 2026-09-17）：
- *   - 域开关关掉的、文本为空的，都不进；
- *   - **压制型预设**且没开「仍然注入」→ 一个都不进（跟随预设）；
- *   - 域声明 `applicableTo` 说不成立的域不进（当前只有人设目录：会话深度超出了人设的
- *     `catalogDepth`，默认 1 = 只在顶层注入。**这不是"子会话不能委派"** —— 委派由官方
- *     决定，见 service.ts 里 `catalogDepth` 的注释）；
- *   - 有官方载体的两个域（提示词 / 技能目录）：预设挂得到官方那条行时不进
- *     —— 官方自己会送，再注入一遍只会重复；预设事实读不到（`undefined`）时按"已承载"处理
- *     （宁可与现状一致，也不制造重复）；
- *   - 同一段文本出现两次只保留前一个（跨域保险）。
- *
- * `onError`（2026-09-30 审查 P1-8）：某个域的 `text()` **取数失败**时回调一次，并跳过该域。
- * 为什么不能像原来那样静默吞成空串：调用方据此判定"该域这一轮没内容"，而下游还有一条
- * 「上一轮可见、这一轮没内容 → 发一条『已清空』」的通知 —— 于是一次取数失败会让模型收到
- * **假的"已清空"**，据此认为那份内容已失效，下一轮内容恢复后又重发一次。
- *
- * ⚠️ 这条通道**只认抛异常**，所以域的 `text()` 实现必须把"读失败"与"真的空"分开：
- * 返回空串一律被当成后者（2026-09-30 审查 F7 —— 修复第一版只覆盖了抛异常那一半，
- * 而真实世界里 IO 失败走的是 `catch → return ''` 那条路）。`src/memories/service.ts`
- * 的 `requireSceneMemory` / `sceneCatalog` / `readPresetTextSync` 已按此改。
- */
-export function selectInjections(domains, settings, facts, agent, onError) {
-    const suppressing = facts !== undefined && facts.suppressing;
-    if (suppressing && !settings.underSuppressingPresets)
-        return [];
-    const out = [];
-    const seen = new Set();
-    for (const domain of domains) {
-        if (settings.domains[domain.key] !== true)
-            continue;
-        // 域自己不成立就不发（如人设目录的 catalogDepth 没覆盖到本会话的深度）。**这里没有开关，是刻意的**：
-        // 曾经有个 `suppressInSubagentSessions` 想让这一步可选，但它是个空开关 —— 域不成立时
-        // 正文自己也被过滤成空的（见 `subagents/catalog.ts` 的按深度过滤），两道闸条件相同，
-        // 开关只控制得了其中一道。留一个点了没反应的勾选框比没有更糟，所以删掉（2026-09-17）。
-        if (domain.applicableTo !== undefined && !domain.applicableTo(agent))
-            continue;
-        const carrier = CARRIER_FACT_OF[domain.key];
-        // 官方载体已挂（或读不到预设、只能按已挂算）→ 不重复送；只有明确"没挂"才兜底。
-        if (carrier !== undefined && facts?.[carrier] !== false)
-            continue;
-        let text = '';
-        try {
-            text = String(domain.text(agent) ?? '');
-        }
-        catch (error) {
-            // 取数失败 ≠ 没有内容：交给调用方（上报 + 这一轮不发"已清空"），本域这一轮不发。
-            try {
-                onError?.(domain.key, error);
-            }
-            catch { /* 上报本身绝不能影响注入 */ }
-            continue;
-        }
-        if (text.trim() === '')
-            continue;
-        const fingerprint = text.trim();
-        if (seen.has(fingerprint))
-            continue;
-        seen.add(fingerprint);
-        out.push({ key: domain.key, name: domain.name, label: domain.label, form: domain.form, text });
-    }
-    return out;
-}
-/**
- * 纯函数：算出某一步每个域的原因（`selectInjections` 的镜像，供「注入实况」解释状态）。
- *
- * 与 `selectInjections` 分开写是为了让两边各自可读：一个是"发什么"，一个是"为什么"。
- * 口径必须一致 —— 否则界面会把"子会话抑制"报成"未投递"，而界面的既有口径是
- * 「琥珀只留给'该投却没投'」（把用户自己的选择读成故障，正是这条口径要避免的事）。
- *
- * ⚠️ 这里**故意不镜像** `selectInjections` 开头那条"压制型预设一个都不进"的提前返回：
- * 该分支下本函数仍按各域自身的原因作答，于是压制型预设 + 没开「仍然注入」时，
- * 界面看到的是"未投递"（琥珀）而不是"已关闭"（灰）。这是 0.9.1 的既有行为，本次未改，
- * 改动它属于另一个话题（"跟随预设"到底该报成故障还是报成选择）。
- */
-export function explainInjections(domains, settings, facts, agent, failed) {
-    const reasons = {};
-    for (const domain of domains) {
-        if (settings.domains[domain.key] !== true) {
-            reasons[domain.key] = 'off';
-            continue;
-        }
-        if (domain.applicableTo !== undefined && !domain.applicableTo(agent)) {
-            reasons[domain.key] = 'child';
-            continue;
-        }
-        const carrier = CARRIER_FACT_OF[domain.key];
-        if (carrier !== undefined && facts?.[carrier] !== false) {
-            reasons[domain.key] = 'official';
-            continue;
-        }
-        // 取数失败过 → 报 `error` 而不是 `empty`：两者在界面上的含义完全不同（一个是故障、
-        // 一个是"本来就没内容"），而原来这条路上永远只能看到后者（审查 P1-8）。`failed` 由调用方
-        // 从 `selectInjections` 的 `onError` 收集；**只认抛异常**，返回空串仍算 `empty`（F7）。
-        if (failed?.has(domain.key)) {
-            reasons[domain.key] = 'error';
-            continue;
-        }
-        let text = '';
-        try {
-            text = String(domain.text(agent) ?? '');
-        }
-        catch {
-            text = '';
-        }
-        reasons[domain.key] = text.trim() === '' ? 'empty' : 'sent';
-    }
-    return reasons;
-}
-/**
- * 权威声明的统一句（用户 2026-09-23 看到实际注入后要求精简）。
- *
- * 此前五个域各写一份 —— `本份场景取代…同类场景` / `本份记忆取代…同类记忆` /
- * `本份状态…` / `本份目录…` —— 说的是**同一条规则**却用了四种措辞，模型读到四条不同的句子
- * 还得自己判断它们是不是一条。统一成一句：被取代的是"同类内容"，与域无关。
- *
- * 为什么不能并进 `cue`（那能省下整整一行 ≈16 tok/段）：用户 2026-09-18 定过"权威声明单独
- * 成句" —— 它和动作句是两种东西（一句说"什么时候用它"，一句说"以哪份为准"），合并后容易
- * 被一眼带过。所以这里的收益只有约 6 tok/轮，**主要收益是消除四种措辞**，不是省字节。
- */
-const SUPERSEDE_NOTE = '本份取代本次会话中更早注入的同类内容。';
-const DOMAIN_FRAME = {
-    scene: {
-        // 场景段只有标题 + 正文 + 权威声明（**没有 cue 是六个域的共同决定**，理由见 `DomainFrame`）。
-        //
-        // 这一段的演进值得记下来，因为每一次都是被实际注入推着改的：
-        //   ① 最早它把「场景说明」当**约定**授权（"一律照办，覆盖你的默认做法"）—— 而它的实例
-        //      是「写代码」这种**标签**，让模型"照办一个标签"，这正是它读不懂这段的原因；
-        //   ② 去掉授权后换成一句定义（"场景是用户给这台机器配的工作模式"）—— 定义不是动作，
-        //      模型读完还是不知道该拿它做什么；
-        //   ③ 再加一句因果（"下面四段都已按它筛过"）—— 用户 2026-09-23 看到渲染效果后给了
-        //      **原则**：「上下文注入就是当前的情况，目的是让 agent 知道现在的情况，不需要它
-        //      知道没用的信息，反推更是浪费 token」。于是三句全删。
-        //
-        // 现在这一段只回答一个问题：**当前处在哪个场景、它是什么**（`**「代码」—— 写代码**`）。
-        // 它还比别的段少一层：因果句也删了 —— 它解释的是"另外四段是怎么产生的"（机制），
-        // 不是当前情况本身，而且"清单里没有 ≠ 本机没有"这层反推被用户明确判为浪费。
-        title: '本机当前的场景',
-        supersede: SUPERSEDE_NOTE,
-    },
-    memory: {
-        title: '本机当前的记忆',
-        supersede: SUPERSEDE_NOTE,
-    },
-    mcp: {
-        title: '本机 MCP 服务器的当前状态',
-        // how 只剩"怎么用备注"这半句：前半个分句「工具名是 `mcp__<服务器>__<工具>`」删掉了
-        // —— 模型自己的工具表里就是这个命名（`mcp__context7__xxx`），告诉它格式是零信息量。
-        how: '带「用户提示：」的行是用户写给这台服务器的决策提示，选服务器之前先看一眼。',
-        supersede: SUPERSEDE_NOTE,
-    },
-    skills: {
-        title: '本机技能目录',
-        // 两句都只在预设没挂官方 `skill` 工具时出现，差别只在点名不点名那个取正文的工具
-        // （工具被用户在兼容页关掉时不点名 —— 点名一个模型手里没有的工具只会让它去猜名字）。
-        how: (toolHidden) => toolHidden('skill_manager_read')
-            ? '本预设没有官方 `skill` 工具：目录只有摘要，读完再照做。'
-            : '本预设没有官方 `skill` 工具：要正文用 `skill_manager_read`（按名字直接给正文与路径）；目录只有摘要，读完再照做。',
-        supersede: `${SUPERSEDE_NOTE.slice(0, -1)}；只列当前可调用的技能。`,
-    },
-    subagents: {
-        title: '可委派的子智能体',
-        // 分界规则（2026-09-17 方案 C，本机实测 session-ee722e23 逼出来的）：官方那两个
-        // 委派工具（`subagent` / `subagent_fork`）不带人设，而此前没有任何一句话说明何时该
-        // 用谁 —— 模型在"审查刚读过的 README"时选了 `subagent_fork`（fork 能继承已读内容、
-        // 省一次复述）。现在人设通道也有 `inherit`（同一套 fork 机制），分界只剩"要不要后台跑"。
-        // 带人设的委派工具被关掉时改说"本会话没有这条通道"：不说的话，模型看到有人设目录却
-        // 找不到对应的工具，会去拿官方那两个凑（它们不接受人设，等于白跑一趟）。
-        how: (toolHidden) => toolHidden('subagent_manager_run')
-            ? '本会话没有带人设的委派工具；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。'
-            : '贴合人设的任务一律用 `subagent_manager_run`（要它看到本次会话就开 `inherit`）；官方 `subagent` / `subagent_fork` 不带人设，只在没有人设贴合、或要后台跑时用。',
-        supersede: SUPERSEDE_NOTE,
-    },
-    prompt: {
-        title: '本机提示词',
-        supersede: SUPERSEDE_NOTE,
-    },
-};
-/** 域声明里没登记的 key（理论上到不了这里）：给一个不出错的通用框架。 */
-const fallbackFrame = (label) => ({
-    title: `本机的${label}`,
-    supersede: SUPERSEDE_NOTE,
-});
-const domainFrame = (key, label) => DOMAIN_FRAME[key] ?? fallbackFrame(label);
-/**
- * 框架的伪 XML 标记。与官方两条注入行同款：`dsh-tool-skill` 与 `dsh-agent-instructions`
- * 都把**整条正文**包在里面（不是只包引导语）。Claude Code 那边把这对标记叫"可依赖的
- * 判别符"（`messages.ts:1797` 的 `ensureSystemReminderWrap` 保证任何注入文本都不落在外面）：
- * 模型据此把这段读成系统给的上下文，而不是用户刚打的字 —— 本插件的正文里混着用户写的
- * 自由文本（AGENTS.md / 记忆 / 备注），这层来源标记尤其不能少。
- */
-const FRAME_OPEN = '<system-reminder>';
-const FRAME_CLOSE = '</system-reminder>';
-/**
- * 正文里的 `</system-reminder>` 拆掉闭合形态（写成 `<\/system-reminder>`）。
- *
- * 正文含用户自由文本（AGENTS.md、记忆、MCP 备注、技能描述），一句手写的闭合标记就能让框架
- * 提前结束，其后的内容读起来像用户当场说的话。照抄官方 `escapeInstructionFrameBody` 的实现
- * （`dsh-agent-instructions/lib/index.js:128`，同样是替换成带反斜杠的形态 —— 模型看到的
- * 字面量不变，标记不再闭合）。
- */
-export function escapeFrameBody(body) {
-    return body.replaceAll(FRAME_CLOSE, '<\\/system-reminder>');
-}
-/**
- * 一条注入消息的正文（纯函数）：`<system-reminder>` 里 = 框架（标题 + 动作 + 补充 + 权威
- * 声明）+ 空行 + 域正文。**所有域一律带框架**，没有例外。
- *
- * 历史（每一版都是被具体毛病逼出来的，别把结论当套话读）：
- *   - 第一版（2026-09-17 前）：五域共用「以下是本机插件的X（取代…）。」——「本机插件」是实现
- *     细节；通篇没有动作；五条消息句式一模一样，雷同的套话退化成背景噪声。
- *   - 第二版（2026-09-17）：动作前置（`**{线索}**：以下是{域}（取代…）。{补充}`），但只改了
- *     用户圈定的两域（记忆 / 子智能体），MCP、技能、提示词继续走老模板。
- *   - 第三版（2026-09-17）：instructions 形态不再裸送 —— 此前"原样送"的理由是"对齐官方
- *     AGENTS.md 那条行"，与官方实际行为不符（官方那条是包 `<system-reminder>` 的，含一句
- *     "这些工作区指令可作参考……"。真正的问题在极简类预设：官方通道被压掉后本插件是唯一
- *     承载者，裸文本没有任何标记，而提示词会因场景切换而变化、新旧两份效力相同、没有判据。
- *     只借官方**包框架**的形式，**不抄**它那句把用户规则降成"仅供参考"的措辞。
- *   - 第四版（2026-09-18，本条）：**动作仍然不够显眼**（用户：「还是不能很好提醒模型去主动
- *     使用」），且整条消息该按 md 排版突出关键信息。改成四级结构：`##` 标题当标签、
- *     加粗动作句单独一行、补充动作给工具名、权威声明单独成句（逐条理由见 `DOMAIN_FRAME`）。
- *     同时把**正文也包进标记里**（此前只有引导语在标记内、正文裸奔）—— 官方两条注入行都是
- *     整条包住的，正文里的用户自由文本更需要这层来源标记。
- */
-export function renderDomainText(section, toolHidden = () => false) {
-    const frame = domainFrame(section.key, section.label);
-    // 层级（2026-09-23 用户看到实际注入后指出「记忆内的场景怎么都是 ## 标题」）：**`#` 一级给板块**
-    // （场景 / 记忆 / MCP / 技能 / 子智能体 / 提示词），域正文里的 `##` 才是它的下一层
-    // （记忆段的 `## 场景：X`、超预算时的 `## 未注入的参考信息`）。此前标题也是 `##`，两者平级，
-    // 模型读不出主次 —— 而"哪些内容归在哪个板块/场景下"正是它做判断时要用的结构。
-    //
-    // 开标签后**必须空一行**：markdown 里 `#` 紧跟在一行文字后面只是**段落续行**，不会被渲染成
-    // 标题 —— 用户截图里 `## 本机当前的场景` 就是这么被吞掉的（和 `<system-reminder>` 挤成一段）。
-    // 收尾同理：正文末尾先归一成单个空行，免得 `</system-reminder>` 粘在最后一行上。
-    // 结构：标题 → 补充说明（有才发）→ 权威声明 → 正文。没有 cue 那一行（见 `DomainFrame` 的注释）。
-    const lines = [FRAME_OPEN, '', `# ${frame.title}`];
-    const how = typeof frame.how === 'function' ? frame.how(toolHidden) : frame.how;
-    if (how !== undefined)
-        lines.push(how);
-    lines.push(frame.supersede, '', escapeFrameBody(section.text).replace(/\n+$/, ''), '', FRAME_CLOSE);
-    return lines.join('\n');
-}
-/** 「已清空」通知正文：某个域曾经注入过、现在没有内容时发一条（纯函数，测试用）。 */
-export function clearedDomainText(key, label) {
-    const frame = domainFrame(key, label);
-    // 形状与 `renderDomainText` 一致（开标签后空行、板块 `#`、收尾空行）—— 这两条都是同一个
-    // 通道发出去的消息，层级与留白不该有两套。
-    return [
-        FRAME_OPEN,
-        '',
-        `# ${frame.title}`,
-        '**已清空** —— 本次会话中此前注入的同类内容不再有效。',
-        '',
-        FRAME_CLOSE,
-    ].join('\n');
-}
-/** 取一条消息的正文（只认单 text 块；形如官方 RuntimeContextProjection.textOf）。 */
-function textOf(message) {
-    const content = message?.content;
-    if (!Array.isArray(content) || content.length !== 1)
-        return undefined;
-    const block = content[0];
-    return block && block.type === 'text' && typeof block.text === 'string' ? block.text : undefined;
-}
-/** 本插件自己的五个注入 kind（去重比对只用这一份 —— 绝不能让官方正文影响"发不发"的判断）。 */
-const PLUGIN_KINDS = new Map(INJECT_DOMAIN_KEYS.map((key) => [INJECT_KIND_OF[key], { key, official: false }]));
-/**
- * 官方载体消息的 kind → 本插件域：技能目录（`@deepseek-ai/dsh-tool-skill`）与
- * AGENTS.md（`@deepseek-ai/dsh-agent-instructions`）。仅用于「注入实况」展示 ——
- * 标准类预设下这两个域由官方在送，它同样是"模型看到的内容"，体积要算官方那份。
- * 字符串取自官方包，是宿主侧的稳定契约。
- */
-const OFFICIAL_KIND_OF = {
-    'skill-catalog': 'skills',
-    'agent-instructions': 'prompt',
-};
-/**
- * 用户**明确关掉**的域 → 该域对应的官方消息 kind（这些 kind 的消息这一步不放行）。
- *
- * 交互事实（用户 2026-09-17 指出）：技能与提示词两域在标准类预设下由官方送（本插件让位），
- * 于是"取消勾选"只停掉了本插件自己，官方那条照样进上下文 —— 用户看到的是"关了没用"。
- * 本函数给出需要**连带拦下**的官方 kind：只有"官方自己会送同份内容"的两个域有这一项；
- * MCP / 记忆 / 人设目录官方不送，没有可拦的对象（它们的开关本来就完全生效）。
- */
-export function officialKindsToSuppress(settings) {
-    const out = new Set();
-    for (const [kind, key] of Object.entries(OFFICIAL_KIND_OF)) {
-        if (settings.domains[key] === false)
-            out.add(kind);
-    }
-    return out;
-}
-/** 一条消息的来源 kind（读不到 = `undefined`）。 */
-function kindOfMessage(message) {
-    const source = message?.source;
-    return source && typeof source.kind === 'string' ? source.kind : undefined;
-}
+import { domainOfTool, INJECT_DOMAIN_KEYS, INJECT_KIND_OF, } from './context-inject-contract.js';
+import { explainInjections, selectInjections, } from './context-inject-select.js';
+import { clearedDomainText, renderDomainText } from './context-inject-frame.js';
+import { kindOfMessage, LIVE_KINDS, newestDomainTexts, officialKindsToSuppress, PLUGIN_KINDS, } from './context-inject-surface.js';
+// 拆出的四层照旧从 context-inject.js 对外可见（index.ts、ops/compat.ts、tools/table.ts、
+// subagents/{catalog,service}.ts 与契约测试都按这个路径引）。
+export { DEFAULT_INJECT_SETTINGS, DOMAIN_TOOL_PREFIX, INJECT_DOMAIN_KEYS, INJECT_KIND_OF, domainOfTool, isSubagentSession, subagentDepthOf, } from './context-inject-contract.js';
+export { explainInjections, normalizeInjectSettings, selectInjections, } from './context-inject-select.js';
+export { clearedDomainText, escapeFrameBody, renderDomainText } from './context-inject-frame.js';
+export { officialKindsToSuppress } from './context-inject-surface.js';
 // B4：关域拦截的**顺序自检**。官方那两条注入行与本插件同挂在这条瀑布上，拦截成立的剩余前提是
 // "本插件排在它们上游"（本插件用 `{ prepend: true }` 把自己钉在钩子表最前，所以真正还依赖的
 // 只剩一条：官方那两条仍用**默认 push** 方式注册）。这仍是非契约事实（见 pre-step 监听器里的
@@ -535,55 +116,6 @@ function suppressionVerdict(active, dropped, counter) {
         params: { turns: counter.turns },
     });
 }
-/** 实况展示用的 kind 表：本插件的五条 + 官方两条。 */
-const LIVE_KINDS = new Map([
-    ...PLUGIN_KINDS,
-    ...Object.entries(OFFICIAL_KIND_OF).map(([kind, key]) => [kind, { key, official: true }]),
-]);
-function newestDomainTexts(agent, kinds) {
-    const out = new Map();
-    const session = agent?.session;
-    if (!session || typeof session.seq !== 'number' || typeof session.eventAt !== 'function')
-        return out;
-    const scan = (seq) => {
-        let event;
-        try {
-            event = session.eventAt(SessionSeq(seq));
-        }
-        catch {
-            return false;
-        }
-        if (!event || event.type !== 'user/message')
-            return false;
-        const source = event.data && event.data.source;
-        const mapping = source && typeof source.kind === 'string' ? kinds.get(source.kind) : undefined;
-        if (mapping === undefined || out.has(mapping.key))
-            return false;
-        const text = textOf(event.data);
-        if (text === undefined)
-            return false;
-        out.set(mapping.key, { text, form: source && typeof source.form === 'string' ? source.form : '', official: mapping.official });
-        return out.size === INJECT_DOMAIN_KEYS.length;
-    };
-    const nodes = session.surface && Array.isArray(session.surface.nodes) ? session.surface.nodes : undefined;
-    if (nodes !== undefined) {
-        const seqs = [];
-        for (const node of nodes) {
-            const n = Number(node);
-            if (Number.isFinite(n))
-                seqs.push(n);
-        }
-        seqs.sort((a, b) => b - a); // 从新到旧（表面自身的顺序不保证）
-        for (const seq of seqs)
-            if (scan(seq))
-                break;
-        return out;
-    }
-    for (let seq = session.seq - 1; seq >= 0; seq -= 1)
-        if (scan(seq))
-            break;
-    return out;
-}
 const bytesOf = (text) => {
     try {
         return Buffer.byteLength(text, 'utf8');