@chaoset/adaptive-perf 0.6.0 → 0.7.1

package/lib/index.mjs

@@ -1,1611 +0,0 @@
-/**
- * adaptive-perf — 极简性能自适应插件（@chaoset/adaptive-perf）
- *
- * 目标：让「标准模式（standard）」与「PTC 模式（code）」达到与「极简模式
- * （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）
- *      后进入 **resident 目录**：工具对 + 常驻发现工具（dev_tool_search /
- *      skill_search / skill_load）+ 已解锁工具，而不是一次性 dump 完整
- *      Standard 目录（避免 post-promotion regression）；阶段从持久会话事件
- *      推导，resume/reload 不丢状态；compaction/end 之后回到受控目录
- *      （工具对 + compactionTools）直到新的晋升信号（纪元感知）；
- *      bootstrap.maxTokens（可选）给请求 #1 封顶输出预算，晋升后剥离。
- *   D. 常驻上下文抑制（suppressInjectedContext，0.5.0 新增）：技能目录提醒
- *      与 AGENTS.md 摘要**不再在晋升后恢复**——参考实现实测它们即使在后置
- *      阶段也扰动轨迹且每个请求多耗数千 token。替代品：
- *        - skill_search / skill_load：按需发现并注入单个技能的完整说明
- *          （晋升后常驻，替代 ~9KB 的 <available_skills> 注入）；
- *        - instruction-hint：晋升后只注入**一次**的短提示——"这些指令文件
- *          存在，需要时自己读"，而不是每请求 dump 全文（文件探测走宿主 fs，
- *          探测失败不注入，绝不抛错）。
- *   E. 工具目录自适应精简：会话启动时按"工具族"默认隐藏高开销低频工具
- *      （子代理 / 工作流 / 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.tools.register()  在 agent 作用域注册工具（按名阴影继承工具，
- *       自身层注册不受 restrict 影响——view() 对 own layer 豁免）
- *   - agent.ctx.plugin()  挂载官方 minimal preset 同款插件（持久 bash /
- *       str_replace_editor / 其依赖的 terminals 与本地 fs）
- *   - agent/pre-step（waterfall） 剥离自动注入上下文 + 注入 instruction-hint
- *   - agent/request（waterfall） 首轮输出预算封顶
- *   - session/event  增量喂入持久事件（晋升 / compaction 纪元）
- *   - 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.mjs';
-
-// remote 服务（设置页 UI 的配置读写）可选：typert-protocol 不可用时
-// 动态 import 失败，核心功能（自适应）照常工作。
-let PluginConfigGateway = null;
-try {
-  ({ PluginConfigGateway } = await import('./remote.mjs'));
-} catch (error) {
-  console.warn('adaptive-perf: settings gateway unavailable: ' + (error && error.message || 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 之后回到
- * 受控目录（bootstrap 工具对 + compactionTools）直到新的晋升信号；maxTokens>0
- * 时给请求 #1 封顶输出预算（晋升后剥离）。
- */
-export const DEFAULT_CONFIG = {
-  /** 总开关：关闭后插件对会话不产生任何影响。 */
-  enabled: true,
-  /** 应用自适应的 agent preset 列表（composedPreset 返回值）。 */
-  presets: ['standard', 'code'],
-  /**
-   * 默认策略（0.6.0）：功能优先，全部优化 opt-in。旧版把下列机制默认
-   * 开启，导致 standard/PTC 模式功能缺失（工具族从目录删除 → PTC 程序
-   * 调用直接 UNKNOWN_TOOL；技能目录/指令摘要被剥离；官方引导段被屏蔽；
-   * 首轮只剩两个工具）。这些机制的收益本质是"砍上下文换 token"，没有
-   * 无损形态，因此默认全部关闭，保持官方 preset 的完整功能；需要省
-   * token 时按需开启（设置页或 config.json），开启即接受相应的功能
-   * 约束（关键词/失败信号放行、skill_search 按需发现等补偿机制仍在）。
-   */
-  /** 抑制运行时上下文快照（等同极简模式的 includeRuntimeContext: false）。 */
-  suppressRuntimeContext: false,
-  /** 会话启动时默认隐藏编排类工具族（核心编码工具始终保留）。 */
-  leanByDefault: false,
-  /** 用户消息命中工具族触发词时自动放行该族（会话内单调）。 */
-  escalateOnKeyword: true,
-  /** 工具调用失败（UNKNOWN_TOOL 文本含隐藏工具名）时自动放行该族。 */
-  escalateOnUnknownTool: true,
-  /**
-   * 常驻上下文抑制（0.5.0）：true = 整个会话剥离自动注入上下文
-   * （skill-catalog 技能目录提醒、agent-instructions AGENTS.md 摘要），
-   * 不再像旧版那样在晋升后恢复——替代品是 skill_search/skill_load 按需发现
-   * 与 instruction-hint 一次性提示。false = 只在 bootstrap（请求 #1）剥离。
-   */
-  suppressInjectedContext: false,
-  /** 晋升后常驻 skill_search / skill_load 两个按需技能发现工具。 */
-  skillDiscovery: true,
-  /** 晋升后注入一次"指令文件存在，需要时自读"的短提示（替代全文注入）。 */
-  instructionHint: 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: false,
-    /**
-     * 是否挂载真实 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'],
-    /** compaction/end 之后、再次晋升前可用的额外核心工作集。 */
-    compactionTools: ['read', 'write', 'edit', 'glob', 'grep', 'todo_write', 'ask_user_question'],
-    /** 晋升后常驻的按需发现工具（dsh-anchored-standard 的 resident discovery set）。 */
-    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: false,
-    /** 替换后的 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),
-    compactionTools: stringListOrEmpty(rawBootstrap.compactionTools, db.compactionTools),
-    discoveryTools: stringListOrEmpty(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),
-    skillDiscovery: boolValue(merged.skillDiscovery, defaults.skillDiscovery),
-    instructionHint: boolValue(merged.instructionHint, defaults.instructionHint),
-    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', 'skillDiscovery', 'instructionHint'];
-  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', 'compactionTools', '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 && error.message) || error)}`);
-    }
-  }
-  return disposers;
-}
-
-// ── instruction-hint（0.5.0，参照 dsh-anchored-standard）──────────────────
-
-/** 项目链候选指令文件名（探测顺序）与用户全局候选。 */
-export const INSTRUCTION_PROJECT_CANDIDATES = ['AGENTS.md', 'CLAUDE.md', 'AGENTS.local.md', 'CLAUDE.local.md'];
-export const INSTRUCTION_USER_CANDIDATE = 'AGENTS.md';
-
-/** 平台无关的路径拼接（与参考实现一致）。 */
-export function joinPath(dir, segment) {
-  if (dir.endsWith('/') || dir.endsWith('\\')) return dir + segment;
-  const sep = dir.includes('\\') ? '\\' : '/';
-  return dir + sep + segment;
-}
-
-/** 绝对 POSIX/Windows 路径的父目录。 */
-export function parentPath(path) {
-  const idx = Math.max(path.lastIndexOf('/'), path.lastIndexOf('\\'));
-  if (idx <= 0) return path;
-  const parent = path.slice(0, idx);
-  return parent.length === 0 ? path : parent;
-}
-
-/** 从 cwd 向上找项目根（含 .git/.hg/.svn 标记的最近祖先）。 */
-export async function findProjectRoot(fs, cwd, signal) {
-  let current = cwd;
-  for (;;) {
-    for (const marker of ['.git', '.hg', '.svn']) {
-      try {
-        const target = await fs.resolve(joinPath(current, marker), { cwd, signal });
-        const info = await fs.stat(target, signal);
-        if (info !== void 0) return current;
-      } catch {
-        // 探测失败 = 标记不存在，继续。
-      }
-    }
-    const parent = parentPath(current);
-    if (parent === current || parent.length === 0) return cwd;
-    current = parent;
-  }
-}
-
-/** 列出某目录下存在的候选指令文件。 */
-export async function presentInDir(fs, dir, candidates, signal) {
-  const found = [];
-  for (const candidate of candidates) {
-    try {
-      const target = await fs.resolve(joinPath(dir, candidate), { cwd: dir, signal });
-      const info = await fs.stat(target, signal);
-      if (info !== void 0 && info.type === 'file') found.push(candidate);
-    } catch {
-      // 不存在/不可读——跳过。
-    }
-  }
-  return found;
-}
-
-/**
- * 探测会话的指令文件（项目链 + $DSH_HOME/AGENTS.md）。任何失败都返回
- * null/空集——提示注入绝不能让会话受损。
- * @returns { projectFiles, root, userGlobalFiles } 或 null（无 fs / 无 cwd）。
- */
-export async function probeInstructionFiles(fs, cwd, dshHome, signal) {
-  if (fs === null || fs === void 0 || typeof cwd !== 'string' || cwd.length === 0) return null;
-  const projectFiles = [];
-  let root = cwd;
-  try {
-    root = await findProjectRoot(fs, cwd, signal);
-    projectFiles.push(...await presentInDir(fs, root, INSTRUCTION_PROJECT_CANDIDATES, signal));
-  } catch {
-    // 项目链探测失败——忽略，仍报告用户全局文件。
-  }
-  const userGlobalFiles = [];
-  if (typeof dshHome === 'string' && dshHome.length > 0) {
-    try {
-      userGlobalFiles.push(...await presentInDir(fs, dshHome, [INSTRUCTION_USER_CANDIDATE], signal));
-    } catch {
-      // 不可读——忽略。
-    }
-  }
-  if (projectFiles.length === 0 && userGlobalFiles.length === 0) return null;
-  return { projectFiles, root, userGlobalFiles };
-}
-
-// ── 按需发现工具（resident discovery set，参照 dsh-anchored-standard）─────
-
-/**
- * 从 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;
-}
-
-/**
- * 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 && error.message) || 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 && error.message) || 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 && error.message) || 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 '';
-}
-
-// ── bootstrap 锚定（参照 dsh-anchored-standard 的实测结论）──────────────
-
-/** promoteOn 配置 → 晋升的持久事件类型集合。 */
-export const PROMOTE_EVENTS = {
-  'tool-call': ['tool/call'],
-  'assistant-message': ['assistant/message'],
-  either: ['tool/call', 'assistant/message'],
-};
-
-/**
- * 扫描一段持久会话日志，推导 { boundary, promoted } 阶段。
- * compaction/end 之后需要新的晋升信号（纪元感知）；boundary 为 -1 表示
- * 尚无压缩。事件无 seq 时按"边界之后"处理（与参考实现一致）。
- */
-export function scanPhase(events, promoteEvents) {
-  let boundary = -1;
-  let promoted = false;
-  if (Array.isArray(events)) {
-    for (const event of events) {
-      const seq = typeof event?.seq === 'number' ? event.seq : 0;
-      if (event?.type === 'compaction/end') {
-        boundary = seq;
-        promoted = false;
-        continue;
-      }
-      if (promoteEvents.includes(event?.type) && seq > boundary) promoted = true;
-    }
-  }
-  return { boundary, promoted };
-}
-
-/** 增量喂入一个持久事件（仅更新已存在条目；冷会话由 scanPhase 全量推导）。 */
-export function observePhase(state, sessionId, event) {
-  const entry = state.get(sessionId);
-  if (entry === void 0) return;
-  const seq = typeof event?.seq === 'number' ? event.seq : 0;
-  if (event?.type === 'compaction/end') {
-    state.set(sessionId, { boundary: seq, promoted: false, promoteEvents: entry.promoteEvents });
-    return;
-  }
-  if (entry.promoted) return;
-  const promoteEvents = entry.promoteEvents;
-  if (promoteEvents.includes(event?.type) && seq > entry.boundary) {
-    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 && error.message || error);
-        if (!message.includes('already registered')) throw error;
-      }
-    });
-    return true;
-  } catch (error) {
-    try { ctx.logger?.warn?.(`adaptive-perf: settings namespace registration skipped: ${error && error.message || 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 仅供测试注入。 */
-    const 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 {}
-    }
-
-    /** 已注入过 instruction-hint 的会话（内存去重，与参考实现一致）。 */
-    const hintedSessions = new Set();
-
-    /**
-     * 配置热更新把 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 && error.message || 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 && error.message || 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 && error.message || 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 && error.message || 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 && error.message || 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' && cfg.skillDiscovery) {
-        return createSkillSearch({ skillsOf: () => ctx.get('skills') });
-      }
-      if (name === 'skill_load' && cfg.skillDiscovery) {
-        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 && error.message || 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 disposer of a.toolDisposers.values()) {
-        try { disposer(); } catch {}
-      }
-      a.toolDisposers.clear();
-      for (const dispose of a.realPairDisposers) {
-        try { dispose(); } catch {}
-      }
-      a.realPairDisposers = [];
-      if (a.bootstrapDisposer !== null) {
-        try { a.bootstrapDisposer(); } catch {}
-      }
-      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 -> { boundary, promoted, promoteEvents }。冷会话在
-    // handleAgent 时全量扫描持久日志（resume 安全），此后 session/event 增量
-    // 更新。子代理（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 { boundary: -1, promoted: true };
-      // 子代理首轮即可用工具（与参考实现一致）。
-      if ((session.header?.delegationDepth ?? 0) > 0) return { boundary: -1, promoted: true };
-      let entry = bootstrapState.get(session.id);
-      if (entry === void 0) {
-        entry = {
-          ...scanPhase(session.events, PROMOTE_EVENTS[cfg.bootstrap.promoteOn]),
-          promoteEvents: PROMOTE_EVENTS[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 阶段的保留工具集：
-     *  - 未晋升：bootstrap 工具对 + PTC 的直接调用工具（run_code）+
-     *    compaction 后恢复期的工作集；
-     *  - 已晋升：bootstrap 工具对 + resident discovery 工具 +
-     *    dev_tool_search 已解锁工具 + 已升级工具族（dsh-anchored-standard 的
-     *    resident catalog，避免晋升后一次性 dump 完整 Standard 目录）。
-     *
-     * 注意：不能靠过滤 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);
-        for (const [id, family] of Object.entries(cfg.families)) {
-          if (a.escalated.has(id)) {
-            for (const name of familyDeny(a, family)) keep.add(name);
-          }
-        }
-        return keep;
-      }
-      if (phase.boundary >= 0) for (const name of cfg.bootstrap.compactionTools) keep.add(name);
-      return keep;
-    }
-
-    /** 按当前阶段同步 bootstrap 的临时 restrict（幂等；仅阶段/配置变化时重挂）。 */
-    function syncBootstrap(a) {
-      const phase = bootstrapPhaseOf(a.agent);
-      const keep = bootstrapKeepSet(a);
-      // discovery 工具只在晋升后的 resident 阶段注册；bootstrap/compaction 阶段隐藏。
-      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 && error.message) || 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 || before.boundary !== after.boundary) {
-          syncBootstrap(a);
-        }
-      }
-    });
-
-    // 上下文剥离 + instruction-hint。prepend + 根作用域注册保证是最后一道
-    // 变换（后注册的注入者无法再补回）。两个职责同在一个监听器里，顺序天然
-    // 正确：先剥离被抑制来源，再（晋升后一次性）追加指令文件提示。
-    // 剥离与 bootstrap 开关正交：常驻抑制（suppressInjectedContext）在
-    // bootstrap 关闭时也生效；instruction-hint 依赖晋升阶段（bootstrap 机制）。
-    ctx.on('agent/pre-step', async ({ agent, signal }, 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);
-        let out = decision;
-        // 剥离条件：bootstrap 未晋升（旧行为）或常驻抑制开启（0.5.0 默认：
-        // 整个会话不再注入技能目录与 AGENTS.md 摘要，替代品是按需发现工具）。
-        const stripActive = (cfg.bootstrap.enabled && !phase.promoted) || cfg.suppressInjectedContext;
-        if (suppressed.size > 0 && stripActive && Array.isArray(out.messages)) {
-          const kept = stripSuppressedMessages(out.messages, suppressed);
-          out = kept === out.messages ? out : { ...out, messages: kept };
-        }
-        // instruction-hint：晋升后一次性注入"指令文件存在，需要时自读"。
-        if (cfg.bootstrap.enabled && cfg.instructionHint && phase.promoted && Array.isArray(out.messages)) {
-          const session = agent.session;
-          if (session !== null && typeof session === 'object' && typeof session.id === 'string' && !hintedSessions.has(session.id)) {
-            hintedSessions.add(session.id);
-            const fs = ctx.get('fs');
-            const dshHome = process.env.DSH_HOME?.trim() || `${process.env.HOME || process.env.USERPROFILE || ''}/.dsh`;
-            const probe = await probeInstructionFiles(fs, session.header?.cwd, dshHome, signal);
-            if (probe !== null) {
-              const sections = [];
-              if (probe.projectFiles.length > 0) {
-                sections.push(`Workspace instruction files exist: ${probe.projectFiles.join(', ')} (project root: ${probe.root}).`);
-              }
-              if (probe.userGlobalFiles.length > 0) {
-                sections.push(`A user-global instruction file exists: ${INSTRUCTION_USER_CANDIDATE}.`);
-              }
-              const text = [
-                ...sections,
-                'Do NOT assume their content. When a task touches this workspace, read the relevant instruction files first and follow them.',
-              ].join(' ');
-              out = {
-                ...out,
-                messages: [...out.messages, {
-                  id: `instruction-hint-${session.id}`,
-                  role: 'user',
-                  content: [{ type: 'text', text }],
-                  source: { kind: 'instruction-hint', form: 'hint' },
-                }],
-              };
-            }
-          }
-        }
-        return out;
-      } catch (error) {
-        // 过滤失败绝不吞掉用户的上下文：原样放行。
-        warnBootstrapOnce(`bootstrap context filter failed, keeping injected context: ${String((error && error.message) || 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 && error.message) || 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 && error.message || 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 && error.message || 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 && error.message || error}`); } catch {}
-  }
-}