@chaoset/adaptive-perf 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-plugins contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# @chaoset/adaptive-perf — DSH 极简性能自适应插件
+
+让 **标准模式（standard）** 与 **PTC 模式（code）** 达到 **极简模式（minimal）**
+级别的高性能，同时保留完整能力——不是静态裁剪，而是**动态自适应**：
+
+- **运行时上下文抑制**：对目标 preset 的会话调用 `suppressRuntimeContext()`
+  （与极简模式的 `includeRuntimeContext: false` 同一机制），每次模型请求省掉
+  "Current runtime context" 快照文本，**零功能损失**。
+- **工具目录自适应精简**：会话启动时按"工具族"默认隐藏高开销低频工具
+  （子代理 / 工作流 / ralph / goal 等编排类），只保留核心编码工具
+  （bash / 文件读写编辑 / 检索 / jobs / todo / 提问 / 网页搜索 / 技能 / 计划）。
+  标准模式的工具目录因此逼近极简；PTC 模式系统提示里的 **SDK 参考段同步缩小**。
+- **需求信号自动放行**（会话内单调升级，只升不降，限制请求缓存失效次数）：
+  - 关键词信号：用户消息命中工具族触发词（如"子代理"、"工作流"）→ 放行该族；
+  - 失败信号：PTC 程序调用被隐藏工具报 `UNKNOWN_TOOL` → 放行该族，下次即可调用。
+
+所有开关与工具族可在设置页配置、随时放行；配置保存后**热生效**（无需重启）。
+
+## 为什么极简模式最快（源码对照结论）
+
+| 维度 | 极简模式 | 标准 / PTC 模式 | 本插件做法 |
+|---|---|---|---|
+| 运行时上下文快照 | 关闭（`includeRuntimeContext: false`） | 每次请求注入文件策略/审批策略等快照 | 同一机制：`suppressRuntimeContext()` |
+| 模型可见工具目录 | 2 个（bash、str_replace_editor） | ~22 个工具 schema 全部进请求 | 默认隐藏 4 个编排类工具族（~11 个工具），按需放行 |
+| PTC SDK 参考段 | 无 | 全部工具的类型+描述渲染进提示 | 随目录缩小（同一 `visible` 视图驱动） |
+
+## 安装（npm 生态方式）
+
+本包是 DSH bundle：自带 `cordis.patch.yml`，使用 `dsh plugin` 安装后会
+自动加入 profile 的 `dsh.profile.bundles`，无需手改 `cordis.patch.yml`。
+
+> 给 AI agent：直接执行下面的 `dsh plugin ...` 命令即可，不要手动编辑 `cordis.patch.yml`。
+
+```bash
+# 安装到默认 web profile
+dsh plugin --profile web add @chaoset/adaptive-perf
+
+# 指定其他 profile
+dsh plugin --profile tui add @chaoset/adaptive-perf
+
+# 卸载
+dsh plugin --profile web remove @chaoset/adaptive-perf
+```
+
+也可以从其他来源安装：
+
+- **GitHub**：如果该包有独立 Git 仓库或 Release tarball，可用
+  `dsh plugin --profile web add github:owner/repo` 或
+  `dsh plugin --profile web add https://github.com/owner/repo/releases/download/v1.0.0/adaptive-perf.tgz`
+- **镜像站**：`dsh plugin --profile web add @chaoset/adaptive-perf --registry=https://registry.npmmirror.com`
+
+更完整的说明见仓库根目录 `README.md` 的「安装来源」。
+
+安装后**重启 harness** 生效（或等待 DSH 对配置层变更的响应）。
+
+## 配置
+
+生效顺序（后者覆盖前者）：
+
+1. 插件内置默认值
+2. bundle patch 中 `cordis.patch.yml` 的 config
+3. 用户 profile/home 的 `cordis.patch.yml` 覆盖
+4. **DSH 设置页 → 插件配置 → 极简性能自适应**（保存到
+   `$DSH_HOME/plugins/adaptive-perf/config.json`，立即热生效）
+
+| 字段 | 默认值 | 说明 |
+|---|---|---|
+| `enabled` | `true` | 总开关 |
+| `presets` | `["standard", "code"]` | 应用自适应的 preset id |
+| `suppressRuntimeContext` | `true` | 抑制运行时上下文快照（零功能损失） |
+| `leanByDefault` | `true` | 会话启动即隐藏编排类工具族 |
+| `escalateOnKeyword` | `true` | 用户消息命中触发词 → 放行该族 |
+| `escalateOnUnknownTool` | `true` | 工具调用失败（UNKNOWN_TOOL）→ 放行该族 |
+| `coreTools` | 核心编码工具 | 展示用：不进入任何限制族 |
+| `families` | 见下 | 工具族：`{ 族名: { enabled, tools, keywords } }` |
+
+默认工具族（可整族禁用、改名、增删触发词）：
+
+```json
+{
+  "delegation": { "tools": ["subagent", "subagent_fork", "send_message", "list_agents", "interrupt_agent"], "keywords": ["子代理", "子agent", "委托", "分派", "subagent", "delegate"] },
+  "workflow":   { "tools": ["workflow"], "keywords": ["工作流", "workflow", "编排"] },
+  "ralph":      { "tools": ["ralph"], "keywords": ["ralph"] },
+  "goal":       { "tools": ["create_goal", "get_goal", "update_goal"], "keywords": ["长期目标", "跨轮次", "goal"] }
+}
+```
+
+> 工具名只在目标 preset 目录中**实际存在**时才被隐藏（运行时取交集），preset
+> 升级改名/删除工具不会导致插件报错；`tools.restrict()` 的限制按 agent 作用域
+> 生效，子代理同样遵循自适应策略（其自身注册的委托机制工具不受影响）。
+
+## 实现要点
+
+- 监听 host 根作用域的 `agent/created` / `agent/disposed` / `agent/inbox/inserted`
+  / `tools/result`（与 `dsh-agent-presets` 自身同款事件用法），按
+  `agentPresets.composedPreset(agent.ctx)` 识别目标 preset
+- 限制通过 `agent.ctx.tools.restrict({ deny })` 逐族注册：多族限制自动取交集，
+  升级 = 释放该族 disposer（单会话单调、一次性目录变化，缓存失效有界）
+- 会话启动/插件重载时用 `tools.schemas(agent)` 记录可见目录，限制与之取交集
+- 全部副作用（抑制器、限制、监听）随 agent 销毁或插件卸载自动释放
+- **fail-safe**：插件任何内部错误只记日志，不拖垮 harness

package/client/client.cjs

@@ -0,0 +1,318 @@
+window.__ModuleLoader__.load({
+  id: "@chaoset/adaptive-perf",
+  factory: (require) => {
+    var module = { exports: {} };
+    var exports = module.exports;
+    let react = require("react");
+
+    // ── 样式（注入 style 标签，模仿官方卡片外观）──────────────────────────
+    var css = ".ap_card{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);border-radius:10px;min-width:0;overflow:hidden}.ap_card[data-open=true]{border-color:var(--dsw-alias-border-l1);box-shadow:var(--dsw-shadow-lv1)}.ap_header{appearance:none;width:100%;font:inherit;color:inherit;text-align:left;cursor:pointer;background:0 0;border:0;border-radius:10px;align-items:center;gap:12px;padding:12px 14px;display:flex}.ap_header:hover,.ap_card[data-open=true]>.ap_header{background:var(--dsw-alias-interactive-bg-hover)}.ap_title{flex:1;min-width:0;font-size:14px;font-weight:600;line-height:20px}.ap_badge{white-space:nowrap;background:color-mix(in srgb,var(--dsw-alias-state-success-primary) 10%,transparent);color:var(--dsw-alias-state-success-primary);border-radius:999px;padding:1px 8px;font-size:11px;font-weight:500;line-height:16px}.ap_body{border-top:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-module-platform);padding:10px 14px 12px}.ap_field{flex-direction:column;gap:4px;padding:8px 0;display:flex}.ap_label{font-size:12px;font-weight:500;line-height:18px}.ap_input{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);height:32px;font:inherit;color:var(--dsw-alias-label-primary);border-radius:6px;padding:0 10px;font-size:13px;line-height:20px}.ap_textarea{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-3);font:inherit;color:var(--dsw-alias-label-primary);border-radius:6px;padding:6px 10px;font-size:12px;line-height:18px;resize:vertical;min-height:120px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace}.ap_hint{color:var(--dsw-alias-label-tertiary);margin:0;font-size:11px;line-height:16px}.ap_footer{border-top:1px solid var(--dsw-alias-border-l2);justify-content:flex-end;align-items:center;gap:8px;padding:8px 0 2px;display:flex}.ap_save{font:inherit;cursor:pointer;border:1px solid transparent;border-radius:6px;padding:4px 14px;font-size:12px;line-height:18px;background:var(--dsw-alias-label-primary);color:var(--dsw-alias-bg-layer-3)}.ap_discard{font:inherit;cursor:pointer;border:1px solid var(--dsw-alias-border-l2);border-radius:6px;padding:4px 14px;font-size:12px;line-height:18px;background:0 0;color:inherit}.ap_status{font-size:11px;line-height:16px;color:var(--dsw-alias-label-tertiary);flex:1}.ap_status.ap_error{color:var(--dsw-alias-state-danger-primary)}";
+    var tagId = "@chaoset/adaptive-perf/client.css";
+    if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=\"" + tagId + "\"]") === null) {
+      var tag = document.createElement("style");
+      tag.dataset.plugin = "@chaoset/adaptive-perf";
+      tag.dataset.pluginCss = tagId;
+      tag.textContent = css;
+      document.head.appendChild(tag);
+    }
+
+    // ── 字典 ─────────────────────────────────────────────────────────────
+    const NS = "settings.plugins.adaptivePerf";
+    const zh = {
+      title: "极简性能自适应（adaptive-perf）",
+      hint: "让标准模式 / PTC 模式达到极简模式级别的高性能：抑制运行时上下文快照，启动即精简工具目录，按需求信号自动放行工具族。",
+      unsaved: "有未保存的修改",
+      discard: "放弃修改",
+      saving: "保存中…",
+      save: "保存",
+      saveFailed: "保存失败",
+      saved: "已保存，热生效（新会话立即生效）",
+      loadFailed: "读取配置失败",
+      invalidFamilies: "families 必须是合法 JSON 对象",
+      enabled: "启用插件",
+      presets: "目标 preset",
+      fieldPresets: "逗号分隔的 preset id（如 standard, code）",
+      suppressRuntimeContext: "抑制运行时上下文快照",
+      fieldSuppressRuntimeContext: "等同极简模式的 includeRuntimeContext: false，每次请求省掉快照文本（零功能损失）",
+      leanByDefault: "启动即精简工具目录",
+      fieldLeanByDefault: "默认隐藏编排类工具族（子代理/工作流/ralph/goal），核心编码工具保留",
+      escalateOnKeyword: "关键词自动放行",
+      fieldEscalateOnKeyword: "用户消息命中工具族触发词（如“子代理”）时，该会话放行对应工具族",
+      escalateOnUnknownTool: "失败自动放行",
+      fieldEscalateOnUnknownTool: "PTC 程序调用被隐藏工具报 UNKNOWN_TOOL 时自动放行对应族",
+      families: "工具族（高级）",
+      fieldFamilies: "JSON：{ 族名: { enabled, tools: [工具名], keywords: [触发词] } }。保存后热生效。",
+      coreTools: "核心工具（永不隐藏）",
+      fieldCoreTools: "展示用：这些工具不进入任何限制族。未列入任何族的工具也默认保留。"
+    };
+    const en = {
+      title: "Adaptive performance (adaptive-perf)",
+      hint: "Bring standard / PTC presets to minimal-mode-level performance: suppress the runtime-context snapshot, start with a lean tool catalog, and re-enable tool families on demand.",
+      unsaved: "Unsaved changes",
+      discard: "Discard",
+      saving: "Saving…",
+      save: "Save",
+      saveFailed: "Save failed",
+      saved: "Saved; hot-applied (new sessions take effect immediately)",
+      loadFailed: "Failed to load config",
+      invalidFamilies: "families must be valid JSON object",
+      enabled: "Enable plugin",
+      presets: "Target presets",
+      fieldPresets: "Comma-separated preset ids (e.g. standard, code)",
+      suppressRuntimeContext: "Suppress runtime-context snapshot",
+      fieldSuppressRuntimeContext: "Same as minimal's includeRuntimeContext: false; drops the snapshot text from every request (zero feature loss)",
+      leanByDefault: "Lean tool catalog at session start",
+      fieldLeanByDefault: "Hide orchestration families (subagent/workflow/ralph/goal) by default; core coding tools stay",
+      escalateOnKeyword: "Keyword escalation",
+      fieldEscalateOnKeyword: "A user message matching a family's trigger words re-enables that family for the session",
+      escalateOnUnknownTool: "Failure escalation",
+      fieldEscalateOnUnknownTool: "A PTC program calling a hidden tool (UNKNOWN_TOOL) re-enables that family",
+      families: "Tool families (advanced)",
+      fieldFamilies: "JSON: { familyId: { enabled, tools: [names], keywords: [triggers] } }. Hot-applied on save.",
+      coreTools: "Core tools (never hidden)",
+      fieldCoreTools: "Informational: these never enter any restriction family. Tools not listed in any family stay visible too."
+    };
+
+    // ── 表单字段 ─────────────────────────────────────────────────────────
+    function Field(props) {
+      return react.createElement(
+        "label",
+        { className: "ap_field" },
+        react.createElement("span", { className: "ap_label" }, props.label),
+        props.children,
+        props.hint !== void 0 ? react.createElement("p", { className: "ap_hint" }, props.hint) : null
+      );
+    }
+    function TextField(props) {
+      return react.createElement(Field, { label: props.label, hint: props.hint },
+        react.createElement("input", {
+          className: "ap_input",
+          value: props.value,
+          onChange: (e) => props.onChange(e.target.value),
+          disabled: props.disabled === true
+        })
+      );
+    }
+    function BoolField(props) {
+      return react.createElement(Field, { label: props.label, hint: props.hint },
+        react.createElement("input", {
+          type: "checkbox",
+          checked: props.value === true,
+          onChange: (e) => props.onChange(e.target.checked),
+          disabled: props.disabled === true
+        })
+      );
+    }
+    function familiesToText(families) {
+      return JSON.stringify(families, null, 2);
+    }
+    function textToFamilies(text) {
+      const parsed = JSON.parse(text);
+      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new TypeError("families must be a JSON object");
+      }
+      for (const [id, fam] of Object.entries(parsed)) {
+        if (fam === null || typeof fam !== "object" || Array.isArray(fam)) {
+          throw new TypeError("family \"" + id + "\" must be an object");
+        }
+        if (fam.enabled !== void 0 && typeof fam.enabled !== "boolean") {
+          throw new TypeError("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("family \"" + id + "\"." + key + " must be an array of strings");
+          }
+        }
+      }
+      return parsed;
+    }
+
+    // ── 配置卡片 ─────────────────────────────────────────────────────────
+    function AdaptivePerfCard(props) {
+      const t = props.t;
+      const [open, setOpen] = react.useState(false);
+      const [cfg, setCfg] = react.useState(null);
+      const [draft, setDraft] = react.useState(null);
+      const [familiesText, setFamiliesText] = react.useState("");
+      const [saving, setSaving] = react.useState(false);
+      const [status, setStatus] = react.useState(null);
+
+      react.useEffect(() => {
+        let cancelled = false;
+        props.getConfig().then((value) => {
+          if (cancelled) return;
+          setCfg(value);
+          setDraft(value);
+          setFamiliesText(familiesToText(value.families));
+        }).catch((error) => {
+          if (!cancelled) setStatus({ kind: "error", text: t("loadFailed") + ": " + (error && error.message || error) });
+        });
+        return () => { cancelled = true; };
+      }, []);
+
+      let familiesInvalid = false;
+      let familiesError = null;
+      if (draft !== null) {
+        try {
+          textToFamilies(familiesText);
+        } catch (error) {
+          familiesInvalid = true;
+          familiesError = error && error.message || String(error);
+        }
+      }
+      const dirty = draft !== null && (JSON.stringify(draft) !== JSON.stringify(cfg) || familiesInvalid === false && familiesToText(draft.families) !== familiesText);
+      const invalid = draft !== null && familiesInvalid;
+      const discard = () => {
+        setDraft(cfg);
+        setFamiliesText(cfg === null ? "" : familiesToText(cfg.families));
+        setStatus(null);
+      };
+      const save = () => {
+        if (draft === null || familiesInvalid) return;
+        let next = draft;
+        try {
+          next = { ...draft, families: textToFamilies(familiesText) };
+        } catch (error) {
+          setStatus({ kind: "error", text: t("invalidFamilies") + ": " + (error && error.message || error) });
+          return;
+        }
+        setSaving(true);
+        setStatus(null);
+        props.setConfig(next).then(() => {
+          setCfg(next);
+          setDraft(next);
+          setFamiliesText(familiesToText(next.families));
+          setStatus({ kind: "ok", text: t("saved") });
+        }).catch((error) => {
+          setStatus({ kind: "error", text: t("saveFailed") + ": " + (error && error.message || error) });
+        }).finally(() => setSaving(false));
+      };
+
+      return react.createElement(
+        "li",
+        { className: "ap_card", "data-open": open },
+        react.createElement(
+          "button",
+          {
+            className: "ap_header",
+            type: "button",
+            onClick: () => setOpen(!open),
+            "aria-expanded": open
+          },
+          react.createElement("span", { className: "ap_title" }, t("title")),
+          dirty ? react.createElement("span", { className: "ap_badge" }, t("unsaved")) : null,
+          react.createElement("span", null, open ? "▲" : "▼")
+        ),
+        open ? react.createElement(
+          "div",
+          { className: "ap_body" },
+          react.createElement("p", { className: "ap_hint" }, t("hint")),
+          react.createElement(BoolField, {
+            label: t("enabled"),
+            value: draft === null ? false : draft.enabled,
+            disabled: draft === null,
+            onChange: (v) => setDraft({ ...draft, enabled: v })
+          }),
+          react.createElement(TextField, {
+            label: t("presets"),
+            hint: t("fieldPresets"),
+            value: draft === null ? "" : (draft.presets || []).join(", "),
+            disabled: draft === null,
+            onChange: (v) => setDraft({ ...draft, presets: v.split(/[,，\s]+/).filter((x) => x.length > 0) })
+          }),
+          react.createElement(BoolField, {
+            label: t("suppressRuntimeContext"),
+            hint: t("fieldSuppressRuntimeContext"),
+            value: draft === null ? false : draft.suppressRuntimeContext,
+            disabled: draft === null,
+            onChange: (v) => setDraft({ ...draft, suppressRuntimeContext: v })
+          }),
+          react.createElement(BoolField, {
+            label: t("leanByDefault"),
+            hint: t("fieldLeanByDefault"),
+            value: draft === null ? false : draft.leanByDefault,
+            disabled: draft === null,
+            onChange: (v) => setDraft({ ...draft, leanByDefault: v })
+          }),
+          react.createElement(BoolField, {
+            label: t("escalateOnKeyword"),
+            hint: t("fieldEscalateOnKeyword"),
+            value: draft === null ? false : draft.escalateOnKeyword,
+            disabled: draft === null,
+            onChange: (v) => setDraft({ ...draft, escalateOnKeyword: v })
+          }),
+          react.createElement(BoolField, {
+            label: t("escalateOnUnknownTool"),
+            hint: t("fieldEscalateOnUnknownTool"),
+            value: draft === null ? false : draft.escalateOnUnknownTool,
+            disabled: draft === null,
+            onChange: (v) => setDraft({ ...draft, escalateOnUnknownTool: v })
+          }),
+          react.createElement(Field, {
+            label: t("families"),
+            hint: familiesInvalid ? t("invalidFamilies") + (familiesError !== null ? " — " + familiesError : "") : t("fieldFamilies")
+          },
+            react.createElement("textarea", {
+              className: "ap_textarea",
+              value: familiesText,
+              disabled: draft === null,
+              spellCheck: false,
+              onChange: (e) => setFamiliesText(e.target.value)
+            })
+          ),
+          react.createElement(Field, {
+            label: t("coreTools"),
+            hint: t("fieldCoreTools")
+          },
+            react.createElement("p", { className: "ap_hint" }, draft === null ? "" : (draft.coreTools || []).join(", "))
+          ),
+          react.createElement(
+            "div",
+            { className: "ap_footer" },
+            react.createElement(
+              "span",
+              { className: "ap_status" + (status !== null && status.kind === "error" ? " ap_error" : ""), role: "status" },
+              status !== null ? status.text : ""
+            ),
+            react.createElement(
+              "button",
+              { className: "ap_discard", type: "button", disabled: saving || draft === null || !dirty, onClick: discard },
+              t("discard")
+            ),
+            react.createElement(
+              "button",
+              { className: "ap_save", type: "button", disabled: saving || draft === null || invalid || !dirty, onClick: save },
+              saving ? t("saving") : t("save")
+            )
+          )
+        ) : null
+      );
+    }
+
+    // ── 插件 apply ───────────────────────────────────────────────────────
+    const inject = ["slots", "locale", "remote", "remote.adaptivePerfConfig"];
+    function apply(ctx) {
+      const t = ctx.locale.bind(NS);
+      ctx.effect(() => ctx.locale.register(NS, { zh, en }), "adaptive-perf: dictionaries");
+      const getConfig = () => ctx.remote.adaptivePerfConfig.get().then((result) => {
+        if (!result.ok) throw new Error("adaptivePerfConfig.get failed: " + result.error.code + ": " + result.error.message);
+        return result.value.config;
+      });
+      const setConfig = (partial) => ctx.remote.adaptivePerfConfig.set(partial).then((result) => {
+        if (!result.ok) throw new Error("adaptivePerfConfig.set failed: " + result.error.code + ": " + result.error.message);
+        return result.value;
+      });
+      ctx.slots.inject("settings.plugin.item", () => ctx.slots.register({
+        name: "settings.plugin.item",
+        id: "adaptive-perf",
+        order: 40,
+        locale: NS,
+        inject: () => ({ getConfig, setConfig })
+      }, AdaptivePerfCard));
+    }
+
+    exports.apply = apply;
+    exports.inject = inject;
+    return module.exports;
+  }
+});

package/cordis.patch.yml

@@ -0,0 +1,17 @@
+# @chaoset/adaptive-perf bundle patch
+#
+# Installed automatically by:
+#   dsh plugin --profile <name> add @chaoset/adaptive-perf
+#
+# This patch inserts the host plugin row with the default adaptive behavior.
+
+- insert:
+    - id: adaptive-perf
+      name: '@chaoset/adaptive-perf'
+      config:
+        enabled: true
+        presets: [standard, code]
+        suppressRuntimeContext: true
+        leanByDefault: true
+        escalateOnKeyword: true
+        escalateOnUnknownTool: true

package/lib/config-store.mjs

@@ -0,0 +1,97 @@
+/**
+ * config-store — 插件配置持久化
+ *
+ * 配置文件位于 $DSH_HOME/plugins/<name>/config.json（默认 ~/.dsh，与
+ * file:// 部署模式共用）。生效顺序（后者覆盖前者）：
+ *   1. 插件内置默认值（DEFAULT_CONFIG）
+ *   2. cordis.patch.yml 传入的 config（安装时生成的默认块）
+ *   3. config.json（设置页 UI 保存，权威）
+ *
+ * 保存后通过 onUpdate 回调立即热更新运行中的配置（包装闭包读共享 state）。
+ * 写入采用随机临时文件 + fsync + rename，权限 0600；损坏 JSON 只告警并回退。
+ */
+
+import { randomUUID } from "node:crypto";
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { homedir } from "node:os";
+
+/**
+ * 创建配置存储。
+ * @param options - { name, defaults, patchConfig, onUpdate,
+ *   validate?: (partial) => void, warn?: (message) => void }
+ */
+export function createConfigStore(options) {
+  // 与 harness 的 DSH_HOME 约定保持一致：默认 ~/.dsh，可用 $DSH_HOME 覆盖。
+  const dshHome = process.env.DSH_HOME?.trim() ? resolve(process.env.DSH_HOME) : join(homedir(), ".dsh");
+  const file = join(dshHome, "plugins", options.name, "config.json");
+  const warn = options.warn ?? (() => {});
+  let readWarningShown = false;
+
+  function readJson() {
+    try {
+      if (!existsSync(file)) return {};
+      const parsed = JSON.parse(readFileSync(file, "utf8"));
+      if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+        readWarningShown = false;
+        return parsed;
+      }
+      if (!readWarningShown) {
+        readWarningShown = true;
+        warn(`config file ${file} must contain a JSON object; using empty config`);
+      }
+      return {};
+    } catch (error) {
+      if (!readWarningShown) {
+        readWarningShown = true;
+        warn(`failed to read config file ${file}: ${error?.message || error}; using empty config`);
+      }
+      return {};
+    }
+  }
+
+  /** 当前生效配置（默认 + patch + json 合并）。 */
+  function effective() {
+    return { ...options.defaults, ...options.patchConfig, ...readJson() };
+  }
+
+  /** 保存部分配置到 config.json 并触发热更新，返回新的生效配置。 */
+  function set(partial) {
+    if (partial === null || typeof partial !== "object" || Array.isArray(partial)) {
+      throw new TypeError("set expects a plain config object");
+    }
+    options.validate?.(partial);
+    const merged = { ...readJson(), ...partial };
+    mkdirSync(dirname(file), { recursive: true });
+
+    const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
+    let fd;
+    try {
+      fd = openSync(tmp, "w", 0o600);
+      writeFileSync(fd, JSON.stringify(merged, null, 2) + "\n", "utf8");
+      fsyncSync(fd);
+      closeSync(fd);
+      fd = void 0;
+      renameSync(tmp, file);
+      // POSIX 目录项持久化（Windows 上目录句柄不可打开时忽略）。
+      try {
+        const dir = openSync(dirname(file), "r");
+        try { fsyncSync(dir); } finally { closeSync(dir); }
+      } catch {}
+    } catch (error) {
+      if (fd !== void 0) try { closeSync(fd); } catch {}
+      try { unlinkSync(tmp); } catch {}
+      throw error;
+    }
+
+    const next = { ...options.defaults, ...options.patchConfig, ...merged };
+    try {
+      options.onUpdate?.(merged, next);
+    } catch (error) {
+      warn(`onUpdate failed after config save: ${error?.message || error}`);
+    }
+    return next;
+  }
+
+  return { file, effective, set };
+}

package/lib/index.mjs

@@ -0,0 +1,481 @@
+/**
+ * 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 段。
+ *
+ * 本插件在两个维度上做"动态自适应"（而不是静态裁剪）：
+ *   A. 运行时上下文抑制：对目标 preset 的会话调用
+ *      agent.ctx.systemPrompt.suppressRuntimeContext()（与极简模式同一机制），
+ *      每次请求省掉快照文本，零功能损失。
+ *   B. 工具目录自适应精简：会话启动时按"工具族"默认隐藏高开销低频工具
+ *      （子代理 / 工作流 / ralph / goal 等编排类），只保留核心编码工具，
+ *      让标准模式的目录逼近极简、PTC 的 SDK 段同步缩小；随后根据两类信号
+ *      在会话内"单调升级"放行对应工具族（只升不降，限制请求缓存失效次数）：
+ *        - 关键词信号：用户消息命中某工具族的触发词（如"子代理"）→ 放行该族；
+ *        - 失败信号：PTC 的 run_code 程序调用被隐藏工具报 UNKNOWN_TOOL
+ *          （tools/result 失败文本含工具名）→ 放行该族，下次程序即可调用。
+ *
+ * 实现全部使用 dsh 公开服务契约（Inspect 确认）：
+ *   - ctx.agentPresets.composedPreset(agent.ctx)  读取会话所属 preset
+ *   - agent.ctx.systemPrompt.suppressRuntimeContext()  抑制上下文快照
+ *   - agent.ctx.tools.schemas(agent)  读取该 agent 当前可见工具（限制交集）
+ *   - agent.ctx.tools.restrict({ deny })  按 agent 作用域裁剪继承工具
+ *   - agent/created、agent/disposed、agent/inbox/inserted、tools/result 事件
+ * 监听器都注册在 host 根作用域（与 dsh-agent-presets 自身同款用法），事件按
+ * scope 过滤分发，子作用域派发的事件根监听器可收到。
+ *
+ * 配置：cordis.patch.yml 的 config（安装默认）与
+ *       ~/.dsh/plugins/adaptive-perf/config.json（设置页 UI，权威）合并，
+ *       保存后热生效（新会话立即生效；已运行会话按新配置重算限制）。
+ *
+ * 本文件不依赖任何 dsh 内部包（纯 ESM + ctx 服务），可独立安装。
+ */
+
+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));
+}
+
+export const name = 'adaptive-perf';
+
+/**
+ * 默认配置。apply 时与 YAML 传入的 config 合并（cordis 不合并小写 config 导出）。
+ *
+ * families：工具族。每族可配 tools（该族工具名，需存在于目标 preset 的目录，
+ * 插件运行时按实际可见工具取交集，不会因改名/缺失而崩溃）与 keywords（用户消息
+ * 命中任一触发词即放行该族；大小写不敏感，子串匹配）。
+ */
+export const DEFAULT_CONFIG = {
+  /** 总开关：关闭后插件对会话不产生任何影响。 */
+  enabled: true,
+  /** 应用自适应的 agent preset 列表（composedPreset 返回值）。 */
+  presets: ['standard', 'code'],
+  /** 抑制运行时上下文快照（等同极简模式的 includeRuntimeContext: false）。 */
+  suppressRuntimeContext: true,
+  /** 会话启动时默认隐藏编排类工具族（核心编码工具始终保留）。 */
+  leanByDefault: true,
+  /** 用户消息命中工具族触发词时自动放行该族（会话内单调）。 */
+  escalateOnKeyword: true,
+  /** 工具调用失败（UNKNOWN_TOOL 文本含隐藏工具名）时自动放行该族。 */
+  escalateOnUnknownTool: 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'],
+    },
+  },
+};
+
+/** 轻量配置校验/归一化：非法字段回退默认值，避免 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;
+}
+
+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),
+    };
+  }
+  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),
+    coreTools: stringList(merged.coreTools, defaults.coreTools),
+    families,
+  };
+}
+
+/** 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'];
+  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`);
+        }
+      }
+    }
+  }
+}
+
+// ── 纯函数（导出便于回归测试）────────────────────────────────────────────
+
+/** 提取一条用户消息的顶层文本（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');
+}
+
+// ── host 插件 ────────────────────────────────────────────────────────────
+
+export function apply(ctx, config) {
+  // 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);
+
+    /** 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;
+      }
+    }
+
+    /** 应用/更新工具族限制（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})`);
+    }
+
+    /** 完整接管一个 agent（幂等）。 */
+    function handleAgent(agent) {
+      if (agents.has(agent.id)) return;
+      if (!isTarget(agent)) return;
+      const a = {
+        agent,
+        suppressDisposer: null,
+        familyDisposers: new Map(),
+        escalated: new Set(),
+        visibleNames: new Set(),
+      };
+      // 记录当前可见目录（限制前）；仅记录真实存在的工具，后续 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}`);
+      }
+      agents.set(agent.id, a);
+      applySuppression(a);
+      applyFamilies(a);
+      info(`agent ${agent.id}: adaptive-perf active (preset ${String(agentPresets.composedPreset(agent.ctx))})`);
+    }
+
+    /** 释放一个 agent 的全部副作用。 */
+    function releaseAgent(agentId) {
+      const a = agents.get(agentId);
+      if (a === void 0) return;
+      agents.delete(agentId);
+      if (a.suppressDisposer !== null) {
+        try { a.suppressDisposer(); } 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;
+          }
+        }
+      }
+    });
+
+    // 已运行会话补挂（插件热重载/重装时）。
+    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');
+        // 补挂此前创建的会话（例如插件从 disabled 切换为 enabled，或新增了
+        // 目标 preset）：新符合条件的 agent 立即接管。
+        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 a of agents.values()) {
+          applySuppression(a);
+          applyFamilies(a);
+        }
+      },
+    });
+    cfg = normalizeConfig(store.effective());
+
+    // 远程配置服务（设置页 UI 读写；typert 不可用时跳过）
+    if (PluginConfigGateway !== null) {
+      ctx.plugin(PluginConfigGateway, { store, serviceKey: 'adaptivePerfConfig' });
+    }
+
+    // 卸载清理：释放全部会话副作用与监听。
+    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 {}
+  }
+}

package/lib/remote.mjs

@@ -0,0 +1,95 @@
+/**
+ * remote.mjs — 插件配置的远程服务（设置页 UI 通过 ctx.remote.<svc> 调用）
+ *
+ * DSH 的 Remote 装饰器是 ECMAScript 标准装饰器语法（Node 默认未启用），
+ * 这里用"手动构造装饰器上下文"的方式等价调用：Remote(name)(method, context)
+ * 把标记初始化器收集起来，在模块加载时用 Object.create 模拟实例执行
+ * （mark 以实例原型为准，与真实实例化等价）。
+ *
+ * typert-protocol 惰性加载：npm 模式从包内 node_modules 解析；file:// 模式
+ * （~/.dsh/plugins/）从 harness 的 profile 依赖树解析。两者都不可用时
+ * 模块加载失败，由 index.mjs 的动态 import 捕获——核心功能不受影响，
+ * 仅设置页 UI 的配置读写不可用。
+ */
+
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// @deepseek-ai/dsh-typert-protocol 是 ESM 包。Node 20 早期版本尚不支持
+// require(ESM)，因此统一用 import() 加载；fallback 时先用 createRequire
+// 解析出实际文件，再以 file URL 导入。
+async function loadTypert() {
+  try {
+    return await import("@deepseek-ai/dsh-typert-protocol");
+  } catch {}
+  const dshHome = process.env.DSH_HOME?.trim() ? resolve(process.env.DSH_HOME) : join(homedir(), ".dsh");
+  const candidates = [
+    join(dshHome, "profiles", "web", "package.json"),
+    join(dshHome, "profiles", "tui", "package.json"),
+    join(dshHome, "profiles", "headless", "package.json"),
+  ];
+  for (const base of candidates) {
+    try {
+      const resolved = createRequire(base).resolve("@deepseek-ai/dsh-typert-protocol");
+      return await import(pathToFileURL(resolved).href);
+    } catch {}
+  }
+  throw new Error("typert-protocol is unavailable (neither package deps nor harness profiles resolve it)");
+}
+
+const { Remote, TypertRemoteService } = await loadTypert();
+
+let pending = [];
+
+/** 手动标记一个类原型方法为 Remote 端点（等价 @Remote(exportName)）。 */
+function markRemoteMethod(proto, method, exportName) {
+  const initializers = [];
+  const context = {
+    kind: "method",
+    name: method,
+    private: false,
+    static: false,
+    addInitializer(fn) { initializers.push(fn); },
+  };
+  Remote(exportName ?? method)(proto[method], context);
+  pending.push({ initializers });
+}
+
+/** 执行收集到的标记（mark 以 Object.getPrototypeOf(this) 为原型）。 */
+function runPendingMarks(instance) {
+  const batch = pending;
+  pending = [];
+  for (const { initializers } of batch) {
+    for (const init of initializers) init.call(instance);
+  }
+}
+
+/**
+ * 配置远程服务：get() 返回当前生效配置；set(partial) 持久化并热更新。
+ * 通过 ctx.plugin(PluginConfigGateway, { store, serviceKey }) 注册。
+ * @param ctx - 插件上下文。
+ * @param config - { store: createConfigStore 返回的存储, serviceKey: 远程服务名 }。
+ */
+export class PluginConfigGateway extends TypertRemoteService {
+  constructor(ctx, config) {
+    super(ctx, config.serviceKey);
+    runPendingMarks(this);
+    this.store = config.store;
+  }
+  get() {
+    return { config: this.store.effective() };
+  }
+  set(partial) {
+    if (partial === null || typeof partial !== "object" || Array.isArray(partial)) {
+      throw new TypeError("set expects a plain config object");
+    }
+    this.store.set(partial);
+    return { saved: true };
+  }
+}
+markRemoteMethod(PluginConfigGateway.prototype, "get");
+markRemoteMethod(PluginConfigGateway.prototype, "set");
+// 模块加载时立即执行标记（Object.create 模拟实例；构造函数里的 runPendingMarks 幂等保留无害）。
+runPendingMarks(Object.create(PluginConfigGateway.prototype));

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@chaoset/adaptive-perf",
+  "version": "0.1.0",
+  "description": "DSH host plugin: bring standard / PTC presets to minimal-mode-level performance via runtime-context suppression and adaptive tool-catalog trimming with demand-driven escalation",
+  "type": "module",
+  "license": "MIT",
+  "files": [
+    "lib",
+    "client",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "exports": {
+    ".": "./lib/index.mjs",
+    "./client": "./client/client.cjs",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "slots",
+        "locale",
+        "remote",
+        "remote.adaptivePerfConfig"
+      ]
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.6"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node ../../scripts/test.mjs",
+    "prepublishOnly": "npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/winliyou/dsh-plugins.git",
+    "directory": "packages/adaptive-perf"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}