@chaoset/adaptive-perf 0.7.0 → 0.7.2

package/lib/index.js

@@ -0,0 +1,1574 @@
+/**
+ * adaptive-perf — 极简性能自适应插件（@chaoset/adaptive-perf）
+ *
+ * 目标：让「标准模式（standard）」「PTC 模式（code）」与「创造模式
+ * （cordis）」达到与「极简模式（minimal）」相同级别的高性能。极简模式快
+ * 的原因（对源码的对照结论）：
+ *   1. persona 配置了 includeRuntimeContext: false —— 每次模型请求不注入
+ *      "Current runtime context" 快照（文件策略 / 审批策略等动态段）；
+ *   2. 工具目录极小（只有 bash + str_replace_editor）—— 每个请求的
+ *      tool schema 与（PTC 的）SDK 参考段都随之变小；
+ *   3. persona 为 complete 固定提示，无其它全局 prompt 段；
+ *   4. 不挂 skill 目录提醒（~9KB）与 AGENTS.md 摘要注入。
+ *
+ * 本插件在多个维度上做"动态自适应"（而不是静态裁剪），全部参照
+ * dsh-anchored-standard（https://github.com/xiaobright/dsh-anchored-standard）
+ * 的实测结论：
+ *   A. 运行时上下文抑制：对目标 preset 的会话调用
+ *      agent.ctx.systemPrompt.suppressRuntimeContext()（与极简模式同一机制），
+ *      每次请求省掉快照文本，零功能损失。
+ *   B. 真实 Minimal 工具对（bootstrap.realPair，0.5.0 新增）：首轮"轨迹"
+ *      （模型思维链风格）由请求 #1 可见的**工具 schema** 决定，且只有与
+ *      Minimal 逐字相同的 schema 才能锚定（issue #11：真实工具对 5/5 锚定，
+ *      任何 standard 系 schema——包括 sandboxed bash/read——11/11 落入
+ *      standard-like）。仅收窄目录不够：standard/code preset 根本没有
+ *      str_replace_editor，其 bash 也是 sandboxed schema。因此本插件把
+ *      Minimal 的**真实工具对**（持久 PTY bash + str_replace_editor，官方
+ *      minimal preset 同一批插件、同一份描述）挂进 agent 作用域工具层
+ *      （scoped registration 按名阴影继承工具），首轮目录 = 真实工具对；
+ *      PTC 的 SDK 参考段同样按可见目录渲染，同步缩小。
+ *   C. 首轮锚定（bootstrap）：请求 #1 只暴露真实工具对，剥离自动注入上下文
+ *      （技能目录提醒 skill-catalog、AGENTS.md 摘要 agent-instructions；
+ *      用户主动的技能手势不过滤）；首个**持久**晋升信号（首个 tool/call 或
+ *      assistant/message，promoteOn 可选 either/tool-call/assistant-message）
+ *      后**完整恢复**该模式的全部工具目录与常规上下文注入（0.7.0，
+ *      dsh-anchored-standard 语义：只锚定首轮，不减少后续功能）；阶段从
+ *      持久会话事件推导，resume/reload 不丢状态，晋升信号持久（compaction
+ *      不重置）；bootstrap.maxTokens（可选）给请求 #1 封顶输出预算，晋升后
+ *      剥离。
+ *   D. 常驻上下文抑制（suppressInjectedContext，0.5.0 新增，0.7.0 默认
+ *      开启）：true = 整个会话剥离技能目录提醒与 AGENTS.md 摘要注入（功能
+ *      可见性由常驻发现工具 dev_tool_search / skill_search / skill_load
+ *      承担——实测晋升后恢复注入会把轨迹拉回 standard-like）；false =
+ *      只剥离首轮，晋升后恢复常规注入（opt-in）。
+ *   E. 工具目录自适应精简（leanByDefault，0.7.0 默认关闭的 opt-in）：开启时
+ *      按"工具族"隐藏高开销低频工具（子代理 / 工作流 / ralph / goal 等编排
+ *      类），只保留核心编码工具，随后根据两类信号在会话内"单调升级"放行
+ *      对应工具族（只升不降）：
+ *        - 关键词信号：用户消息命中某工具族的触发词（如"子代理"）→ 放行该族；
+ *        - 失败信号：PTC 的 run_code 程序调用被隐藏工具报 UNKNOWN_TOOL
+ *          （tools/result 失败文本含工具名）→ 放行该族，下次程序即可调用。
+ *
+ * 实现全部使用 dsh 公开服务契约（Inspect 确认）：
+ *   - ctx.agentPresets.composedPreset(agent.ctx)  读取会话所属 preset
+ *   - agent.ctx.systemPrompt.suppressRuntimeContext()  抑制上下文快照
+ *   - agent.ctx.systemPrompt.section()  按名阴影 prompt 段（persona/引导段）
+ *   - agent.ctx.tools.schemas(agent)  读取该 agent 当前可见工具（限制交集）
+ *   - agent.ctx.tools.restrict({ deny })  按 agent 作用域裁剪继承工具
+ *   - agent.ctx.plugin()  挂载官方 minimal preset 同款插件（持久 bash /
+ *       str_replace_editor / 其依赖的 terminals 与本地 fs）
+ *   - agent/pre-step（waterfall） 首轮剥离自动注入上下文
+ *   - agent/request（waterfall） 首轮输出预算封顶
+ *   - session/event  增量喂入持久事件（晋升信号）
+ *   - agent/created、agent/disposed、agent/inbox/inserted、tools/result 事件
+ * 监听器都注册在 host 根作用域（与 dsh-agent-presets 自身同款用法），事件按
+ * scope 过滤分发，子作用域派发的事件根监听器可收到；waterfall 均以 prepend
+ * 注册保证"最外层"（剥离是最后一道变换）。
+ *
+ * 配置：cordis.patch.yml 的 config（安装默认）与
+ *       ~/.dsh/plugins/adaptive-perf/config.json（设置页 UI，权威）合并，
+ *       保存后热生效（新会话立即生效；已运行会话按新配置重算限制）。
+ *
+ * 依赖：真实工具对需要官方插件包（@deepseek-ai/dsh-terminal 等，声明为
+ * optionalDependencies）。它们不可用时本插件自动降级（告警 + 退回旧行为：
+ * 只收窄目录、不替换 schema），绝不拖垮 harness。
+ */
+import { createConfigStore } from './config-store.js';
+// remote 服务（设置页 UI 的配置读写）可选：typert-protocol 不可用时
+// 动态 import 失败，核心功能（自适应）照常工作。
+let PluginConfigGateway = null;
+try {
+    ({ PluginConfigGateway } = await import('./remote.js'));
+}
+catch (error) {
+    console.warn('adaptive-perf: settings gateway unavailable: ' + (error?.message ?? String(error)));
+}
+// 宿主 settings 体系的 schema 库（dsh-settings 0.1.0-rc.7+ 用 schemastery）。
+// DSH profile 的 hoisted node_modules 直接解析；仓库测试环境无此包时为
+// null，settings namespace 注册段静默跳过（fail-safe）。
+let Schema = null;
+try {
+    ({ default: Schema } = await import('@deepseek-ai/schemastery'));
+}
+catch { }
+export const name = 'adaptive-perf';
+/**
+ * 默认配置。apply 时与 YAML 传入的 config 合并（cordis 不合并小写 config 导出）。
+ *
+ * families：工具族。每族可配 tools（该族工具名，需存在于目标 preset 的目录，
+ * 插件运行时按实际可见工具取交集，不会因改名/缺失而崩溃）与 keywords（用户消息
+ * 命中任一触发词即放行该族；大小写不敏感，子串匹配）。
+ *
+ * bootstrap：首轮锚定（参照 dsh-anchored-standard 的实测结论）。请求 #1 只暴露
+ * bootstrap.tools（真实 Minimal 工具对），剥离 suppressedContextSources 列出的
+ * 自动注入上下文；首个持久晋升信号（promoteOn）后完整恢复全部工具与常规注入
+ * （晋升是持久信号，compaction/end 不重置）；maxTokens>0 时给请求 #1 封顶输出
+ * 预算（晋升后剥离）。
+ */
+export const DEFAULT_CONFIG = {
+    /** 总开关：关闭后插件对会话不产生任何影响。 */
+    enabled: true,
+    /** 应用自适应的 agent preset 列表（composedPreset 返回值）。 */
+    presets: ['standard', 'code', 'cordis'],
+    /**
+     * 默认策略（0.7.0）：首轮锚定、晋升后 resident 目录（dsh-anchored-standard
+     * 语义）。非极简 preset 的会话：请求 #1 按极简条件组装（真实 Minimal 工具
+     * 对 + 极简 persona + 屏蔽全局引导段 + 剥离自动注入 + 抑制运行时快照）以
+     * 锚定极简轨迹；首个持久晋升信号后进入 resident 阶段——保留 bootstrap 工具
+     * 对 + 常驻发现工具（dev_tool_search / skill_search / skill_load），完整
+     * 目录经 dev_tool_search 按需解锁（避免晋升时一次性倒出完整目录把轨迹拉回
+     * standard-like，anchored-standard 实测的"晋升后回退"问题），常规上下文
+     * 注入恢复可见——功能不减少。工具目录默认零裁剪（leanByDefault 关闭，
+     * 编排类工具族始终可用）；需要时可在设置页按需开启。
+     */
+    /** 抑制运行时上下文快照（等同极简模式的 includeRuntimeContext: false）。 */
+    suppressRuntimeContext: true,
+    /** 会话启动时默认隐藏编排类工具族（核心编码工具始终保留）。 */
+    leanByDefault: false,
+    /** 用户消息命中工具族触发词时自动放行该族（会话内单调）。 */
+    escalateOnKeyword: true,
+    /** 工具调用失败（UNKNOWN_TOOL 文本含隐藏工具名）时自动放行该族。 */
+    escalateOnUnknownTool: true,
+    /**
+     * 常驻上下文抑制（0.5.0）：true = 整个会话剥离自动注入上下文
+     * （skill-catalog 技能目录提醒、agent-instructions AGENTS.md 摘要）；
+     * false = 只在 bootstrap 未晋升阶段剥离，晋升后恢复注入（0.7.0 默认，
+     * 与 dsh-anchored-standard 一致：只锚定首轮、不减少后续功能）。
+     */
+    suppressInjectedContext: true,
+    /** 核心编码工具（不进入任何限制族；此处仅作文档展示）。 */
+    coreTools: [
+        'bash', 'read', 'write', 'edit', 'glob', 'grep', 'read_image',
+        'job_output', 'job_list', 'job_kill',
+        'todo_write', 'ask_user_question', 'web_search', 'skill', 'exit_plan_mode',
+    ],
+    /** 默认隐藏、按需放行的工具族。 */
+    families: {
+        delegation: {
+            enabled: true,
+            tools: ['subagent', 'subagent_fork', 'send_message', 'list_agents', 'interrupt_agent'],
+            keywords: ['子代理', '子agent', '委托', '分派', '派给', '子任务', 'subagent', 'delegate', 'fork'],
+        },
+        workflow: {
+            enabled: true,
+            tools: ['workflow'],
+            keywords: ['工作流', 'workflow', '编排', '多阶段'],
+        },
+        ralph: {
+            enabled: true,
+            tools: ['ralph'],
+            keywords: ['ralph', '全新agent', 'fresh agent'],
+        },
+        goal: {
+            enabled: true,
+            tools: ['create_goal', 'get_goal', 'update_goal'],
+            keywords: ['长期目标', '跨轮次', '目标追踪', 'goal'],
+        },
+    },
+    /** 首轮锚定（参照 dsh-anchored-standard）。 */
+    bootstrap: {
+        /** 是否启用首轮锚定。 */
+        enabled: true,
+        /**
+         * 是否挂载真实 Minimal 工具对（0.5.0）：把官方 minimal preset 的持久
+         * PTY bash + str_replace_editor 挂进 agent 作用域（按名阴影 standard 的
+         * sandboxed bash），使请求 #1 的 schema 与 Minimal 逐字相同。依赖
+         * @deepseek-ai 官方插件包，不可用时自动降级为旧行为（仅收窄目录）。
+         */
+        realPair: true,
+        /** 请求 #1 可见的工具（真实 Minimal 工具对）。 */
+        tools: ['bash', 'str_replace_editor'],
+        /** 晋升触发：either（默认）/ tool-call / assistant-message。 */
+        promoteOn: 'either',
+        /** 请求 #1 剥离的自动注入上下文 source.kind；[] 关闭剥离。 */
+        suppressedContextSources: ['skill-catalog', 'agent-instructions'],
+        /** 晋升后 resident 目录的常驻发现工具（按需解锁完整目录）。 */
+        discoveryTools: ['dev_tool_search', 'skill_search', 'skill_load'],
+        /** 请求 #1 的输出预算封顶（token）；0 = 不封顶（opt-in）。 */
+        maxTokens: 0,
+    },
+    /**
+     * 极简提示词层（语域锚定，参照 dsh-anchored-standard 的完整条件）。
+     *
+     * 参考实现指出：首轮"轨迹"（思维链风格）锚定需要 **Minimal 的完整 system
+     * prompt**——只收窄工具 schema 不够。本层对目标 preset 的会话：
+     *   - suppressSections：按名阴影屏蔽全局引导段（harness:identity、
+     *     harness:source、app:web-surface），空段在装配时被丢弃，等同极简
+     *     complete persona 的效果（plan-mode 段、PTC 的 SDK 段不受影响）；
+     *   - persona：按名阴影替换 deployment:persona 为极简语域的短 persona
+     *     （默认与极简模式逐字相同；留空则不替换）。
+     * 两处都是 agent 作用域的 prompt 段阴影，仅影响目标会话，随会话销毁自动
+     * 释放；对已恢复/已晋升的旧会话同样生效（不依赖 bootstrap 阶段）。
+     */
+    minimalPrompt: {
+        /** 是否启用极简提示词层。 */
+        enabled: true,
+        /** 替换后的 persona 文本；与极简模式相同可完全对齐语域。留空不替换。 */
+        persona: 'You are a helpful software engineer assistant.',
+        /** 屏蔽全局引导段（identity / source / web-surface）。 */
+        suppressSections: true,
+    },
+};
+/** 轻量配置校验/归一化：非法字段回退默认值，避免 config.json 或 remote.set
+ * 写入错误类型后在事件路径上抛 TypeError。 */
+function boolValue(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function stringList(value, fallback) {
+    if (Array.isArray(value)) {
+        const out = value.filter((v) => typeof v === 'string' && v.trim().length > 0).map((v) => v.trim());
+        return out.length > 0 ? out : fallback;
+    }
+    if (typeof value === 'string') {
+        const out = value.split(/[,，\s]+/).filter((v) => v.length > 0);
+        return out.length > 0 ? out : fallback;
+    }
+    return fallback;
+}
+/** 与 stringList 相同，但显式空数组保持为空（语义是有意义的配置值）。 */
+function stringListOrEmpty(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    return stringList(value, []);
+}
+export function normalizeConfig(source, defaults = DEFAULT_CONFIG) {
+    const raw = source !== null && typeof source === 'object' && !Array.isArray(source) ? source : {};
+    const merged = { ...defaults, ...raw };
+    const families = {};
+    const rawFamilies = raw.families !== null && typeof raw.families === 'object' && !Array.isArray(raw.families)
+        ? raw.families
+        : defaults.families;
+    for (const [id, fam] of Object.entries(defaults.families)) {
+        const candidate = rawFamilies[id] !== null && typeof rawFamilies[id] === 'object' && !Array.isArray(rawFamilies[id])
+            ? rawFamilies[id]
+            : fam;
+        families[id] = {
+            enabled: boolValue(candidate.enabled, fam.enabled),
+            tools: stringList(candidate.tools, fam.tools),
+            keywords: stringList(candidate.keywords, fam.keywords),
+        };
+    }
+    const rawBootstrap = raw.bootstrap !== null && typeof raw.bootstrap === 'object' && !Array.isArray(raw.bootstrap)
+        ? raw.bootstrap
+        : defaults.bootstrap;
+    const db = defaults.bootstrap;
+    const promoteOn = rawBootstrap.promoteOn === 'tool-call' || rawBootstrap.promoteOn === 'assistant-message'
+        ? rawBootstrap.promoteOn
+        : rawBootstrap.promoteOn === 'either' ? 'either' : db.promoteOn;
+    const maxTokensRaw = rawBootstrap.maxTokens;
+    const maxTokens = Number.isSafeInteger(maxTokensRaw) && maxTokensRaw > 0 ? maxTokensRaw : 0;
+    const bootstrap = {
+        enabled: boolValue(rawBootstrap.enabled, db.enabled),
+        realPair: boolValue(rawBootstrap.realPair, db.realPair),
+        tools: stringList(rawBootstrap.tools, db.tools),
+        promoteOn,
+        suppressedContextSources: stringListOrEmpty(rawBootstrap.suppressedContextSources, db.suppressedContextSources),
+        discoveryTools: stringList(rawBootstrap.discoveryTools, db.discoveryTools),
+        maxTokens,
+    };
+    const rawMP = raw.minimalPrompt !== null && typeof raw.minimalPrompt === 'object' && !Array.isArray(raw.minimalPrompt)
+        ? raw.minimalPrompt
+        : defaults.minimalPrompt;
+    const dm = defaults.minimalPrompt;
+    const minimalPrompt = {
+        enabled: boolValue(rawMP.enabled, dm.enabled),
+        persona: typeof rawMP.persona === 'string' ? rawMP.persona.trim() : dm.persona,
+        suppressSections: boolValue(rawMP.suppressSections, dm.suppressSections),
+    };
+    return {
+        enabled: boolValue(merged.enabled, defaults.enabled),
+        presets: stringList(merged.presets, defaults.presets),
+        suppressRuntimeContext: boolValue(merged.suppressRuntimeContext, defaults.suppressRuntimeContext),
+        leanByDefault: boolValue(merged.leanByDefault, defaults.leanByDefault),
+        escalateOnKeyword: boolValue(merged.escalateOnKeyword, defaults.escalateOnKeyword),
+        escalateOnUnknownTool: boolValue(merged.escalateOnUnknownTool, defaults.escalateOnUnknownTool),
+        suppressInjectedContext: boolValue(merged.suppressInjectedContext, defaults.suppressInjectedContext),
+        coreTools: stringList(merged.coreTools, defaults.coreTools),
+        families,
+        bootstrap,
+        minimalPrompt,
+    };
+}
+/** remote.set 的严格校验：非法值直接拒绝并返回错误，而不是静默写坏文件。 */
+export function validateConfig(partial) {
+    if (partial === null || typeof partial !== 'object' || Array.isArray(partial)) {
+        throw new TypeError('adaptive-perf config must be a plain object');
+    }
+    const boolFields = ['enabled', 'suppressRuntimeContext', 'leanByDefault', 'escalateOnKeyword', 'escalateOnUnknownTool',
+        'suppressInjectedContext'];
+    for (const key of boolFields) {
+        if (partial[key] !== void 0 && typeof partial[key] !== 'boolean') {
+            throw new TypeError(`adaptive-perf config field "${key}" must be a boolean`);
+        }
+    }
+    for (const key of ['presets', 'coreTools']) {
+        if (partial[key] !== void 0 && !(Array.isArray(partial[key]) && partial[key].every((v) => typeof v === 'string'))) {
+            throw new TypeError(`adaptive-perf config field "${key}" must be an array of strings`);
+        }
+    }
+    if (partial.families !== void 0) {
+        if (partial.families === null || typeof partial.families !== 'object' || Array.isArray(partial.families)) {
+            throw new TypeError('adaptive-perf config field "families" must be an object');
+        }
+        for (const [id, fam] of Object.entries(partial.families)) {
+            if (fam === null || typeof fam !== 'object' || Array.isArray(fam)) {
+                throw new TypeError(`adaptive-perf config family "${id}" must be an object { enabled, tools, keywords }`);
+            }
+            if (fam.enabled !== void 0 && typeof fam.enabled !== 'boolean') {
+                throw new TypeError(`adaptive-perf config family "${id}".enabled must be a boolean`);
+            }
+            for (const key of ['tools', 'keywords']) {
+                if (fam[key] !== void 0 && !(Array.isArray(fam[key]) && fam[key].every((v) => typeof v === 'string'))) {
+                    throw new TypeError(`adaptive-perf config family "${id}".${key} must be an array of strings`);
+                }
+            }
+        }
+    }
+    if (partial.bootstrap !== void 0) {
+        const b = partial.bootstrap;
+        if (b === null || typeof b !== 'object' || Array.isArray(b)) {
+            throw new TypeError('adaptive-perf config field "bootstrap" must be an object');
+        }
+        if (b.enabled !== void 0 && typeof b.enabled !== 'boolean') {
+            throw new TypeError('adaptive-perf config field "bootstrap.enabled" must be a boolean');
+        }
+        if (b.realPair !== void 0 && typeof b.realPair !== 'boolean') {
+            throw new TypeError('adaptive-perf config field "bootstrap.realPair" must be a boolean');
+        }
+        if (b.promoteOn !== void 0 && !['either', 'tool-call', 'assistant-message'].includes(b.promoteOn)) {
+            throw new TypeError('adaptive-perf config field "bootstrap.promoteOn" must be "either" | "tool-call" | "assistant-message"');
+        }
+        if (b.maxTokens !== void 0 && !(Number.isSafeInteger(b.maxTokens) && b.maxTokens >= 0)) {
+            throw new TypeError('adaptive-perf config field "bootstrap.maxTokens" must be a non-negative safe integer');
+        }
+        for (const key of ['tools', 'suppressedContextSources', 'discoveryTools']) {
+            if (b[key] !== void 0 && !(Array.isArray(b[key]) && b[key].every((v) => typeof v === 'string'))) {
+                throw new TypeError(`adaptive-perf config field "bootstrap.${key}" must be an array of strings`);
+            }
+        }
+    }
+    if (partial.minimalPrompt !== void 0) {
+        const m = partial.minimalPrompt;
+        if (m === null || typeof m !== 'object' || Array.isArray(m)) {
+            throw new TypeError('adaptive-perf config field "minimalPrompt" must be an object');
+        }
+        if (m.enabled !== void 0 && typeof m.enabled !== 'boolean') {
+            throw new TypeError('adaptive-perf config field "minimalPrompt.enabled" must be a boolean');
+        }
+        if (m.suppressSections !== void 0 && typeof m.suppressSections !== 'boolean') {
+            throw new TypeError('adaptive-perf config field "minimalPrompt.suppressSections" must be a boolean');
+        }
+        if (m.persona !== void 0 && typeof m.persona !== 'string') {
+            throw new TypeError('adaptive-perf config field "minimalPrompt.persona" must be a string');
+        }
+    }
+}
+// ── 纯函数（导出便于回归测试）────────────────────────────────────────────
+/** 被极简提示词层屏蔽的全局引导段（name, order，与 dsh-app-boot /
+ * dsh-web-app / dsh-system-prompt 的注册一致）。 */
+export const SECTION_SHADOWS = [
+    ['harness:identity', -100],
+    ['harness:source', -99],
+    ['app:web-surface', -98],
+];
+/** persona 段的注册名与顺序（dsh-system-prompt 的 PERSONA_SECTION/PERSONA_ORDER）。 */
+export const PERSONA_SECTION_NAME = 'deployment:persona';
+export const PERSONA_SECTION_ORDER = 0;
+/** 提取一条用户消息的顶层文本（text 块拼接）。 */
+export function extractUserText(message) {
+    if (message === null || typeof message !== 'object' || !Array.isArray(message.content))
+        return '';
+    let text = '';
+    for (const block of message.content) {
+        if (block !== null && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') {
+            text += block.text;
+        }
+    }
+    return text;
+}
+/** 大小写不敏感的子串匹配：任一关键词命中即返回 true。 */
+export function matchKeywords(text, keywords) {
+    if (!Array.isArray(keywords) || keywords.length === 0)
+        return false;
+    const haystack = String(text ?? '').toLowerCase();
+    return keywords.some((k) => typeof k === 'string' && k.length > 0 && haystack.includes(k.toLowerCase()));
+}
+/** 收集一次工具调用失败的模型可见文本（error 字段 + content 文本块）。 */
+export function collectFailureText(result) {
+    if (result === null || typeof result !== 'object')
+        return '';
+    const parts = [];
+    const error = result.error;
+    if (error !== null && typeof error === 'object') {
+        if (typeof error.code === 'string')
+            parts.push(error.code);
+        if (typeof error.message === 'string')
+            parts.push(error.message);
+        if (typeof error.text === 'string')
+            parts.push(error.text);
+    }
+    if (Array.isArray(result.content)) {
+        for (const block of result.content) {
+            if (block !== null && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') {
+                parts.push(block.text);
+            }
+        }
+    }
+    return parts.join('\n');
+}
+// ── 真实 Minimal 工具对（0.5.0，参照 dsh-anchored-standard issue #11）──────
+/**
+ * 官方 minimal preset 的持久 bash 工具描述，逐字一致。schema（参数）由
+ * @deepseek-ai/dsh-tool-bash-persistent 提供，与 minimal preset 挂的是同一
+ * 个包；描述在这里显式传入，保证与 minimal 的 agent.cordis.yml 完全一致。
+ */
+export const MINIMAL_BASH_DESCRIPTION = [
+    'Run commands in a bash shell',
+    '* When invoking this tool, the contents of the "command" parameter does NOT need to be XML-escaped.',
+    "* You don't have access to the internet via this tool.",
+    '* You do have access to a mirror of common linux and python packages via apt and pip.',
+    '* State is persistent across command calls and discussions with the user.',
+    "* To inspect a particular line range of a file, e.g. lines 10-25, try 'sed -n 10,25p /path/to/the/file'.",
+    '* Please avoid commands that may produce a very large amount of output.',
+    "* Please run long lived commands in the background, e.g. 'sleep 10 &' or start a server in the background.",
+].join('\n');
+/**
+ * 被真实工具对按名阴影的工具引导段：standard 的 sandboxed bash 注册了
+ * `tool:bash`（order 105）引导段，挂载真实工具对后该文本已与可见工具不符，
+ * 按名阴影为空段（装配时丢弃）。
+ */
+export const TOOL_GUIDANCE_SHADOWS = [
+    ['tool:bash', 105],
+];
+/** 真实工具对挂载所需的官方插件包说明符（声明在 optionalDependencies）。 */
+export const REAL_PAIR_SPECS = {
+    terminal: '@deepseek-ai/dsh-terminal',
+    terminalBash: '@deepseek-ai/dsh-terminal-bash',
+    bashPersistent: '@deepseek-ai/dsh-tool-bash-persistent',
+    fsLocal: '@deepseek-ai/dsh-fs-local',
+    strReplaceEditor: '@deepseek-ai/dsh-tool-str-replace-editor',
+};
+/**
+ * 加载真实 Minimal 工具对所需模块。任一包不可用即整体返回 null（调用方
+ * 降级为旧行为），绝不抛出。
+ * @param importFn - 测试可注入的 import 实现（默认动态 import）。
+ */
+export async function loadRealPairModules(importFn) {
+    const dynamicImport = importFn ?? ((spec) => import(spec));
+    const modules = {};
+    for (const [key, spec] of Object.entries(REAL_PAIR_SPECS)) {
+        try {
+            const mod = await dynamicImport(spec);
+            modules[key] = mod?.default ?? mod;
+        }
+        catch {
+            modules[key] = null;
+        }
+    }
+    if (Object.keys(REAL_PAIR_SPECS).some((key) => modules[key] === null))
+        return null;
+    return modules;
+}
+/**
+ * 计算真实工具对的挂载清单（纯函数，便于测试）：
+ * 顺序 = 依赖在前（terminals → backend → bash；fs → editor）。
+ * @param modules - loadRealPairModules 的结果。
+ * @param cwd - str_replace_editor 本地 fs 的工作目录（会话 cwd）。
+ */
+export function realPairMounts(modules, cwd) {
+    if (modules === null || modules === void 0)
+        return [];
+    const resolvedCwd = typeof cwd === 'string' && cwd.length > 0
+        ? cwd
+        : (process.env.DSH_CWD && process.env.DSH_CWD.trim().length > 0 ? process.env.DSH_CWD : process.cwd());
+    return [
+        { module: modules.terminal, config: {} },
+        { module: modules.terminalBash, config: { timeoutMs: 300000 } },
+        { module: modules.bashPersistent, config: { timeoutMs: 300000, description: MINIMAL_BASH_DESCRIPTION } },
+        { module: modules.fsLocal, config: { cwd: resolvedCwd } },
+        { module: modules.strReplaceEditor, config: { maxOutputChars: 16000 } },
+    ];
+}
+/**
+ * 在 agent 作用域挂载真实工具对（scoped registration 按名阴影继承工具）。
+ * 每个挂载是一个独立 fiber，dispose 时全部副作用（工具/schema/服务）撤销。
+ * @param agent - 目标 agent（其 ctx 必须带 scope 标签）。
+ * @param mounts - realPairMounts 的结果。
+ * @param warn - 日志回调。
+ * @returns 可释放的 disposer 列表。
+ */
+export function mountRealPair(agent, mounts, warn) {
+    const disposers = [];
+    if (agent === null || typeof agent !== 'object' || typeof agent.ctx?.plugin !== 'function')
+        return disposers;
+    for (const mount of mounts) {
+        if (mount?.module === null || mount?.module === void 0)
+            continue;
+        try {
+            const fiber = agent.ctx.plugin(mount.module, mount.config ?? {});
+            disposers.push(() => {
+                try {
+                    fiber.dispose();
+                }
+                catch { }
+            });
+        }
+        catch (error) {
+            warn?.(`mountRealPair failed for ${String(mount.module?.name ?? 'module')}: ${String(error?.message ?? String(error))}`);
+        }
+    }
+    return disposers;
+}
+/**
+ * 从 agent/pre-step 的 decision.messages 剥离指定 source.kind 的消息。
+ * 保留原数组引用（未变化时）便于调用方判断。
+ */
+export function stripSuppressedMessages(messages, suppressedSources) {
+    if (!Array.isArray(messages) || suppressedSources.size === 0)
+        return messages;
+    const kept = messages.filter((message) => {
+        const kind = message?.source?.kind;
+        return typeof kind !== 'string' || !suppressedSources.has(kind);
+    });
+    return kept.length === messages.length ? messages : kept;
+}
+// ── bootstrap 锚定（参照 dsh-anchored-standard 的实测结论）──────────────
+/** promoteOn 配置 → 晋升的持久事件类型集合。 */
+export const PROMOTE_EVENTS = {
+    'tool-call': ['tool/call'],
+    'assistant-message': ['assistant/message'],
+    either: ['tool/call', 'assistant/message'],
+};
+/**
+ /**
+ * dev_tool_search：搜索完整可见目录并按名解锁工具（解锁结果下一请求生效，
+ * 经 syncBootstrap 重算 deny 集；解锁记录写入 a.unlocked，resume-safe 由
+ * loadUnlockedFromEvents 从持久事件恢复）。
+ */
+export function createDevToolSearch({ schemasOf, onUnlock, catalogHint }) {
+    const hint = catalogHint ?? [
+        'This session starts with a minimal resident set: bash, str_replace_editor.',
+        'Everything else is unlocked on demand through this tool.',
+    ].join('\n');
+    return {
+        name: 'dev_tool_search',
+        description: [
+            'Discover and unlock tools that are NOT currently available.',
+            '',
+            hint,
+            '',
+            'If the current task needs internet, delegation, workflows, goals, images, background jobs, or multi-agent coordination, call dev_tool_search FIRST — do not try to work around them with bash.',
+            '',
+            'Usage: pass `query` to search the catalog (returns matching tool names + descriptions), then pass `toolNames` with exact names to unlock them. Unlocked tools appear from the next request on and stay unlocked for the session.',
+        ].join('\n'),
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'search keywords (e.g. "web", "subagent")' },
+                toolNames: { type: 'array', description: 'exact tool names to unlock', items: { type: 'string' } },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: { text: { type: 'string' } }, required: ['text'] },
+            render: (_a, value) => [{ type: 'text', text: value.text }],
+        },
+        async execute(args, exec) {
+            const query = args !== null && typeof args === 'object' && typeof args.query === 'string' ? args.query.trim() : '';
+            const unlock = args !== null && typeof args === 'object' && Array.isArray(args.toolNames)
+                ? args.toolNames.filter((name) => typeof name === 'string' && name.length > 0)
+                : [];
+            const lines = [];
+            if (unlock.length > 0) {
+                let available = new Set();
+                try {
+                    const schemas = typeof schemasOf === 'function' ? (schemasOf(exec) ?? []) : [];
+                    for (const schema of schemas) {
+                        if (schema !== null && typeof schema === 'object' && typeof schema.name === 'string')
+                            available.add(schema.name);
+                    }
+                }
+                catch { }
+                const ok = unlock.filter((name) => available.has(name));
+                if (ok.length > 0 && typeof onUnlock === 'function') {
+                    try {
+                        await onUnlock(ok, exec);
+                    }
+                    catch { }
+                }
+                if (ok.length > 0)
+                    lines.push(`Unlocked for the next request: ${ok.join(', ')}`);
+                const missing = unlock.filter((name) => !available.has(name));
+                if (missing.length > 0)
+                    lines.push(`Not found in catalog: ${missing.join(', ')}`);
+            }
+            if (query.length === 0 && unlock.length === 0) {
+                lines.push('Provide `query` to search the catalog, or `toolNames` to unlock tools.');
+                return { text: lines.join('\n') };
+            }
+            if (query.length === 0) {
+                return { text: lines.join('\n') || 'Nothing to do.' };
+            }
+            try {
+                const schemas = typeof schemasOf === 'function' ? (schemasOf(exec) ?? []) : [];
+                const wanted = query.toLowerCase().split(/[^a-z0-9_]+/).filter(Boolean);
+                const matches = schemas
+                    .filter((schema) => {
+                    if (schema === null || typeof schema !== 'object')
+                        return false;
+                    const haystack = `${schema.name || ''} ${schema.description || ''}`.toLowerCase();
+                    return wanted.every((token) => haystack.includes(token));
+                })
+                    .slice(0, 25);
+                if (matches.length === 0) {
+                    lines.push(`No tools match "${query}".`);
+                }
+                else {
+                    lines.push(`Matching tools (${matches.length}):`);
+                    for (const schema of matches) {
+                        const desc = String(schema.description || '').split('\n')[0] ?? ''.slice(0, 90);
+                        lines.push(`- ${schema.name}: ${desc}`);
+                    }
+                    lines.push('Unlock with dev_tool_search({"toolNames": ["<exact name>"]}).');
+                }
+            }
+            catch (error) {
+                lines.push(`catalog search unavailable: ${String(error?.message ?? String(error))}`);
+            }
+            return { text: lines.join('\n') };
+        },
+    };
+}
+/**
+ * skill_search：按关键词搜索可用技能（仅摘要，替代 ~9KB 目录注入）。
+ * skillsOf 返回宿主 skills 服务（调用期解析）。
+ */
+export function createSkillSearch({ skillsOf }) {
+    const tokens = (text) => (text || '').toLowerCase().split(/[^a-z0-9_-]+/).filter(Boolean);
+    return {
+        name: 'skill_search',
+        description: 'Search the available skills by keyword and return matching skill names with short descriptions. This session keeps NO skill catalog in the prompt — if a task looks like it matches a skill (document conversion, image processing, game reviews, markdown, PDF, spreadsheets, …), call skill_search FIRST to find it, then skill_load to activate it. Do NOT assume skill names from memory.',
+        parameters: {
+            type: 'object',
+            properties: { query: { type: 'string', description: 'search keywords (e.g. "pdf", "obsidian", "game review")' } },
+            required: ['query'],
+            additionalProperties: false,
+        },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: { text: { type: 'string' } }, required: ['text'] },
+            render: (_a, value) => [{ type: 'text', text: value.text }],
+        },
+        async execute(args, exec) {
+            const wanted = tokens(args?.query);
+            try {
+                const skills = skillsOf();
+                if (skills === void 0 || typeof skills.list !== 'function') {
+                    return { text: 'skill_search unavailable: skills service is not mounted.' };
+                }
+                const agent = exec?.agent;
+                const lookup = {
+                    scope: agent,
+                    cwd: agent?.session?.header?.cwd,
+                    signal: exec?.signal,
+                };
+                const all = await skills.list(lookup);
+                const matches = (Array.isArray(all) ? all : []).filter((skill) => {
+                    if (wanted.length === 0)
+                        return true;
+                    const haystack = tokens(`${skill?.name ?? ''} ${skill?.description ?? ''} ${skill?.whenToUse ?? ''}`).join(' ');
+                    return wanted.every((token) => haystack.includes(token));
+                });
+                const head = matches.slice(0, 20);
+                const lines = head.map((skill) => {
+                    const desc = String(skill?.description || '').split('\n')[0] ?? '';
+                    return `- ${skill?.name}: ${desc}`;
+                });
+                if (lines.length === 0)
+                    return { text: `No skills match "${args?.query}". Use skill_search with other keywords.` };
+                const extra = matches.length > 20 ? `\n…(${matches.length - 20} more)` : '';
+                return { text: `Matching skills (${matches.length}):\n${lines.join('\n')}${extra}\n\nLoad one with skill_load (exact name).` };
+            }
+            catch (error) {
+                return { text: `skill_search unavailable: ${String(error?.message ?? String(error))}` };
+            }
+        },
+    };
+}
+/**
+ * skill_load：按精确名加载单个技能的完整说明，经 agent.inject 作为
+ * source.kind='skill-invocation' 的下一条上下文消息注入（用户主动技能手势
+ * 同款来源，绝不被默认抑制集剥离）。
+ */
+export function createSkillLoad({ skillsOf }) {
+    return {
+        name: 'skill_load',
+        description: 'Load the full instructions of ONE skill by its exact name (from skill_search results) and inject them for the next request. Call this before acting on a task that matches the skill.',
+        parameters: {
+            type: 'object',
+            properties: { name: { type: 'string', description: 'exact skill name (kebab-case, from skill_search)' } },
+            required: ['name'],
+            additionalProperties: false,
+        },
+        output: {
+            schema: { type: 'object', additionalProperties: false, properties: { text: { type: 'string' } }, required: ['text'] },
+            render: (_a, value) => [{ type: 'text', text: value.text }],
+        },
+        async execute(args, exec) {
+            try {
+                const agent = exec?.agent;
+                if (agent === void 0)
+                    return { text: 'skill_load requires an agent context.' };
+                const skills = skillsOf();
+                if (skills === void 0 || typeof skills.get !== 'function') {
+                    return { text: 'skill_load unavailable: skills service is not mounted.' };
+                }
+                const name = typeof args?.name === 'string' ? args.name.trim() : '';
+                if (name.length === 0)
+                    return { text: 'skill_load requires a skill name.' };
+                const skill = await skills.get(name, {
+                    scope: agent,
+                    cwd: agent.session?.header?.cwd,
+                    signal: exec?.signal,
+                });
+                if (skill === void 0) {
+                    return { text: `No skill named "${name}". Run skill_search to list available skills.` };
+                }
+                const body = extractSkillBody(skill);
+                if (body.length === 0) {
+                    return { text: `Skill "${name}" has no loadable body.` };
+                }
+                if (typeof agent.inject !== 'function') {
+                    return { text: `Skill "${name}" found, but injection is unavailable in this agent.` };
+                }
+                agent.inject({
+                    id: `skill-load-${name}-${Date.now()}`,
+                    role: 'user',
+                    content: [{ type: 'text', text: body }],
+                    source: { kind: 'skill-invocation', name, form: 'instructions' },
+                });
+                return { text: `Skill "${name}" loaded; its instructions will be injected for the next request.` };
+            }
+            catch (error) {
+                return { text: `skill_load failed: ${String(error?.message ?? String(error))}` };
+            }
+        },
+    };
+}
+/** 提取已加载技能定义的模型可见正文（与参考实现一致）。 */
+export function extractSkillBody(skill) {
+    const content = skill?.content ?? skill?.instructions ?? skill?.body;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((part) => (typeof part === 'string' ? part : JSON.stringify(part))).join('\n');
+    }
+    return '';
+}
+/**
+ * 扫描一段持久会话日志，推导 { promoted } 阶段。
+ * 晋升是持久信号（与 dsh-anchored-standard 一致）：首次 promoteOn 事件后
+ * 恒为已晋升，resume/reload 不丢状态，compaction 不重置。
+ */
+export function scanPhase(events, promoteEvents) {
+    let promoted = false;
+    if (Array.isArray(events)) {
+        for (const event of events) {
+            if (promoteEvents.includes(event?.type)) {
+                promoted = true;
+                break;
+            }
+        }
+    }
+    return { promoted };
+}
+/** 增量喂入一个持久事件（仅更新已存在条目；冷会话由 scanPhase 全量推导）。 */
+export function observePhase(state, sessionId, event) {
+    const entry = state.get(sessionId);
+    if (entry === void 0)
+        return;
+    if (entry.promoted)
+        return;
+    const promoteEvents = Array.isArray(entry.promoteEvents)
+        ? entry.promoteEvents
+        : PROMOTE_EVENTS[entry.promoteOn] ?? [];
+    if (promoteEvents.includes(event?.type)) {
+        state.set(sessionId, { ...entry, promoted: true });
+    }
+}
+/**
+ * 按 keep 集合收窄装配后的工具目录。
+ * @returns { tools, missing } —— missing 非空表示 keep 中的工具在目录里缺失，
+ * 调用方决定是否降级（全目录放行）。
+ */
+export function filterBootstrapTools(assembly, keep) {
+    const keepSet = keep instanceof Set ? keep : new Set(keep);
+    const tools = Array.isArray(assembly?.tools) ? assembly.tools : [];
+    const available = new Set(tools.map((tool) => tool?.name).filter((n) => typeof n === 'string'));
+    const missing = [...keepSet].filter((n) => !available.has(n));
+    return {
+        tools: tools.filter((tool) => keepSet.has(tool.name)),
+        missing,
+    };
+}
+/** 按 source.kind 剥离自动注入的上下文消息（保留主动的用户消息）。 */
+export function filterBootstrapMessages(messages, suppressedSources) {
+    if (!Array.isArray(messages) || suppressedSources.size === 0)
+        return messages;
+    const kept = messages.filter((message) => {
+        const kind = message?.source?.kind;
+        return typeof kind !== 'string' || !suppressedSources.has(kind);
+    });
+    return kept.length === messages.length ? messages : kept;
+}
+/** 首轮输出预算：未晋升 → 封顶；已晋升 → 若仍带着封顶值则剥离。 */
+export function applyBootstrapBudget(config, promoted, maxTokens) {
+    if (!promoted)
+        return { ...config, maxTokens };
+    if (config?.maxTokens === maxTokens) {
+        const { maxTokens: _drop, ...rest } = config;
+        return rest;
+    }
+    return config;
+}
+// ── host 插件 ────────────────────────────────────────────────────────────
+/** 把配置 namespace 注册进宿主 settings 体系（dsh-settings 0.1.0-rc.7+）。
+ * 设置页 describe() 只枚举 settings.register 注册过的 namespace；本插件
+ * 的卡片读写不经过宿主 settings 文档，注册只为让卡片出现在设置页。
+ * options.base 必传当前生效配置快照：宿主 resolve = schema(mergeLayers(base,
+ * section))，schema 无默认值时 base 缺失会让 describe() 的 value 为
+ * undefined，而设置页 wire 校验要求 value 非空（invalid_type: nonoptional），
+ * 一项失败会拖垮整个设置页。本插件的 any() schema 完全依赖 base。
+ * fail-safe（schema 库/服务缺失静默跳过）+ 幂等（重复注册忽略）。
+ * 导出以便测试注入 Schema stub。 */
+export function registerSettingsNamespace(ctx, ns, schemaLib, buildSchema, options) {
+    if (schemaLib === null || schemaLib === undefined)
+        return false;
+    if (ctx === null || typeof ctx !== 'object' || typeof ctx.inject !== 'function')
+        return false;
+    try {
+        ctx.inject(['settings'], (settingsCtx) => {
+            try {
+                settingsCtx.settings.register(ns, buildSchema(schemaLib), options);
+            }
+            catch (error) {
+                const message = String(error?.message ?? String(error));
+                if (!message.includes('already registered'))
+                    throw error;
+            }
+        });
+        return true;
+    }
+    catch (error) {
+        try {
+            ctx.logger?.warn?.(`adaptive-perf: settings namespace registration skipped: ${error?.message ?? String(error)}`);
+        }
+        catch { }
+        return false;
+    }
+}
+export async function apply(ctx, config, options = {}) {
+    // fail-safe：初始化失败只记录，绝不让本插件拖垮 harness（host 层挂载时
+    // entry 异常会导致进程启动失败）。
+    try {
+        const systemPrompt = ctx.get('systemPrompt');
+        const tools = ctx.get('tools');
+        if (systemPrompt === void 0 || tools === void 0) {
+            ctx.logger?.warn?.('adaptive-perf: systemPrompt/tools service unavailable; plugin inactive');
+            return;
+        }
+        const agentPresets = ctx.get('agentPresets');
+        if (agentPresets === void 0) {
+            ctx.logger?.warn?.('adaptive-perf: agentPresets service unavailable (no agent presets composed); plugin inactive');
+            return;
+        }
+        const agentsService = ctx.get('agents');
+        const patchConfig = config !== null && typeof config === 'object' && !Array.isArray(config) ? config : {};
+        /** 当前生效配置（热更新；后续 store 创建后以 config.json 权威合并结果覆盖）。 */
+        let cfg = normalizeConfig(patchConfig);
+        /** 真实 Minimal 工具对模块（0.5.0）。加载失败 = null = 降级旧行为。
+         *  options.realPairModules 仅供测试注入。 */
+        let realPairModules = options.realPairModules === void 0
+            ? (cfg.bootstrap.enabled && cfg.bootstrap.realPair ? await loadRealPairModules() : null)
+            : options.realPairModules;
+        /** 是否已尝试加载过真实工具对模块（避免配置热更新时反复重试）。 */
+        let realPairModulesTried = options.realPairModules !== void 0 || (cfg.bootstrap.enabled && cfg.bootstrap.realPair);
+        if (cfg.bootstrap.enabled && cfg.bootstrap.realPair && realPairModules === null) {
+            try {
+                ctx.logger?.warn?.('adaptive-perf: real Minimal tool pair modules unavailable (optional @deepseek-ai deps missing?); falling back to catalog-only bootstrap');
+            }
+            catch { }
+        }
+        /**
+         * 配置热更新把 realPair 从关闭切到开启时补加载官方模块（初始未启用时
+         * 不加载）。加载成功后对已接管会话补挂。
+         */
+        function ensureRealPairModules() {
+            if (realPairModulesTried || cfg.bootstrap.enabled === false || cfg.bootstrap.realPair === false)
+                return;
+            realPairModulesTried = true;
+            loadRealPairModules().then((mods) => {
+                if (mods === null)
+                    return;
+                realPairModules = mods;
+                info('real Minimal tool pair modules loaded; mounting for live agents');
+                for (const a of agents.values()) {
+                    syncRealPair(a);
+                    applyMinimalPrompt(a);
+                    syncBootstrap(a);
+                }
+            }).catch(() => { });
+        }
+        /** agentId -> 会话自适应状态。 */
+        const agents = new Map();
+        const warn = (message) => { try {
+            ctx.logger?.warn?.(`adaptive-perf: ${message}`);
+        }
+        catch { } };
+        const info = (message) => { try {
+            ctx.logger?.info?.(`adaptive-perf: ${message}`);
+        }
+        catch { } };
+        /** 该会话是否为目标 preset。 */
+        function isTarget(agent) {
+            if (!cfg.enabled)
+                return false;
+            try {
+                const presetId = agentPresets.composedPreset(agent.ctx);
+                return presetId !== void 0 && cfg.presets.includes(presetId);
+            }
+            catch (error) {
+                warn(`preset lookup failed for agent ${agent.id}: ${error?.message ?? String(error)}`);
+                return false;
+            }
+        }
+        /** 计算某族当前应隐藏的工具名（与该 agent 实际可见目录取交集）。 */
+        function familyDeny(a, family) {
+            if (!Array.isArray(family.tools))
+                return [];
+            return family.tools.filter((n) => typeof n === 'string' && a.visibleNames.has(n));
+        }
+        /** 应用/更新运行时上下文抑制。总开关关闭时一并释放。 */
+        function applySuppression(a) {
+            const want = cfg.enabled && cfg.suppressRuntimeContext;
+            if (want && a.suppressDisposer === null) {
+                try {
+                    a.suppressDisposer = a.agent.ctx.systemPrompt.suppressRuntimeContext();
+                    info(`agent ${a.agent.id}: runtime context suppressed`);
+                }
+                catch (error) {
+                    warn(`suppressRuntimeContext failed for agent ${a.agent.id}: ${error?.message ?? String(error)}`);
+                }
+            }
+            else if (!want && a.suppressDisposer !== null) {
+                try {
+                    a.suppressDisposer();
+                }
+                catch { }
+                a.suppressDisposer = null;
+            }
+        }
+        /** 应用/更新极简提示词层（persona 阴影 + 全局引导段屏蔽 +
+         *  真实工具对替换后的 tool 引导段阴影）。 */
+        function applyMinimalPrompt(a) {
+            for (const disposer of a.promptDisposers) {
+                try {
+                    disposer();
+                }
+                catch { }
+            }
+            a.promptDisposers = [];
+            if (!cfg.enabled || !cfg.minimalPrompt.enabled)
+                return;
+            const sp = a.agent.ctx.systemPrompt;
+            try {
+                if (cfg.minimalPrompt.suppressSections) {
+                    for (const [name, order] of SECTION_SHADOWS) {
+                        a.promptDisposers.push(sp.section({ name, order, text: '' }));
+                    }
+                }
+                if (a.realPairActive) {
+                    for (const [name, order] of TOOL_GUIDANCE_SHADOWS) {
+                        a.promptDisposers.push(sp.section({ name, order, text: '' }));
+                    }
+                }
+                const persona = cfg.minimalPrompt.persona.trim();
+                if (persona.length > 0) {
+                    a.promptDisposers.push(sp.section({ name: PERSONA_SECTION_NAME, order: PERSONA_SECTION_ORDER, text: persona }));
+                }
+                info(`agent ${a.agent.id}: minimal prompt layer active`);
+            }
+            catch (error) {
+                warn(`minimalPrompt failed for agent ${a.agent.id}: ${error?.message ?? String(error)}`);
+            }
+        }
+        /** 应用/更新工具族限制（lean 模式）。总开关关闭、族被禁用、已升级、
+         *  已从配置删除的族一律放行。 */ function applyFamilies(a) {
+            if (!cfg.enabled || !cfg.leanByDefault) {
+                for (const [id, disposer] of a.familyDisposers) {
+                    try {
+                        disposer();
+                    }
+                    catch { }
+                    a.familyDisposers.delete(id);
+                }
+                return;
+            }
+            // 1) 清理不再需要的限制（族被禁用 / 已升级 / 配置里已不存在）。
+            for (const [id, disposer] of a.familyDisposers) {
+                const family = cfg.families[id];
+                if (family === void 0 || family.enabled === false || a.escalated.has(id)) {
+                    try {
+                        disposer();
+                    }
+                    catch { }
+                    a.familyDisposers.delete(id);
+                }
+            }
+            // 2) 补齐需要的新限制。
+            for (const [id, family] of Object.entries(cfg.families)) {
+                if (a.familyDisposers.has(id))
+                    continue;
+                if (family.enabled === false || a.escalated.has(id))
+                    continue;
+                const deny = familyDeny(a, family);
+                if (deny.length === 0)
+                    continue;
+                try {
+                    const disposer = a.agent.ctx.tools.restrict({ deny });
+                    a.familyDisposers.set(id, disposer);
+                }
+                catch (error) {
+                    warn(`restrict failed for agent ${a.agent.id} family "${id}": ${error?.message ?? String(error)}`);
+                }
+            }
+        }
+        /** 当前隐藏的工具名（活跃限制族的 deny 并集，供失败信号匹配）。 */
+        function hiddenNames(a) {
+            const out = new Set();
+            for (const [id, family] of Object.entries(cfg.families)) {
+                if (!a.familyDisposers.has(id))
+                    continue;
+                for (const n of familyDeny(a, family))
+                    out.add(n);
+            }
+            return out;
+        }
+        /** 放行一个工具族（会话内单调：只升不降）。 */
+        function escalate(a, familyId, trigger) {
+            if (a.escalated.has(familyId))
+                return;
+            a.escalated.add(familyId);
+            const disposer = a.familyDisposers.get(familyId);
+            if (disposer !== void 0) {
+                try {
+                    disposer();
+                }
+                catch { }
+                a.familyDisposers.delete(familyId);
+            }
+            info(`agent ${a.agent.id}: escalated family "${familyId}" (${trigger})`);
+        }
+        /** 从持久事件恢复 dev_tool_search 已解锁的工具（resume-safe）。 */
+        function loadUnlockedFromEvents(a) {
+            const events = a.agent.session && Array.isArray(a.agent.session.events) ? a.agent.session.events : [];
+            for (const event of events) {
+                if (event === null || typeof event !== 'object' || event.type !== 'tool/call')
+                    continue;
+                if (event.data === null || typeof event.data !== 'object' || event.data.name !== 'dev_tool_search')
+                    continue;
+                let args = event.data.arguments;
+                if (typeof args === 'string') {
+                    try {
+                        args = JSON.parse(args);
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (args === null || typeof args !== 'object' || Array.isArray(args))
+                    continue;
+                if (Array.isArray(args.toolNames)) {
+                    for (const name of args.toolNames) {
+                        if (typeof name === 'string' && name.length > 0)
+                            a.unlocked.add(name);
+                    }
+                }
+            }
+        }
+        /**
+         * 挂载/卸载真实 Minimal 工具对（0.5.0）：把官方 minimal preset 同款插件
+         * （持久 PTY bash + str_replace_editor 及其依赖的 terminals/本地 fs）
+         * 挂进 agent 作用域。scoped registration 按名阴影 standard 的 sandboxed
+         * bash，且自身层注册不受 restrict 影响（view() 对 own layer 豁免）——
+         * 首轮目录因此是"真实工具对 + 被 deny 的其他继承工具"。
+         * 依赖模块缺失（realPairModules === null）或 Windows（PTY 仅 linux/darwin）
+         * 时静默降级：不挂载，退回旧行为（仅收窄目录）。
+         */
+        function syncRealPair(a) {
+            for (const dispose of a.realPairDisposers) {
+                try {
+                    dispose();
+                }
+                catch { }
+            }
+            a.realPairDisposers = [];
+            const active = cfg.enabled && cfg.bootstrap.enabled && cfg.bootstrap.realPair
+                && realPairModules !== null && process.platform !== 'win32';
+            if (active) {
+                const mounts = realPairMounts(realPairModules, a.agent.session?.header?.cwd);
+                a.realPairDisposers = mountRealPair(a.agent, mounts, warn);
+                if (a.realPairDisposers.length > 0) {
+                    info(`agent ${a.agent.id}: real Minimal tool pair mounted (${mounts.length} plugins)`);
+                }
+            }
+            a.realPairActive = a.realPairDisposers.length > 0;
+        }
+        /**
+         * 给目标 agent 注册 on-demand 发现工具（dsh-anchored-standard 的 resident
+         * discovery pattern）：晋升后常驻 bootstrap.discoveryTools 列出的工具——
+         * dev_tool_search（搜索完整目录并按名解锁，解锁结果下一请求生效，写入
+         * a.unlocked 后 syncBootstrap 重算 deny 集）+ skill_search / skill_load
+         * （常驻上下文抑制的替代品：按需发现/加载技能）。
+         * 已存在的同名工具（preset 自带）不重复注册。
+         */
+        function syncDiscoveryTools(a, enabled) {
+            const want = enabled ? cfg.bootstrap.discoveryTools : [];
+            for (const [name, disposer] of a.toolDisposers) {
+                if (!want.includes(name)) {
+                    try {
+                        disposer();
+                    }
+                    catch { }
+                    a.toolDisposers.delete(name);
+                }
+            }
+            if (!enabled)
+                return;
+            const scopedTools = a.agent.ctx && a.agent.ctx.tools;
+            if (scopedTools === void 0 || typeof scopedTools.register !== 'function')
+                return;
+            for (const name of want) {
+                if (a.toolDisposers.has(name))
+                    continue;
+                if (a.visibleNames.has(name))
+                    continue; // preset/宿主已提供同名工具
+                const def = discoveryToolDef(a, name);
+                if (def === null)
+                    continue;
+                try {
+                    const disposer = scopedTools.register(def);
+                    if (typeof disposer === 'function')
+                        a.toolDisposers.set(name, disposer);
+                }
+                catch (error) {
+                    warn(`register ${name} failed for agent ${a.agent.id}: ${error?.message ?? String(error)}`);
+                }
+            }
+        }
+        /** 构造一个发现工具定义；未知名称返回 null。 */
+        function discoveryToolDef(a, name) {
+            if (name === 'dev_tool_search') {
+                return createDevToolSearch({
+                    schemasOf: (exec) => {
+                        const agent = exec !== null && typeof exec === 'object' ? exec.agent : void 0;
+                        return agent === void 0 ? [] : tools.schemas(agent);
+                    },
+                    onUnlock: async (names, exec) => {
+                        const agent = exec !== null && typeof exec === 'object' ? exec.agent : void 0;
+                        const state = agent === void 0 ? void 0 : agents.get(agent.id);
+                        if (state === void 0)
+                            return;
+                        for (const name of names)
+                            state.unlocked.add(name);
+                        syncBootstrap(state);
+                    },
+                    catalogHint: 'This session starts with a minimal resident set: bash, str_replace_editor, skill_search, skill_load. Everything else is unlocked on demand through this tool.',
+                });
+            }
+            if (name === 'skill_search') {
+                return createSkillSearch({ skillsOf: () => ctx.get('skills') });
+            }
+            if (name === 'skill_load') {
+                return createSkillLoad({ skillsOf: () => ctx.get('skills') });
+            }
+            return null;
+        }
+        /** 完整接管一个 agent（幂等）。 */
+        function handleAgent(agent) {
+            if (agents.has(agent.id))
+                return;
+            if (!isTarget(agent))
+                return;
+            const a = {
+                agent,
+                suppressDisposer: null,
+                promptDisposers: [],
+                familyDisposers: new Map(),
+                bootstrapDisposer: null,
+                bootstrapKey: null,
+                escalated: new Set(),
+                visibleNames: new Set(),
+                unlocked: new Set(),
+                toolDisposers: new Map(),
+                realPairDisposers: [],
+                realPairActive: false,
+            };
+            // 记录当前可见目录（限制前）；仅记录真实存在的工具，后续 restrict 与
+            // 实际目录取交集，preset 升级改名/删除工具不会让本插件崩溃。
+            try {
+                for (const schema of tools.schemas(agent)) {
+                    if (schema !== null && typeof schema === 'object' && typeof schema.name === 'string') {
+                        a.visibleNames.add(schema.name);
+                    }
+                }
+            }
+            catch (error) {
+                warn(`schemas lookup failed for agent ${agent.id}: ${error?.message ?? String(error)}`);
+            }
+            loadUnlockedFromEvents(a);
+            agents.set(agent.id, a);
+            applySuppression(a);
+            syncRealPair(a);
+            applyMinimalPrompt(a);
+            applyFamilies(a);
+            syncBootstrap(a);
+            info(`agent ${agent.id}: adaptive-perf active (preset ${String(agentPresets.composedPreset(agent.ctx))})`);
+        }
+        /** 释放一个 agent 的全部副作用。 */
+        function releaseAgent(agentId) {
+            const a = agents.get(agentId);
+            agents.delete(agentId);
+            bootstrapState.delete(agentId);
+            if (a === void 0)
+                return;
+            if (a.suppressDisposer !== null) {
+                try {
+                    a.suppressDisposer();
+                }
+                catch { }
+            }
+            for (const disposer of a.promptDisposers) {
+                try {
+                    disposer();
+                }
+                catch { }
+            }
+            a.promptDisposers = [];
+            for (const dispose of a.realPairDisposers) {
+                try {
+                    dispose();
+                }
+                catch { }
+            }
+            a.realPairDisposers = [];
+            if (a.bootstrapDisposer !== null) {
+                try {
+                    a.bootstrapDisposer();
+                }
+                catch { }
+            }
+            for (const disposer of a.toolDisposers.values()) {
+                try {
+                    disposer();
+                }
+                catch { }
+            }
+            a.toolDisposers.clear();
+            for (const disposer of a.familyDisposers.values()) {
+                try {
+                    disposer();
+                }
+                catch { }
+            }
+        }
+        // ── 事件监听（注册在 host 根作用域，与 dsh-agent-presets 同款用法）──
+        ctx.on('agent/created', ({ agent }) => {
+            handleAgent(agent);
+        });
+        ctx.on('agent/disposed', ({ agent }) => {
+            releaseAgent(agent.id);
+        });
+        // 关键词信号：用户消息进入收件箱（早于回合处理与请求装配）。
+        // 监听器无条件注册，事件时按实时 cfg 判断，热更新开关即时生效。
+        ctx.on('agent/inbox/inserted', ({ agent, message }) => {
+            if (!cfg.enabled || !cfg.escalateOnKeyword)
+                return;
+            const a = agents.get(agent.id);
+            if (a === void 0)
+                return;
+            const text = extractUserText(message);
+            if (text.length === 0)
+                return;
+            for (const [id, family] of Object.entries(cfg.families)) {
+                if (a.escalated.has(id) || family.enabled === false)
+                    continue;
+                if (matchKeywords(text, family.keywords))
+                    escalate(a, id, 'keyword');
+            }
+        });
+        // 失败信号：PTC 程序调用隐藏工具报错（文本含工具名）时放行对应族。
+        ctx.on('tools/result', (exec, result) => {
+            if (!cfg.enabled || !cfg.escalateOnUnknownTool)
+                return;
+            const agent = exec !== null && typeof exec === 'object' ? exec.agent : void 0;
+            if (agent === void 0)
+                return;
+            const a = agents.get(agent.id);
+            if (a === void 0)
+                return;
+            if (result === null || typeof result !== 'object' || result.isError !== true)
+                return;
+            const text = collectFailureText(result);
+            if (text.length === 0)
+                return;
+            const hidden = hiddenNames(a);
+            if (hidden.size === 0)
+                return;
+            for (const [id, family] of Object.entries(cfg.families)) {
+                if (a.escalated.has(id) || family.enabled === false)
+                    continue;
+                for (const n of family.tools) {
+                    if (hidden.has(n) && text.includes(n)) {
+                        escalate(a, id, 'unknown-tool');
+                        break;
+                    }
+                }
+            }
+        });
+        // ── 首轮锚定（bootstrap，参照 dsh-anchored-standard 的实测结论）─────
+        // 阶段状态：sessionId -> { promoted, promoteEvents }。冷会话在
+        // handleAgent 时全量扫描持久日志（resume 安全），此后 session/event 增量
+        // 更新。晋升是持久信号（compaction 不重置）。子代理（delegationDepth > 0）
+        // 恒为已晋升。所有 waterfall 用 prepend 注册，保证本插件是"最外层"
+        // 变换（剥离是最后一道）。
+        const bootstrapState = new Map();
+        let bootstrapWarned = false;
+        const warnBootstrapOnce = (message) => {
+            if (bootstrapWarned)
+                return;
+            bootstrapWarned = true;
+            warn(message);
+        };
+        function bootstrapPhaseOf(agent) {
+            const session = agent !== null && typeof agent === 'object' ? agent.session : void 0;
+            if (session === void 0 || typeof session.id !== 'string')
+                return { promoted: true };
+            // 子代理首轮即可用工具（与参考实现一致）。
+            if ((session.header?.delegationDepth ?? 0) > 0)
+                return { promoted: true };
+            let entry = bootstrapState.get(session.id);
+            if (entry === void 0) {
+                entry = {
+                    ...scanPhase(session.events, PROMOTE_EVENTS[cfg.bootstrap.promoteOn]),
+                    promoteOn: cfg.bootstrap.promoteOn,
+                };
+                bootstrapState.set(session.id, entry);
+            }
+            return entry;
+        }
+        /** bootstrap 是否对该会话生效（总开关 + 目标 preset + 无会话时放行）。 */
+        function bootstrapActiveFor(agent) {
+            if (!cfg.enabled || !cfg.bootstrap.enabled)
+                return false;
+            if (agent === void 0)
+                return true;
+            return isTarget(agent);
+        }
+        /**
+         * bootstrap 阶段的保留工具集（0.7.0：首轮锚定、晋升后 resident 目录）：
+         *  - 未晋升：bootstrap 工具对 + PTC 的直接调用工具（run_code）；
+         *  - 已晋升：bootstrap 工具对 + 常驻发现工具（dev_tool_search /
+         *    skill_search / skill_load）+ dev_tool_search 已解锁工具
+         *    （dsh-anchored-standard 的 resident catalog：晋升时一次性倒出
+         *    完整 Standard 目录会把轨迹拉回 standard-like——晋升后回退问题，
+         *    因此重型工具保持一次 dev_tool_search 即可取用）。
+         *
+         * 注意：不能靠过滤 system-prompt/assemble 的 assembly.tools 来实现——
+         * PTC 模式下 assembly.tools 只有 [run_code]，Minimal 工具对不在其中，
+         * 过滤会触发降级（实测首轮模型仍看到 15 个工具）。正确做法是
+         * tools.restrict（与族限制同一机制）：它同时驱动 API 目录和 PTC 的
+         * SDK 参考段，且天然保留 run_code（不在 deny 里）。
+         */
+        function bootstrapKeepSet(a) {
+            if (!cfg.enabled || !cfg.bootstrap.enabled)
+                return null;
+            const session = a.agent.session;
+            if (session === void 0)
+                return null; // 无会话信息时保持既有行为（测试/未知场景）
+            const phase = bootstrapPhaseOf(a.agent);
+            const keep = new Set(cfg.bootstrap.tools);
+            if (a.visibleNames.has('run_code'))
+                keep.add('run_code');
+            if (phase.promoted) {
+                for (const name of cfg.bootstrap.discoveryTools)
+                    keep.add(name);
+                for (const name of a.unlocked)
+                    keep.add(name);
+            }
+            return keep;
+        }
+        /** 按当前阶段同步 bootstrap 的临时 restrict（幂等；仅阶段/配置变化时重挂）。 */
+        function syncBootstrap(a) {
+            const phase = bootstrapPhaseOf(a.agent);
+            const keep = bootstrapKeepSet(a);
+            // discovery 工具只在晋升后的 resident 阶段注册；bootstrap 阶段隐藏。
+            syncDiscoveryTools(a, keep !== null && phase.promoted);
+            const key = keep === null ? null : [...keep].sort().join(',');
+            if (key === a.bootstrapKey)
+                return;
+            if (a.bootstrapDisposer !== null) {
+                try {
+                    a.bootstrapDisposer();
+                }
+                catch { }
+                a.bootstrapDisposer = null;
+                a.bootstrapKey = null;
+            }
+            if (keep === null)
+                return;
+            const deny = [...a.visibleNames].filter((name) => !keep.has(name));
+            if (deny.length === 0)
+                return;
+            try {
+                a.bootstrapDisposer = a.agent.ctx.tools.restrict({ deny });
+                a.bootstrapKey = key;
+                info(`agent ${a.agent.id}: bootstrap restrict deny=${deny.length} keep=[${[...keep].join(',')}]`);
+            }
+            catch (error) {
+                warn(`bootstrap restrict failed for agent ${a.agent.id}: ${String(error?.message ?? String(error))}`);
+            }
+        }
+        // 持久事件增量喂入：晋升信号 / compaction 纪元；阶段变化时同步 bootstrap 限制。
+        ctx.on('session/event', (session, event) => {
+            if (session === null || typeof session !== 'object' || typeof session.id !== 'string')
+                return;
+            const before = bootstrapState.get(session.id);
+            observePhase(bootstrapState, session.id, event);
+            const a = agents.get(session.id);
+            if (a !== void 0) {
+                const after = bootstrapState.get(session.id);
+                if (before === void 0 || after === void 0 || before.promoted !== after.promoted) {
+                    syncBootstrap(a);
+                }
+            }
+        });
+        // 上下文剥离（首轮锚定的注入部分）。prepend + 根作用域注册保证是
+        // 最后一道变换（后注册的注入者无法再补回）。
+        // 剥离条件：bootstrap 未晋升（首轮剥离）或常驻抑制开启
+        // （suppressInjectedContext，0.7.0 默认开启：晋升后注入保持剥离，
+        // 由常驻发现工具承担功能可见性）。
+        ctx.on('agent/pre-step', async ({ agent }, next) => {
+            const decision = await next();
+            if (decision === null || typeof decision !== 'object' || decision.kind === 'reject')
+                return decision;
+            try {
+                if (!cfg.enabled || !isTarget(agent))
+                    return decision;
+                const phase = bootstrapPhaseOf(agent);
+                const suppressed = new Set(cfg.bootstrap.suppressedContextSources);
+                if (suppressed.size === 0)
+                    return decision;
+                const stripActive = (cfg.bootstrap.enabled && !phase.promoted) || cfg.suppressInjectedContext;
+                if (!stripActive || !Array.isArray(decision.messages))
+                    return decision;
+                const kept = stripSuppressedMessages(decision.messages, suppressed);
+                return kept === decision.messages ? decision : { ...decision, messages: kept };
+            }
+            catch (error) {
+                // 过滤失败绝不吞掉用户的上下文：原样放行。
+                warnBootstrapOnce(`bootstrap context filter failed, keeping injected context: ${String(error?.message ?? String(error))}`);
+                return decision;
+            }
+        }, { prepend: true });
+        // 可选：请求 #1 输出预算封顶（晋升后剥离，避免封顶沿 header 种子延续）。
+        if (cfg.bootstrap.maxTokens > 0) {
+            ctx.on('agent/request', async ({ agent }, next) => {
+                const resolved = await next();
+                try {
+                    if (!bootstrapActiveFor(agent))
+                        return resolved;
+                    const phase = bootstrapPhaseOf(agent);
+                    return applyBootstrapBudget(resolved, phase.promoted, cfg.bootstrap.maxTokens);
+                }
+                catch (error) {
+                    warnBootstrapOnce(`bootstrap budget filter failed: ${String(error?.message ?? String(error))}`);
+                    return resolved;
+                }
+            }, { prepend: true });
+        }
+        // 已运行会话补挂（插件热重载/重装时）。
+        if (agentsService !== void 0 && typeof agentsService.list === 'function') {
+            try {
+                for (const agent of agentsService.list())
+                    handleAgent(agent);
+            }
+            catch (error) {
+                warn(`existing agent sweep failed: ${error?.message ?? String(error)}`);
+            }
+        }
+        // 配置存储：patch config 为低优先级，config.json（设置页 UI）权威。
+        // onUpdate 把 UI 保存的改动热更新进 cfg，并对所有已接管会话重算。
+        const store = createConfigStore({
+            name: 'adaptive-perf',
+            defaults: DEFAULT_CONFIG,
+            patchConfig,
+            validate: validateConfig,
+            warn,
+            onUpdate: (merged) => {
+                cfg = normalizeConfig({ ...patchConfig, ...merged });
+                info('config hot-updated; recomputing restrictions for live agents');
+                // realPair 从关闭切到开启：补加载官方模块（首次尝试失败不反复重试）。
+                ensureRealPairModules();
+                // 补挂此前创建的会话（例如插件从 disabled 切换为 enabled，或新增了
+                // 目标 preset）：新符合条件的 agent 立即接管（handleAgent 已应用全部
+                // 层，下面的重算只针对此前已接管的 agent，避免同一 onUpdate 内重复）。
+                const existing = new Set(agents.keys());
+                if (agentsService !== void 0 && typeof agentsService.list === 'function') {
+                    try {
+                        for (const agent of agentsService.list())
+                            handleAgent(agent);
+                    }
+                    catch (error) {
+                        warn(`config-update agent sweep failed: ${error?.message ?? String(error)}`);
+                    }
+                }
+                for (const agentId of existing) {
+                    const a = agents.get(agentId);
+                    if (a === void 0)
+                        continue;
+                    applySuppression(a);
+                    syncRealPair(a);
+                    applyMinimalPrompt(a);
+                    applyFamilies(a);
+                    syncBootstrap(a);
+                }
+            },
+        });
+        cfg = normalizeConfig(store.effective());
+        // 远程配置服务（设置页 UI 读写；typert 不可用时跳过）
+        if (PluginConfigGateway !== null) {
+            ctx.plugin(PluginConfigGateway, { store, serviceKey: 'adaptivePerfConfig' });
+        }
+        // 注册进宿主 settings 体系（可见性）：设置页用 settings.describe() 枚举
+        // registrations，未注册的 namespace 即使卡片带正确的 key 也不渲染。
+        // 卡片的实际读写仍走上面的 config gateway（config.json 权威、热更新）。
+        // 配置为多层嵌套结构（families/bootstrap/minimalPrompt…），schema 用 any
+        // 透传——describe 元数据只服务于可见性，卡片不读取它。any() 无默认值，
+        // 必须传 base（当前生效配置快照），否则 describe() 的 value 为 undefined，
+        // 设置页 wire 校验（nonoptional）会整体失败。
+        registerSettingsNamespace(ctx, 'adaptivePerfConfig', Schema, (z) => z.any(), { base: cfg });
+        // 卸载清理：释放全部会话副作用与监听。
+        ctx.effect(() => () => {
+            for (const agentId of [...agents.keys()])
+                releaseAgent(agentId);
+        });
+    }
+    catch (error) {
+        try {
+            ctx.logger?.error?.(`adaptive-perf: init failed (harness continues without adaptive performance): ${error?.message ?? String(error)}`);
+        }
+        catch { }
+    }
+}
+//# sourceMappingURL=index.js.map