@chaoset/adaptive-perf 0.5.0 → 0.7.0

package/CHANGELOG.md

@@ -0,0 +1,186 @@
+# Changelog
+
+## [0.7.0](https://github.com/winliyou/dsh-plugins) (2026-08-18)
+
+### Features
+
+* **first-round anchoring, resident catalog after promotion (anchored-standard semantics).** Only request #1 is composed under Minimal conditions (real Minimal tool pair + minimal persona + suppressed global guide sections + stripped `skill-catalog`/`agent-instructions` injections + suppressed runtime snapshot); after the first persistent promotion signal (first `tool/call` or `assistant/message`) the session enters the **resident phase**: the bootstrap tool pair stays resident together with the discovery tools (`dev_tool_search`/`skill_search`/`skill_load`), the full catalog is unlocked on demand via `dev_tool_search`, and normal context injection becomes visible again. Performance is raised without reducing functionality — dumping the full catalog at promotion pulls the trajectory back to standard-like (the reference implementation's post-promotion regression), so the full catalog is fetched on demand instead. The tool/skill/web-search/plan/goal/subagent/workflow abilities of each mode remain fully available
+
+* **promotion is now persistent.** `scanPhase`/`observePhase` no longer reset on `compaction/end` (epoch-aware boundary removed); promotion is remembered per session like the reference implementation, so resume/reload and post-compaction rounds keep the resident catalog
+
+* **catalog is zero-trimmed by default.** `leanByDefault` defaults to `false`: orchestration tool families (subagent/workflow/ralph/goal) are never hidden unless explicitly opted in. `suppressInjectedContext` defaults to `true` (injections stay stripped for the whole session; visibility is carried by the resident discovery tools — measured: restoring injections after promotion pulls the trajectory back to standard-like, "Let me…" narration returns). Setting it to `false` restores post-promotion injections as an opt-in
+
+* **creator mode (cordis) is a target preset.** `presets` defaults to `["standard", "code", "cordis"]` in the bundle patch, the settings UI, and DEFAULT_CONFIG — the creator preset gets the same minimal-anchored first round
+
+### ⚠ Breaking (config)
+
+* **removed `skillDiscovery`, `instructionHint`, `bootstrap.compactionTools`; restored `bootstrap.discoveryTools`.** Under resident-catalog semantics the on-demand discovery is done by the resident `dev_tool_search`, so the one-shot instruction hint and the post-compaction work set are no longer needed; `bootstrap.discoveryTools` (default `dev_tool_search`/`skill_search`/`skill_load`) is restored as the resident post-promotion discovery set. The discovery tool factories (`createDevToolSearch`/`createSkillSearch`/`createSkillLoad`/`extractSkillBody`) and `loadUnlockedFromEvents` are back; saved configs ignore the removed fields; the settings UI renders the discovery-tools control again; `leanByDefault` keeps its new default (false) while `suppressInjectedContext` defaults to `true`
+
+## [0.6.0](https://github.com/winliyou/dsh-plugins) (2026-08-17)
+
+
+### ⚠ Breaking (behavior)
+
+* **function-first defaults — every optimization is now opt-in.** The previous defaults broke standard/PTC functionality: tool families removed from the catalog (PTC program calls hit `UNKNOWN_TOOL` outright), skill-catalog/AGENTS.md injections stripped, official prompt sections shadowed, request #1 restricted to two tools. These mechanisms have no lossless form (their savings come from removing context/tools), so `leanByDefault`, `suppressRuntimeContext`, `suppressInjectedContext`, `minimalPrompt.enabled`, and `bootstrap.enabled` all default to **false**: a fresh install is a zero-intervention no-op and official presets keep full functionality. Enable any mechanism on demand from the settings page; compensation paths (keyword/failure-signal escalation, `skill_search` discovery, instruction-hint) activate together with them. Tests now cover both the zero-intervention defaults and each mechanism under explicit opt-in config
+
+## [0.5.3](https://github.com/winliyou/dsh-plugins) (2026-08-17)
+
+
+### Bug Fixes
+
+* pass the live config snapshot as `base` when registering the settings namespace: without `base`, a schema without defaults (adaptive-perf's `any()`) made `settings.describe()` return `value: undefined`, and the settings page's wire validation (`invalid_type: nonoptional` at `namespaces[n].value`) failed hard, breaking the whole settings UI. With `base` the resolved value is always the full config object
+
+## [0.5.2](https://github.com/winliyou/dsh-plugins) (2026-08-17)
+
+
+### Bug Fixes
+
+* register the config namespace into the host settings service (`ctx.settings.register`) so the settings page's configurable-plugins tab lists it: the tab dispatches cards from `settings.describe()`, and a namespace that was never registered renders nothing even with a correctly keyed card. Registration is visibility-only — the card still reads/writes through the plugin's own config gateway (config.json stays authoritative, hot-reload preserved). Fail-safe when schemastery or the settings service is unavailable; duplicate registrations (HMR) are ignored
+
+## [0.5.1](https://github.com/winliyou/dsh-plugins) (2026-08-17)
+
+
+### Bug Fixes
+
+* settings card registration: pass `key` (the settings namespace, matching the host-side service key) when registering into `settings.plugin.item` — the host `dsh-client-ui-slots` 0.1.0-rc.7 declares it as a keyed slot, and a registration without `key` fails the whole client bundle apply ("Failed to load plugins: keyed slot requires options.key")
+
+## [0.5.0](https://github.com/winliyou/dsh-plugins) (2026-08-16)
+
+
+### Features
+
+* real Minimal tool pair on request #1 (`bootstrap.realPair`)
+
+The bootstrap phase previously only *narrowed* the standard/PTC catalog, so
+request #1 still exposed the sandboxed standard `bash` schema (and no
+`str_replace_editor` at all — the standard preset does not mount it).
+Per dsh-anchored-standard issue #11 the first-request trajectory is decided
+by the *byte-identical* tool schema: the real Minimal pair anchors 5/5 while
+every standard-family schema (including sandboxed bash) falls standard-like
+11/11. The plugin now mounts the official minimal-preset plugins — the
+persistent PTY bash (`@deepseek-ai/dsh-tool-bash-persistent` over
+`dsh-terminal` + `dsh-terminal-bash`, with the exact minimal description)
+and `str_replace_editor` over the bare local fs (`dsh-fs-local`) — into each
+target agent's scoped tool layer, where scoped registrations shadow the
+inherited sandboxed `bash` by name and own-layer registrations are exempt
+from restrictions. The `tool:bash` guidance section is shadowed to empty at
+the same time. The packages are optionalDependencies; when they cannot be
+resolved (or on Windows, where the PTY backend is unavailable) the plugin
+degrades to the previous catalog-only behavior with a warning.
+
+* permanent injected-context suppression (`suppressInjectedContext`)
+
+The skill-catalog reminder and the AGENTS.md digest were previously stripped
+only on request #1 and re-injected after promotion. The reference implementation
+removes both injections entirely: even post-promotion they perturb the
+trajectory and cost thousands of tokens per request. With
+`suppressInjectedContext: true` (default) the strip now applies to every
+request of the session; `skill_search` / `skill_load` (resident after
+promotion, gated by `skillDiscovery`) replace the ~9KB catalog dump, and the
+new one-shot `instruction-hint` (`instructionHint`, default on) tells the
+model once per session that instruction files exist and should be read when
+relevant, instead of embedding their content. User-initiated skill gestures
+(`skill-invocation`) are never filtered.
+
+* resident discovery set now includes skill_search / skill_load
+
+`bootstrap.discoveryTools` defaults to `[dev_tool_search, skill_search,
+skill_load]` so the promoted catalog keeps the on-demand discovery surface of
+the reference's resident set; skills stay reachable while the catalog
+injection stays off.
+
+## [0.4.0](https://github.com/winliyou/dsh-plugins) (2026-08-16)
+
+
+### Features
+
+* minimal-prompt layer (register anchoring, per dsh-anchored-standard)
+
+The reference's full anchoring condition is the *complete minimal system
+prompt*, not just the tool catalog: tool narrowing alone leaves the global
+orientation sections (harness:identity / harness:source / app:web-surface)
+and the standard persona in the prompt, and the model keeps narrating in the
+standard-like register ("Let me…" thinking chains). The new `minimalPrompt`
+layer shadows those sections to empty per target agent (same effect as
+minimal's `complete` persona; plan-mode and the PTC SDK sections are
+untouched) and shadows `deployment:persona` with the exact minimal-mode text
+("You are a helpful software engineer assistant."), so the assembled system
+prompt for standard / PTC sessions drops to the minimal register from request
+#1 onward — including for resumed/already-promoted sessions, which the
+bootstrap phase never touches. All knobs are configurable and hot-applied
+(`minimalPrompt.enabled` / `.persona` / `.suppressSections`).
+
+## [0.3.2](https://github.com/winliyou/dsh-plugins) (2026-08-16)
+
+
+### Bug Fixes
+
+* bootstrap tool narrowing now uses tools.restrict instead of filtering assembly.tools
+
+In PTC/code mode the assembled tool catalog contains only run_code, so
+filtering it down to the Minimal pair always hit the fail-safe and the
+first request kept the full SDK (verified live: the model still saw 15
+tools). tools.restrict drives both the API catalog and the PTC SDK
+reference section (the same mechanism the family trimming uses), so the
+bootstrap phase now temporarily denies everything except
+run_code + the Minimal pair (plus the post-compaction work set) and
+lifts the restriction on the first durable promotion signal. Verified
+live: on request #1 the model reports run_code as the only direct tool
+and the SDK declarations contain only the Minimal pair.
+
+## [0.3.1](https://github.com/winliyou/dsh-plugins) (2026-08-16)
+
+
+### Bug Fixes
+
+* raise engines.node to >=22.19.0 (node 20 is EOL; aligns with the reference preset baseline and the current LTS floor)
+
+## [0.3.0](https://github.com/winliyou/dsh-plugins/compare/adaptive-perf-v0.2.2...adaptive-perf-v0.3.0) (2026-08-16)
+
+
+### Features
+
+* first-request bootstrap anchoring (inspired by dsh-anchored-standard)
+
+Request #1 for target presets now exposes only the real Minimal tool pair
+(bash + str_replace_editor) and strips auto-injected context
+(skill-catalog reminder, AGENTS.md digest), which anchors the first-request
+trajectory on minimal conditions (the community measurements: the Minimal
+pair anchors 5/5 at the adapter-default budget while every standard-family
+schema falls into standard-like behavior 11/11, and a present skill catalog
+breaks the anchor 0/9). The session promotes after its first durable
+tool/call or assistant/message (promoteOn: either, or tool-call /
+assistant-message) — phase derived from durable session events, resume-safe.
+A compaction resets the phase (epoch-aware): after compaction/end the
+session falls back to the bootstrap pair plus a configurable compactionTools
+work set until a new promotion signal. bootstrap.maxTokens optionally caps
+request #1's output budget and is stripped after promotion.
+
+Wiring uses the harness's public waterfalls: system-prompt/assemble (tool
+catalog narrowing), agent/pre-step (context stripping, prepend-registered so
+the strip is the final transform), agent/request (budget cap), and
+session/event (phase feed). Degrades to the full catalog on any filter
+failure so a plugin bug can never brick a session.
+
+## [0.2.2](https://github.com/winliyou/dsh-plugins/compare/adaptive-perf-v0.2.1...adaptive-perf-v0.2.2) (2026-08-16)
+
+
+### Bug Fixes
+
+* register config-gateway endpoints via a typert-loader host artifact (lib/typert.host.js) so the api-gateway claims them regardless of module-instance identity ([dsh-plugins#registry-install](https://github.com/winliyou/dsh-plugins))
+
+When the package is installed from the npm registry, its typert-protocol copy differs from the harness's, so the Remote-decorator SRC markers are invisible to the gateway and settings-page calls fail with "transport failure ... HTTP 404". The typert artifact registers the same get/set endpoints into ctx.typert.local through the official loader mechanism.
+
+## [0.2.1](https://github.com/winliyou/dsh-plugins/compare/adaptive-perf-v0.2.0...adaptive-perf-v0.2.1) (2026-08-16)
+
+
+### Bug Fixes
+
+* mount remote config namespaces in client bundles ([a647484](https://github.com/winliyou/dsh-plugins/commit/a64748489ddf003cb29c0527016ea089748e0c7b))
+
+## [0.2.0](https://github.com/winliyou/dsh-plugins/compare/adaptive-perf-v0.1.2...adaptive-perf-v0.2.0) (2026-08-15)
+
+
+### Features
+
+* convert plugins to DSH bundle installation ([caae797](https://github.com/winliyou/dsh-plugins/commit/caae797acd12c70af52b0868ec352d91a0a7ef12))

package/README.md

@@ -1,7 +1,22 @@
 # @chaoset/adaptive-perf — DSH 极简性能自适应插件
 
-让 **标准模式（standard）** 与 **PTC 模式（code）** 达到 **极简模式（minimal）**
-级别的高性能，同时保留完整能力——不是静态裁剪，而是**动态自适应**：
+> **默认策略（0.7.0，首轮锚定、晋升后 resident 目录）**：只提高性能，不减少功能。
+> 非极简模式会话的**请求 #1** 按极简模式条件组装——真实 Minimal 工具对
+> 锚定首轮轨迹、极简 persona + 屏蔽全局引导段对齐语域、剥离技能目录/指令
+> 摘要注入、抑制运行时快照；首个**持久**晋升信号（首个 `tool/call` 或
+> `assistant/message`）后进入 **resident 阶段**——保留 bootstrap 工具对 +
+> 常驻发现工具（`dev_tool_search` / `skill_search` / `skill_load`），完整
+> 目录经 `dev_tool_search` 按需解锁，常规上下文注入恢复可见（与
+> [dsh-anchored-standard](https://github.com/xiaobright/dsh-anchored-standard/)
+> 语义一致：晋升按会话记忆化，compaction 不重置；晋升时一次性倒出完整目录
+> 会把轨迹拉回 standard-like，故完整目录按需取用）。工具目录默认**零裁剪**
+> （编排类工具族始终可用）；`leanByDefault` 是省 token 的 opt-in 开关，
+> `suppressInjectedContext` 默认开启（注入剥离由发现工具承担可见性），
+> 设置页按需调整。
+
+让 **标准模式（standard）**、**PTC 模式（code）** 与 **创造模式（cordis）**
+达到 **极简模式（minimal）** 级别的高性能，同时保留完整能力——不是静态裁剪，
+而是**动态自适应**：
 
 - **真实 Minimal 工具对（realPair）**：首轮"轨迹"由请求 #1 可见的**工具 schema**
   逐字决定——只有与 Minimal 完全相同的 schema 能锚定（参照
@@ -16,23 +31,20 @@
   - 请求 #1 剥离自动注入上下文（技能目录提醒 `skill-catalog`、AGENTS.md 摘要
     `agent-instructions`，用户主动的技能手势不过滤）；
   - 会话出现首个**持久**晋升信号（首个 `tool/call` 或 `assistant/message`，
-    `promoteOn` 可选 `either`/`tool-call`/`assistant-message`）后进入 **resident
-    目录**：bootstrap 工具对 + 常驻发现工具（`dev_tool_search` +
-    `skill_search` + `skill_load`）+ 已解锁工具，而不是一次性 dump 完整
-    Standard 目录（避免 post-promotion regression）；阶段从持久会话事件推导，
-    **resume / reload 不丢状态**；
-  - `dev_tool_search` 可搜索完整目录并按名解锁工具，解锁结果下一请求生效；
-  - compaction 会把会话打回"第二次首轮"：`compaction/end` 之后回到受控目录
-    （bootstrap 工具对 + `compactionTools` 核心工作集），直到出现新的晋升信号；
+    `promoteOn` 可选 `either`/`tool-call`/`assistant-message`）后进入
+    **resident 阶段**：保留 bootstrap 工具对 + 常驻发现工具（0.7.0 语义：
+    只锚定首轮，不减少后续功能；完整目录经 `dev_tool_search` 按需解锁——
+    晋升时一次性倒出完整目录会把轨迹拉回 standard-like，anchored-standard
+    实测的"晋升后回退"问题），常规注入（技能目录提醒 + AGENTS.md 摘要）
+    恢复可见；阶段从持久会话事件推导，**resume / reload 不丢状态**，晋升
+    信号**持久**（`compaction/end` 不重置，与 dsh-anchored-standard 一致）；
   - `maxTokens > 0` 时可给请求 #1 封顶输出预算（晋升后自动剥离）。
-- **常驻上下文抑制（suppressInjectedContext）**：技能目录提醒与 AGENTS.md 摘要
-  **不再在晋升后恢复**——参考实现实测它们即使在后置阶段也扰动轨迹，且每个请求
-  多耗数千 token。替代品：
-  - `skill_search` / `skill_load`：晋升后常驻的两个小工具，按需发现并注入单个
-    技能的完整说明（替代 ~9KB 的 `<available_skills>` 目录注入）；
-  - `instruction-hint`：晋升后只注入**一次**的短提示——"指令文件存在，需要时
-    自己读"，而不是每请求 dump 全文（探测项目链 AGENTS.md/CLAUDE.md 与
-    `$DSH_HOME/AGENTS.md`，探测失败不注入，绝不抛错）。
+- **常驻上下文抑制（suppressInjectedContext，默认开启）**：整个会话持续
+  剥离技能目录提醒 + AGENTS.md 摘要注入——实测晋升后恢复注入会把轨迹拉回
+  standard-like（"Let me…" 叙述回归），且每请求多耗数千 token。功能可见性
+  由常驻发现工具承担：`dev_tool_search` 搜索完整目录并按名解锁、
+  `skill_search` / `skill_load` 按需搜索/加载技能说明。设为 `false` 时只剥
+  离请求 #1，晋升后恢复常规注入（功能不减少但轨迹回退，opt-in）。
 - **运行时上下文抑制**：对目标 preset 的会话调用 `suppressRuntimeContext()`
   （与极简模式的 `includeRuntimeContext: false` 同一机制），每次模型请求省掉
   "Current runtime context" 快照文本，**零功能损失**。
@@ -48,9 +60,10 @@
   - 挂载真实工具对时按名阴影 `tool:bash` 引导段（与可见工具一致）。
   各处均为 agent 作用域的 prompt 段阴影，仅影响目标会话；**对已恢复/已晋升的
   旧会话同样生效**（不依赖 bootstrap 阶段）。
-- **工具目录自适应精简**：会话启动时按"工具族"默认隐藏高开销低频工具
-  （子代理 / 工作流 / ralph / goal 等编排类），只保留核心编码工具
-  （bash / 文件读写编辑 / 检索 / jobs / todo / 提问 / 网页搜索 / 技能 / 计划）。
+- **工具目录自适应精简（leanByDefault，0.7.0 起为 opt-in）**：默认 `false` =
+  工具目录零裁剪，编排类工具族（子代理 / 工作流 / ralph / goal）始终可用。
+  设为 `true` 时会话启动按"工具族"隐藏高开销低频工具，只保留核心编码工具
+  （bash / 文件读写编辑 / 检索 / jobs / todo / 提问 / 网页搜索 / 技能 / 计划），
   标准模式的工具目录因此逼近极简；PTC 模式系统提示里的 **SDK 参考段同步缩小**。
 - **需求信号自动放行**（会话内单调升级，只升不降，限制请求缓存失效次数）：
   - 关键词信号：用户消息命中工具族触发词（如"子代理"、"工作流"）→ 放行该族；
@@ -62,12 +75,12 @@
 
 | 维度 | 极简模式 | 标准 / PTC 模式 | 本插件做法 |
 |---|---|---|---|
-| 首轮轨迹（决定后续行为风格） | Minimal 真实工具对锚定（5/5） | 任何 standard 系 schema（含 sandboxed bash）落入 standard-like（11/11） | realPair 挂载官方同款插件：请求 #1 的 schema 与 Minimal 逐字相同，首个持久信号后进 resident 目录 |
+| 首轮轨迹（决定后续行为风格） | Minimal 真实工具对锚定（5/5） | 任何 standard 系 schema（含 sandboxed bash）落入 standard-like（11/11） | realPair 挂载官方同款插件：请求 #1 的 schema 与 Minimal 逐字相同 |
 | 首轮注入提醒 | 无 skill 目录/AGENTS.md 注入 | 自动注入（在场时锚定 0/9） | 请求 #1 剥离 `skill-catalog` + `agent-instructions` |
-| 后置阶段注入 | 永不注入 | 晋升后每请求恢复 ~9KB 目录 + AGENTS.md 全文 | `suppressInjectedContext`：整个会话抑制；替代品为 `skill_search`/`skill_load` + 一次性 `instruction-hint` |
+| 后置阶段注入 | 永不注入 | 晋升后每请求恢复 ~9KB 目录 + AGENTS.md 全文 | 默认全程剥离（发现工具承担可见性）；`suppressInjectedContext=false` opt-in 恢复 |
 | 系统提示语域（persona + 全局引导段） | 一句话 persona，无任何引导段 | identity/source/web-surface 引导段 + 标准 persona（"Let me…" 叙述来源） | minimalPrompt 层按名阴影屏蔽 3 个全局段 + 替换极简 persona（对旧会话同样生效） |
 | 运行时上下文快照 | 关闭（`includeRuntimeContext: false`） | 每次请求注入文件策略/审批策略等快照 | 同一机制：`suppressRuntimeContext()` |
-| 模型可见工具目录 | 2 个（bash、str_replace_editor） | ~22 个工具 schema 全部进请求 | 首轮 2 个；晋升后 resident 目录（工具对 + 发现工具 + 已解锁），编排族默认隐藏按需放行 |
+| 模型可见工具目录 | 2 个（bash、str_replace_editor） | ~22 个工具 schema 全部进请求 | 首轮 2 个；晋升后 resident（2 + 3 个发现工具，完整目录按需解锁）；opt-in lean 时隐藏编排族按需放行 |
 | PTC SDK 参考段 | 无 | 全部工具的类型+描述渲染进提示 | 随目录缩小（同一 `visible` 视图驱动） |
 
 ## 安装（npm 生态方式）
@@ -112,12 +125,10 @@ dsh plugin --profile web remove @chaoset/adaptive-perf
 | 字段 | 默认值 | 说明 |
 |---|---|---|
 | `enabled` | `true` | 总开关 |
-| `presets` | `["standard", "code"]` | 应用自适应的 preset id |
+| `presets` | `["standard", "code", "cordis"]` | 应用自适应的 preset id |
 | `suppressRuntimeContext` | `true` | 抑制运行时上下文快照（零功能损失） |
-| `suppressInjectedContext` | `true` | 整个会话剥离技能目录/AGENTS.md 注入（0.5.0；`false` = 只在请求 #1 剥离） |
-| `skillDiscovery` | `true` | 晋升后常驻 `skill_search` / `skill_load`（0.5.0） |
-| `instructionHint` | `true` | 晋升后一次性注入指令文件提示（0.5.0） |
-| `leanByDefault` | `true` | 会话启动即隐藏编排类工具族 |
+| `suppressInjectedContext` | `true` | 常驻上下文抑制（默认开启）：整个会话剥离技能目录/AGENTS.md 注入（发现工具承担可见性）；`false` = 只在请求 #1 剥离，晋升后恢复 |
+| `leanByDefault` | `false` | 工具目录精简（opt-in）：`true` = 会话启动即隐藏编排类工具族；`false`（默认）= 零裁剪 |
 | `escalateOnKeyword` | `true` | 用户消息命中触发词 → 放行该族 |
 | `escalateOnUnknownTool` | `true` | 工具调用失败（UNKNOWN_TOOL）→ 放行该族 |
 | `coreTools` | 核心编码工具 | 展示用：不进入任何限制族 |
@@ -134,7 +145,6 @@ dsh plugin --profile web remove @chaoset/adaptive-perf
   "tools": ["bash", "str_replace_editor"],
   "promoteOn": "either",
   "suppressedContextSources": ["skill-catalog", "agent-instructions"],
-  "compactionTools": ["read", "write", "edit", "glob", "grep", "todo_write", "ask_user_question"],
   "discoveryTools": ["dev_tool_search", "skill_search", "skill_load"],
   "maxTokens": 0
 }
@@ -147,12 +157,20 @@ dsh plugin --profile web remove @chaoset/adaptive-perf
   Windows（无 PTY 后端）时自动降级为"仅收窄目录"并告警。
 - `tools`：请求 #1 可见的工具（真实 Minimal 对）。
 - `promoteOn`：`either`（默认）/ `tool-call` / `assistant-message`。
-- `suppressedContextSources`：剥离的自动注入 source.kind；`[]` 关闭剥离。
-- `compactionTools`：compaction/end 之后、再次晋升前可用的核心工作集。
-- `discoveryTools`：晋升后 resident 目录里的按需发现工具
-  （`dev_tool_search` 解锁工具；`skill_search`/`skill_load` 按需加载技能）。
+- `suppressedContextSources`：首轮剥离的自动注入 source.kind；`[]` 关闭剥离。
+- `discoveryTools`：晋升后 resident 目录的常驻发现工具——`dev_tool_search`
+  （搜索完整目录并按名解锁，解锁结果下一请求生效且会话内保持）、
+  `skill_search` / `skill_load`（无门控，按需搜索/加载技能说明，替代常驻
+  ~9KB 技能目录）。
 - `maxTokens`：请求 #1 输出预算封顶（0 = 不封顶，opt-in）。
 
+> 0.7.0 破坏性变更：移除 `skillDiscovery` / `instructionHint` /
+> `bootstrap.compactionTools` 三个字段（resident 语义下不再需要：
+> `dev_tool_search` 常驻提供按需发现，无压缩回退、无指令提示补偿）；
+> `bootstrap.discoveryTools` **恢复**为 resident 目录的常驻发现工具
+> （默认 `dev_tool_search` / `skill_search` / `skill_load`）。已保存的旧配置
+> 会自动忽略被移除字段。
+
 `minimalPrompt`（极简提示词层，0.4.0 新增）：
 
 ```json

package/client/client.cjs

@@ -42,10 +42,6 @@ window.__ModuleLoader__.load({
       fieldEscalateOnUnknownTool: "PTC 程序调用被隐藏工具报 UNKNOWN_TOOL 时自动放行对应族",
       suppressInjectedContext: "常驻抑制注入上下文",
       fieldSuppressInjectedContext: "整个会话剥离技能目录提醒（skill-catalog）与 AGENTS.md 摘要（agent-instructions），不再在晋升后恢复——替代品是 skill_search/skill_load 按需发现与一次性 instruction-hint（参照 dsh-anchored-standard：注入在场即使后置也扰动轨迹）",
-      skillDiscovery: "技能按需发现",
-      fieldSkillDiscovery: "晋升后常驻 skill_search / skill_load 两个小工具，替代 ~9KB 的 <available_skills> 目录注入",
-      instructionHint: "指令文件一次性提示",
-      fieldInstructionHint: "晋升后注入一次“指令文件存在，需要时自读”的短提示（探测项目链 AGENTS.md/CLAUDE.md 与 $DSH_HOME/AGENTS.md），替代全文摘要",
       families: "工具族（高级）",
       fieldFamilies: "JSON：{ 族名: { enabled, tools: [工具名], keywords: [触发词] } }。保存后热生效。",
       coreTools: "核心工具（永不隐藏）",
@@ -59,11 +55,9 @@ window.__ModuleLoader__.load({
       bootstrapPromoteOn: "晋升触发",
       fieldBootstrapPromoteOn: "either（默认）：首个 tool/call 或 assistant/message 先到者晋升；tool-call / assistant-message 可单独指定",
       bootstrapSuppressed: "剥离的注入上下文",
+      bootstrapDiscovery: "常驻发现工具（晋升后）",
       fieldBootstrapSuppressed: "请求 #1 剥离的自动注入 source.kind（技能目录提醒 skill-catalog、AGENTS.md 摘要 agent-instructions）；逗号分隔，留空=不剥离",
-      bootstrapCompactionTools: "压缩后工作集",
-      fieldBootstrapCompactionTools: "compaction/end 之后、再次晋升前额外可用的工具（核心工作集）。逗号分隔。",
-      bootstrapDiscoveryTools: "晋升后常驻发现工具",
-      fieldBootstrapDiscoveryTools: "晋升后保留在 resident 目录里的按需发现工具（如 dev_tool_search）；逗号分隔。",
+      fieldBootstrapDiscovery: "晋升后常驻目录的发现工具（dev_tool_search 搜索完整目录并按名解锁；skill_search / skill_load 按需加载技能）；逗号分隔",
       bootstrapMaxTokens: "首轮输出预算封顶（token）",
       fieldBootstrapMaxTokens: "请求 #1 的 maxTokens 封顶，晋升后自动剥离；0 = 不封顶（opt-in）",
       minimalPromptEnabled: "极简提示词层（语域锚定）",
@@ -97,10 +91,6 @@ window.__ModuleLoader__.load({
       fieldEscalateOnUnknownTool: "A PTC program calling a hidden tool (UNKNOWN_TOOL) re-enables that family",
       suppressInjectedContext: "Always suppress injected context",
       fieldSuppressInjectedContext: "Strip the skill-catalog reminder and the AGENTS.md digest from every request, not just request #1 — replaced by on-demand skill_search/skill_load and a one-shot instruction hint (per dsh-anchored-standard: the injections perturb the trajectory even after promotion)",
-      skillDiscovery: "On-demand skill discovery",
-      fieldSkillDiscovery: "Keep skill_search / skill_load resident after promotion as the replacement for the ~9KB <available_skills> catalog injection",
-      instructionHint: "One-shot instruction hint",
-      fieldInstructionHint: "After promotion, inject ONCE a short hint that instruction files exist and should be read when relevant (probes the project chain AGENTS.md/CLAUDE.md and $DSH_HOME/AGENTS.md), instead of dumping their content",
       families: "Tool families (advanced)",
       fieldFamilies: "JSON: { familyId: { enabled, tools: [names], keywords: [triggers] } }. Hot-applied on save.",
       coreTools: "Core tools (never hidden)",
@@ -114,11 +104,9 @@ window.__ModuleLoader__.load({
       bootstrapPromoteOn: "Promotion trigger",
       fieldBootstrapPromoteOn: "either (default): first tool/call or assistant/message promotes; tool-call / assistant-message select one",
       bootstrapSuppressed: "Suppressed injected context",
+      bootstrapDiscovery: "Resident discovery tools (post-promotion)",
       fieldBootstrapSuppressed: "Auto-injected source.kinds stripped on request #1 (skill-catalog reminder, agent-instructions digest); comma-separated, empty = strip nothing",
-      bootstrapCompactionTools: "Post-compaction work set",
-      fieldBootstrapCompactionTools: "Extra tools available after compaction/end until a new promotion signal (core work set). Comma-separated.",
-      bootstrapDiscoveryTools: "Resident discovery tools",
-      fieldBootstrapDiscoveryTools: "On-demand discovery tools kept in the resident catalog after promotion (e.g. dev_tool_search). Comma-separated.",
+      fieldBootstrapDiscovery: "Resident discovery tools after promotion (dev_tool_search searches the full catalog and unlocks by name; skill_search / skill_load load skills on demand); comma-separated",
       bootstrapMaxTokens: "First-request output cap (tokens)",
       fieldBootstrapMaxTokens: "maxTokens cap for request #1, stripped after promotion; 0 = no cap (opt-in)",
       minimalPromptEnabled: "Minimal prompt layer (register anchor)",
@@ -265,21 +253,21 @@ window.__ModuleLoader__.load({
           react.createElement("p", { className: "ap_hint" }, t("hint")),
           react.createElement(BoolField, {
             label: t("enabled"),
-            value: draft === null ? false : draft.enabled,
+            value: draft === null ? true : 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(", "),
+            value: draft === null ? "standard, code, cordis" : (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,
+            value: draft === null ? true : draft.suppressRuntimeContext,
             disabled: draft === null,
             onChange: (v) => setDraft({ ...draft, suppressRuntimeContext: v })
           }),
@@ -293,14 +281,14 @@ window.__ModuleLoader__.load({
           react.createElement(BoolField, {
             label: t("escalateOnKeyword"),
             hint: t("fieldEscalateOnKeyword"),
-            value: draft === null ? false : draft.escalateOnKeyword,
+            value: draft === null ? true : 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,
+            value: draft === null ? true : draft.escalateOnUnknownTool,
             disabled: draft === null,
             onChange: (v) => setDraft({ ...draft, escalateOnUnknownTool: v })
           }),
@@ -311,31 +299,17 @@ window.__ModuleLoader__.load({
             disabled: draft === null,
             onChange: (v) => setDraft({ ...draft, suppressInjectedContext: v })
           }),
-          react.createElement(BoolField, {
-            label: t("skillDiscovery"),
-            hint: t("fieldSkillDiscovery"),
-            value: draft === null ? false : draft.skillDiscovery,
-            disabled: draft === null,
-            onChange: (v) => setDraft({ ...draft, skillDiscovery: v })
-          }),
-          react.createElement(BoolField, {
-            label: t("instructionHint"),
-            hint: t("fieldInstructionHint"),
-            value: draft === null ? false : draft.instructionHint,
-            disabled: draft === null,
-            onChange: (v) => setDraft({ ...draft, instructionHint: v })
-          }),
           react.createElement(BoolField, {
             label: t("bootstrapEnabled"),
             hint: t("fieldBootstrapEnabled"),
-            value: draft === null ? false : !!draft.bootstrap && draft.bootstrap.enabled,
+            value: draft === null ? true : !!draft.bootstrap && draft.bootstrap.enabled,
             disabled: draft === null,
             onChange: (v) => setDraft({ ...draft, bootstrap: { ...(draft.bootstrap || {}), enabled: v } })
           }),
           react.createElement(BoolField, {
             label: t("bootstrapRealPair"),
             hint: t("fieldBootstrapRealPair"),
-            value: draft === null ? false : !!draft.bootstrap && draft.bootstrap.realPair,
+            value: draft === null ? true : !!draft.bootstrap && draft.bootstrap.realPair,
             disabled: draft === null || (draft.bootstrap && draft.bootstrap.enabled === false),
             onChange: (v) => setDraft({ ...draft, bootstrap: { ...(draft.bootstrap || {}), realPair: v } })
           }),
@@ -361,15 +335,8 @@ window.__ModuleLoader__.load({
             onChange: (v) => setDraft({ ...draft, bootstrap: { ...(draft.bootstrap || {}), suppressedContextSources: v.split(/[,，\s]+/).filter((x) => x.length > 0) } })
           }),
           react.createElement(TextField, {
-            label: t("bootstrapCompactionTools"),
-            hint: t("fieldBootstrapCompactionTools"),
-            value: draft === null ? "" : ((draft.bootstrap && draft.bootstrap.compactionTools) || []).join(", "),
-            disabled: draft === null || (draft.bootstrap && draft.bootstrap.enabled === false),
-            onChange: (v) => setDraft({ ...draft, bootstrap: { ...(draft.bootstrap || {}), compactionTools: v.split(/[,，\s]+/).filter((x) => x.length > 0) } })
-          }),
-          react.createElement(TextField, {
-            label: t("bootstrapDiscoveryTools"),
-            hint: t("fieldBootstrapDiscoveryTools"),
+            label: t("bootstrapDiscovery"),
+            hint: t("fieldBootstrapDiscovery"),
             value: draft === null ? "" : ((draft.bootstrap && draft.bootstrap.discoveryTools) || []).join(", "),
             disabled: draft === null || (draft.bootstrap && draft.bootstrap.enabled === false),
             onChange: (v) => setDraft({ ...draft, bootstrap: { ...(draft.bootstrap || {}), discoveryTools: v.split(/[,，\s]+/).filter((x) => x.length > 0) } })
@@ -387,14 +354,14 @@ window.__ModuleLoader__.load({
           react.createElement(BoolField, {
             label: t("minimalPromptEnabled"),
             hint: t("fieldMinimalPromptEnabled"),
-            value: draft === null ? false : (draft.minimalPrompt && draft.minimalPrompt.enabled === true),
+            value: draft === null ? true : (draft.minimalPrompt && draft.minimalPrompt.enabled === true),
             disabled: draft === null,
             onChange: (v) => setDraft({ ...draft, minimalPrompt: { ...(draft.minimalPrompt || {}), enabled: v } })
           }),
           react.createElement(BoolField, {
             label: t("minimalPromptSuppressSections"),
             hint: t("fieldMinimalPromptSuppressSections"),
-            value: draft === null ? false : (draft.minimalPrompt && draft.minimalPrompt.suppressSections === true),
+            value: draft === null ? true : (draft.minimalPrompt && draft.minimalPrompt.suppressSections === true),
             disabled: draft === null || (draft.minimalPrompt && draft.minimalPrompt.enabled === false),
             onChange: (v) => setDraft({ ...draft, minimalPrompt: { ...(draft.minimalPrompt || {}), suppressSections: v } })
           }),
@@ -501,6 +468,9 @@ window.__ModuleLoader__.load({
       });
       ctx.slots.inject("settings.plugin.item", () => ctx.slots.register({
         name: "settings.plugin.item",
+        // keyed slot：key 为卡片编辑的设置 namespace（与 host 侧 serviceKey 一致），
+        // 设置页按 key 与宿主服务的 namespace 配对 dispatch。
+        key: "adaptivePerfConfig",
         id: "adaptive-perf",
         order: 40,
         locale: NS,

package/cordis.patch.yml

@@ -10,27 +10,36 @@
       name: '@chaoset/adaptive-perf'
       config:
         enabled: true
-        presets: [standard, code]
+        presets: [standard, code, cordis]
         suppressRuntimeContext: true
-        leanByDefault: true
+        leanByDefault: false
         escalateOnKeyword: true
         escalateOnUnknownTool: true
-        # 常驻上下文抑制（参照 dsh-anchored-standard）：整个会话剥离技能目录
-        # 提醒与 AGENTS.md 摘要注入，替代品是 skill_search/skill_load 按需
-        # 发现与 instruction-hint 一次性提示。
+        # 常驻上下文抑制（0.7.0 默认关闭）：true = 整个会话剥离技能目录
+        # 提醒与 AGENTS.md 摘要注入；false（默认）= 只在首轮剥离，晋升后
+        # 常驻剥离注入（0.7.0 默认开启）：技能目录/AGENTS.md 摘要的可见性
+        # 由 resident 发现工具 dev_tool_search / skill_search / skill_load
+        # 承担——实测晋升后恢复注入会把轨迹拉回 standard-like。
         suppressInjectedContext: true
-        skillDiscovery: true
-        instructionHint: true
-        # 首轮锚定（参照 dsh-anchored-standard issue #11）：请求 #1 只暴露
-        # 真实 Minimal 工具对（realPair 挂载官方 minimal preset 同款插件，
-        # schema 与 Minimal 逐字相同）并剥离自动注入上下文，首个持久信号后
-        # 进入 resident 目录（工具对 + 发现工具 + 已解锁工具）。
+        # 首轮锚定、晋升后 resident 目录（参照 dsh-anchored-standard issue
+        # #11）：请求 #1 只暴露真实 Minimal 工具对（realPair 挂载官方 minimal
+        # preset 同款插件，schema 与 Minimal 逐字相同）并剥离自动注入上下文；
+        # 首个持久信号后保留 bootstrap 工具对 + 常驻发现工具（完整目录经
+        # dev_tool_search 按需解锁，避免晋升时一次性倒出完整目录把轨迹拉回
+        # standard-like），常规注入恢复可见。
         bootstrap:
           enabled: true
           realPair: true
           tools: [bash, str_replace_editor]
           promoteOn: either
           suppressedContextSources: [skill-catalog, agent-instructions]
-          compactionTools: [read, write, edit, glob, grep, todo_write, ask_user_question]
           discoveryTools: [dev_tool_search, skill_search, skill_load]
           maxTokens: 0
+        # 极简提示词层（参照 dsh-anchored-standard 的完整锚定条件）：按名
+        # 阴影屏蔽 harness:identity / harness:source / app:web-surface 三个
+        # 全局引导段，并替换 deployment:persona 为极简语域 persona——只收窄
+        # 工具 schema 不够，首轮轨迹由 Minimal 的完整 system prompt 决定。
+        minimalPrompt:
+          enabled: true
+          persona: You are a helpful software engineer assistant.
+          suppressSections: true

package/lib/index.mjs

@@ -1,8 +1,9 @@
 /**
  * adaptive-perf — 极简性能自适应插件（@chaoset/adaptive-perf）
  *
- * 目标：让「标准模式（standard）」与「PTC 模式（code）」达到与「极简模式
- * （minimal）」相同级别的高性能。极简模式快的原因（对源码的对照结论）：
+ * 目标：让「标准模式（standard）」「PTC 模式（code）」与「创造模式
+ * （cordis）」达到与「极简模式（minimal）」相同级别的高性能。极简模式快
+ * 的原因（对源码的对照结论）：
  *   1. persona 配置了 includeRuntimeContext: false —— 每次模型请求不注入
  *      "Current runtime context" 快照（文件策略 / 审批策略等动态段）；
  *   2. 工具目录极小（只有 bash + str_replace_editor）—— 每个请求的
@@ -30,23 +31,20 @@
  *      （技能目录提醒 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 等编排类），只保留核心编码工具，
- *      随后根据两类信号在会话内"单调升级"放行对应工具族（只升不降）：
+ *      后**完整恢复**该模式的全部工具目录与常规上下文注入（0.7.0，
+ *      dsh-anchored-standard 语义：只锚定首轮，不减少后续功能）；阶段从
+ *      持久会话事件推导，resume/reload 不丢状态，晋升信号持久（compaction
+ *      不重置）；bootstrap.maxTokens（可选）给请求 #1 封顶输出预算，晋升后
+ *      剥离。
+ *   D. 常驻上下文抑制（suppressInjectedContext，0.5.0 新增，0.7.0 默认
+ *      开启）：true = 整个会话剥离技能目录提醒与 AGENTS.md 摘要注入（功能
+ *      可见性由常驻发现工具 dev_tool_search / skill_search / skill_load
+ *      承担——实测晋升后恢复注入会把轨迹拉回 standard-like）；false =
+ *      只剥离首轮，晋升后恢复常规注入（opt-in）。
+ *   E. 工具目录自适应精简（leanByDefault，0.7.0 默认关闭的 opt-in）：开启时
+ *      按"工具族"隐藏高开销低频工具（子代理 / 工作流 / ralph / goal 等编排
+ *      类），只保留核心编码工具，随后根据两类信号在会话内"单调升级"放行
+ *      对应工具族（只升不降）：
  *        - 关键词信号：用户消息命中某工具族的触发词（如"子代理"）→ 放行该族；
  *        - 失败信号：PTC 的 run_code 程序调用被隐藏工具报 UNKNOWN_TOOL
  *          （tools/result 失败文本含工具名）→ 放行该族，下次程序即可调用。
@@ -57,17 +55,15 @@
  *   - 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/pre-step（waterfall） 首轮剥离自动注入上下文
  *   - agent/request（waterfall） 首轮输出预算封顶
- *   - session/event  增量喂入持久事件（晋升 / compaction 纪元）
+ *   - session/event  增量喂入持久事件（晋升信号）
  *   - agent/created、agent/disposed、agent/inbox/inserted、tools/result 事件
  * 监听器都注册在 host 根作用域（与 dsh-agent-presets 自身同款用法），事件按
- * scope 过滤分发，子作用域派发的事件根监听器可收到；两个 waterfall 均以
- * prepend 注册保证"最外层"（剥离是最后一道变换）。
+ * scope 过滤分发，子作用域派发的事件根监听器可收到；waterfall 均以 prepend
+ * 注册保证"最外层"（剥离是最后一道变换）。
  *
  * 配置：cordis.patch.yml 的 config（安装默认）与
  *       ~/.dsh/plugins/adaptive-perf/config.json（设置页 UI，权威）合并，
@@ -89,6 +85,14 @@ try {
   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';
 
 /**
@@ -100,34 +104,41 @@ export const name = 'adaptive-perf';
  *
  * bootstrap：首轮锚定（参照 dsh-anchored-standard 的实测结论）。请求 #1 只暴露
  * bootstrap.tools（真实 Minimal 工具对），剥离 suppressedContextSources 列出的
- * 自动注入上下文；首个持久晋升信号（promoteOn）后恢复；compaction/end 之后回到
- * 受控目录（bootstrap 工具对 + compactionTools）直到新的晋升信号；maxTokens>0
- * 时给请求 #1 封顶输出预算（晋升后剥离）。
+ * 自动注入上下文；首个持久晋升信号（promoteOn）后完整恢复全部工具与常规注入
+ * （晋升是持久信号，compaction/end 不重置）；maxTokens>0 时给请求 #1 封顶输出
+ * 预算（晋升后剥离）。
  */
 export const DEFAULT_CONFIG = {
   /** 总开关：关闭后插件对会话不产生任何影响。 */
   enabled: true,
   /** 应用自适应的 agent preset 列表（composedPreset 返回值）。 */
-  presets: ['standard', 'code'],
+  presets: ['standard', 'code', 'cordis'],
+  /**
+   * 默认策略（0.7.0）：首轮锚定、晋升后 resident 目录（dsh-anchored-standard
+   * 语义）。非极简 preset 的会话：请求 #1 按极简条件组装（真实 Minimal 工具
+   * 对 + 极简 persona + 屏蔽全局引导段 + 剥离自动注入 + 抑制运行时快照）以
+   * 锚定极简轨迹；首个持久晋升信号后进入 resident 阶段——保留 bootstrap 工具
+   * 对 + 常驻发现工具（dev_tool_search / skill_search / skill_load），完整
+   * 目录经 dev_tool_search 按需解锁（避免晋升时一次性倒出完整目录把轨迹拉回
+   * standard-like，anchored-standard 实测的"晋升后回退"问题），常规上下文
+   * 注入恢复可见——功能不减少。工具目录默认零裁剪（leanByDefault 关闭，
+   * 编排类工具族始终可用）；需要时可在设置页按需开启。
+   */
   /** 抑制运行时上下文快照（等同极简模式的 includeRuntimeContext: false）。 */
   suppressRuntimeContext: true,
   /** 会话启动时默认隐藏编排类工具族（核心编码工具始终保留）。 */
-  leanByDefault: true,
+  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）剥离。
+   * （skill-catalog 技能目录提醒、agent-instructions AGENTS.md 摘要）；
+   * false = 只在 bootstrap 未晋升阶段剥离，晋升后恢复注入（0.7.0 默认，
+   * 与 dsh-anchored-standard 一致：只锚定首轮、不减少后续功能）。
    */
   suppressInjectedContext: true,
-  /** 晋升后常驻 skill_search / skill_load 两个按需技能发现工具。 */
-  skillDiscovery: true,
-  /** 晋升后注入一次"指令文件存在，需要时自读"的短提示（替代全文注入）。 */
-  instructionHint: true,
   /** 核心编码工具（不进入任何限制族；此处仅作文档展示）。 */
   coreTools: [
     'bash', 'read', 'write', 'edit', 'glob', 'grep', 'read_image',
@@ -174,9 +185,7 @@ export const DEFAULT_CONFIG = {
     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）。 */
+    /** 晋升后 resident 目录的常驻发现工具（按需解锁完整目录）。 */
     discoveryTools: ['dev_tool_search', 'skill_search', 'skill_load'],
     /** 请求 #1 的输出预算封顶（token）；0 = 不封顶（opt-in）。 */
     maxTokens: 0,
@@ -260,8 +269,7 @@ export function normalizeConfig(source, defaults = DEFAULT_CONFIG) {
     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),
+    discoveryTools: stringList(rawBootstrap.discoveryTools, db.discoveryTools),
     maxTokens,
   };
   const rawMP = raw.minimalPrompt !== null && typeof raw.minimalPrompt === 'object' && !Array.isArray(raw.minimalPrompt)
@@ -281,8 +289,6 @@ export function normalizeConfig(source, defaults = DEFAULT_CONFIG) {
     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,
@@ -296,7 +302,7 @@ export function validateConfig(partial) {
     throw new TypeError('adaptive-perf config must be a plain object');
   }
   const boolFields = ['enabled', 'suppressRuntimeContext', 'leanByDefault', 'escalateOnKeyword', 'escalateOnUnknownTool',
-    'suppressInjectedContext', 'skillDiscovery', 'instructionHint'];
+    'suppressInjectedContext'];
   for (const key of boolFields) {
     if (partial[key] !== void 0 && typeof partial[key] !== 'boolean') {
       throw new TypeError(`adaptive-perf config field "${key}" must be a boolean`);
@@ -342,7 +348,7 @@ export function validateConfig(partial) {
     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']) {
+    for (const key of ['tools', 'suppressedContextSources', 'discoveryTools']) {
       if (b[key] !== void 0 && !(Array.isArray(b[key]) && b[key].every((v) => typeof v === 'string'))) {
         throw new TypeError(`adaptive-perf config field "bootstrap.${key}" must be an array of strings`);
       }
@@ -519,89 +525,7 @@ export function mountRealPair(agent, mounts, warn) {
   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 的消息。
@@ -616,7 +540,17 @@ export function stripSuppressedMessages(messages, suppressedSources) {
   return kept.length === messages.length ? messages : kept;
 }
 
+// ── bootstrap 锚定（参照 dsh-anchored-standard 的实测结论）──────────────
+
+/** promoteOn 配置 → 晋升的持久事件类型集合。 */
+export const PROMOTE_EVENTS = {
+  'tool-call': ['tool/call'],
+  'assistant-message': ['assistant/message'],
+  either: ['tool/call', 'assistant/message'],
+};
+
 /**
+ /**
  * dev_tool_search：搜索完整可见目录并按名解锁工具（解锁结果下一请求生效，
  * 经 syncBootstrap 重算 deny 集；解锁记录写入 a.unlocked，resume-safe 由
  * loadUnlockedFromEvents 从持久事件恢复）。
@@ -828,49 +762,34 @@ export function extractSkillBody(skill) {
   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 时按"边界之后"处理（与参考实现一致）。
+ * 扫描一段持久会话日志，推导 { promoted } 阶段。
+ * 晋升是持久信号（与 dsh-anchored-standard 一致）：首次 promoteOn 事件后
+ * 恒为已晋升，resume/reload 不丢状态，compaction 不重置。
  */
 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)) {
+        promoted = true;
+        break;
       }
-      if (promoteEvents.includes(event?.type) && seq > boundary) promoted = true;
     }
   }
-  return { boundary, promoted };
+  return { 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) {
+  const promoteEvents = Array.isArray(entry.promoteEvents)
+    ? entry.promoteEvents
+    : PROMOTE_EVENTS[entry.promoteOn] ?? [];
+  if (promoteEvents.includes(event?.type)) {
     state.set(sessionId, { ...entry, promoted: true });
   }
 }
@@ -913,6 +832,34 @@ export function applyBootstrapBudget(config, promoted, maxTokens) {
 
 // ── 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 异常会导致进程启动失败）。
@@ -936,7 +883,7 @@ export async function apply(ctx, config, options = {}) {
 
     /** 真实 Minimal 工具对模块（0.5.0）。加载失败 = null = 降级旧行为。
      *  options.realPairModules 仅供测试注入。 */
-    const realPairModules = options.realPairModules === void 0
+    let realPairModules = options.realPairModules === void 0
       ? (cfg.bootstrap.enabled && cfg.bootstrap.realPair ? await loadRealPairModules() : null)
       : options.realPairModules;
     /** 是否已尝试加载过真实工具对模块（避免配置热更新时反复重试）。 */
@@ -947,9 +894,6 @@ export async function apply(ctx, config, options = {}) {
       } catch {}
     }
 
-    /** 已注入过 instruction-hint 的会话（内存去重，与参考实现一致）。 */
-    const hintedSessions = new Set();
-
     /**
      * 配置热更新把 realPair 从关闭切到开启时补加载官方模块（初始未启用时
      * 不加载）。加载成功后对已接管会话补挂。
@@ -1138,6 +1082,7 @@ export async function apply(ctx, config, options = {}) {
       a.realPairActive = a.realPairDisposers.length > 0;
     }
 
+
     /**
      * 给目标 agent 注册 on-demand 发现工具（dsh-anchored-standard 的 resident
      * discovery pattern）：晋升后常驻 bootstrap.discoveryTools 列出的工具——
@@ -1189,10 +1134,10 @@ export async function apply(ctx, config, options = {}) {
           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) {
+      if (name === 'skill_search') {
         return createSkillSearch({ skillsOf: () => ctx.get('skills') });
       }
-      if (name === 'skill_load' && cfg.skillDiscovery) {
+      if (name === 'skill_load') {
         return createSkillLoad({ skillsOf: () => ctx.get('skills') });
       }
       return null;
@@ -1250,10 +1195,6 @@ export async function apply(ctx, config, options = {}) {
         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 {}
       }
@@ -1261,6 +1202,10 @@ export async function apply(ctx, config, options = {}) {
       if (a.bootstrapDisposer !== null) {
         try { a.bootstrapDisposer(); } catch {}
       }
+      for (const disposer of a.toolDisposers.values()) {
+        try { disposer(); } catch {}
+      }
+      a.toolDisposers.clear();
       for (const disposer of a.familyDisposers.values()) {
         try { disposer(); } catch {}
       }
@@ -1312,10 +1257,11 @@ export async function apply(ctx, config, options = {}) {
     });
 
     // ── 首轮锚定（bootstrap，参照 dsh-anchored-standard 的实测结论）─────
-    // 阶段状态：sessionId -> { boundary, promoted, promoteEvents }。冷会话在
+    // 阶段状态：sessionId -> { promoted, promoteEvents }。冷会话在
     // handleAgent 时全量扫描持久日志（resume 安全），此后 session/event 增量
-    // 更新。子代理（delegationDepth > 0）恒为已晋升。所有 waterfall 用
-    // prepend 注册，保证本插件是"最外层"变换（剥离是最后一道）。
+    // 更新。晋升是持久信号（compaction 不重置）。子代理（delegationDepth > 0）
+    // 恒为已晋升。所有 waterfall 用 prepend 注册，保证本插件是"最外层"
+    // 变换（剥离是最后一道）。
     const bootstrapState = new Map();
     let bootstrapWarned = false;
     const warnBootstrapOnce = (message) => {
@@ -1326,14 +1272,14 @@ export async function apply(ctx, config, options = {}) {
 
     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 === void 0 || typeof session.id !== 'string') return { promoted: true };
       // 子代理首轮即可用工具（与参考实现一致）。
-      if ((session.header?.delegationDepth ?? 0) > 0) return { boundary: -1, promoted: true };
+      if ((session.header?.delegationDepth ?? 0) > 0) return { promoted: true };
       let entry = bootstrapState.get(session.id);
       if (entry === void 0) {
         entry = {
           ...scanPhase(session.events, PROMOTE_EVENTS[cfg.bootstrap.promoteOn]),
-          promoteEvents: PROMOTE_EVENTS[cfg.bootstrap.promoteOn],
+          promoteOn: cfg.bootstrap.promoteOn,
         };
         bootstrapState.set(session.id, entry);
       }
@@ -1348,12 +1294,13 @@ export async function apply(ctx, config, options = {}) {
     }
 
     /**
-     * bootstrap 阶段的保留工具集：
-     *  - 未晋升：bootstrap 工具对 + PTC 的直接调用工具（run_code）+
-     *    compaction 后恢复期的工作集；
-     *  - 已晋升：bootstrap 工具对 + resident discovery 工具 +
-     *    dev_tool_search 已解锁工具 + 已升级工具族（dsh-anchored-standard 的
-     *    resident catalog，避免晋升后一次性 dump 完整 Standard 目录）。
+     * bootstrap 阶段的保留工具集（0.7.0：首轮锚定、晋升后 resident 目录）：
+     *  - 未晋升：bootstrap 工具对 + PTC 的直接调用工具（run_code）；
+     *  - 已晋升：bootstrap 工具对 + 常驻发现工具（dev_tool_search /
+     *    skill_search / skill_load）+ dev_tool_search 已解锁工具
+     *    （dsh-anchored-standard 的 resident catalog：晋升时一次性倒出
+     *    完整 Standard 目录会把轨迹拉回 standard-like——晋升后回退问题，
+     *    因此重型工具保持一次 dev_tool_search 即可取用）。
      *
      * 注意：不能靠过滤 system-prompt/assemble 的 assembly.tools 来实现——
      * PTC 模式下 assembly.tools 只有 [run_code]，Minimal 工具对不在其中，
@@ -1371,14 +1318,7 @@ export async function apply(ctx, config, options = {}) {
       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;
     }
 
@@ -1386,7 +1326,7 @@ export async function apply(ctx, config, options = {}) {
     function syncBootstrap(a) {
       const phase = bootstrapPhaseOf(a.agent);
       const keep = bootstrapKeepSet(a);
-      // discovery 工具只在晋升后的 resident 阶段注册；bootstrap/compaction 阶段隐藏。
+      // discovery 工具只在晋升后的 resident 阶段注册；bootstrap 阶段隐藏。
       syncDiscoveryTools(a, keep !== null && phase.promoted);
       const key = keep === null ? null : [...keep].sort().join(',');
       if (key === a.bootstrapKey) return;
@@ -1415,65 +1355,29 @@ export async function apply(ctx, config, options = {}) {
       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) {
+        if (before === void 0 || after === void 0 || before.promoted !== after.promoted) {
           syncBootstrap(a);
         }
       }
     });
 
-    // 上下文剥离 + instruction-hint。prepend + 根作用域注册保证是最后一道
-    // 变换（后注册的注入者无法再补回）。两个职责同在一个监听器里，顺序天然
-    // 正确：先剥离被抑制来源，再（晋升后一次性）追加指令文件提示。
-    // 剥离与 bootstrap 开关正交：常驻抑制（suppressInjectedContext）在
-    // bootstrap 关闭时也生效；instruction-hint 依赖晋升阶段（bootstrap 机制）。
-    ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
+    // 上下文剥离（首轮锚定的注入部分）。prepend + 根作用域注册保证是
+    // 最后一道变换（后注册的注入者无法再补回）。
+    // 剥离条件：bootstrap 未晋升（首轮剥离）或常驻抑制开启
+    // （suppressInjectedContext，0.7.0 默认开启：晋升后注入保持剥离，
+    // 由常驻发现工具承担功能可见性）。
+    ctx.on('agent/pre-step', async ({ agent }, next) => {
       const decision = await next();
       if (decision === null || typeof decision !== 'object' || decision.kind === 'reject') return decision;
       try {
         if (!cfg.enabled || !isTarget(agent)) return decision;
         const phase = bootstrapPhaseOf(agent);
         const suppressed = new Set(cfg.bootstrap.suppressedContextSources);
-        let out = decision;
-        // 剥离条件：bootstrap 未晋升（旧行为）或常驻抑制开启（0.5.0 默认：
-        // 整个会话不再注入技能目录与 AGENTS.md 摘要，替代品是按需发现工具）。
+        if (suppressed.size === 0) return decision;
         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;
+        if (!stripActive || !Array.isArray(decision.messages)) return decision;
+        const kept = stripSuppressedMessages(decision.messages, suppressed);
+        return kept === decision.messages ? decision : { ...decision, messages: kept };
       } catch (error) {
         // 过滤失败绝不吞掉用户的上下文：原样放行。
         warnBootstrapOnce(`bootstrap context filter failed, keeping injected context: ${String((error && error.message) || error)}`);
@@ -1547,6 +1451,15 @@ export async function apply(ctx, config, options = {}) {
       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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaoset/adaptive-perf",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "DSH host plugin: bring standard / PTC presets to minimal-mode-level performance — real Minimal tool pair, permanent injected-context suppression with on-demand discovery, runtime-context suppression, and adaptive tool-catalog trimming with demand-driven escalation",
   "type": "module",
   "license": "MIT",
@@ -8,7 +8,9 @@
     "lib",
     "client",
     "cordis.patch.yml",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
   ],
   "exports": {
     ".": "./lib/index.mjs",
@@ -31,19 +33,16 @@
     }
   },
   "optionalDependencies": {
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-terminal": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-terminal-bash": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tool-bash-persistent": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-fs-local": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tool-str-replace-editor": "^0.1.0-rc.6"
-  },
-  "engines": {
-    "node": ">=22.19.0"
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-terminal": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-terminal-bash": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-tool-bash-persistent": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-fs-local": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-tool-str-replace-editor": "^0.1.0-rc.7"
   },
   "scripts": {
-    "test": "node ../../scripts/test.mjs",
-    "prepublishOnly": "npm test"
+    "test": "bun ../../scripts/test.mjs",
+    "prepublishOnly": "bun ../../scripts/test.mjs"
   },
   "repository": {
     "type": "git",