@yanglaofish/dsh-proxy-pro 1.1.0 → 2.0.2

package/README.md

@@ -135,6 +135,13 @@ dsh-proxy-pro
 
 ## 开发
 
+本地测试使用 Node.js 24（与发布 CI 一致）。多 profile 分别运行在独立进程中，
+可以使用不同监听端口并共用同一个上游代理；每个页面只能向自己的 `host:port`
+提交插件配置。此校验不影响代理端口、内网源或 `NO_PROXY`。
+
+启动会在插件初始化完成前应用已保存的代理配置；默认关闭时不改动已有传输。
+状态、系统提示和诊断提示会隐藏代理 URL 中的认证信息，连接参数及配置编辑框仍保留完整值。
+
 ```sh
 # 语法检查
 node --check lib/index.js lib/client.js lib/proxy-core.js
@@ -143,6 +150,15 @@ node --check lib/index.js lib/client.js lib/proxy-core.js
 npm test
 ```
 
+装有官方 Windows 桌面版时，可额外运行真实内核验证（替换为本机安装目录）：
+
+```powershell
+node scripts/verify-desktop-runtime.mjs 'E:\Agenttools\deepseek\app'
+```
+
+该验证在两个隔离进程内加载桌面版自带依赖，以本地测试代理检查认证、启动首请求、
+直连和关闭一方后的进程隔离，同时执行真实工具 schema 编译；不会修改已安装的 profile。
+
 - 纯逻辑层 `lib/proxy-core.js` 零 DSH 依赖，可独立单测。
 - **GitHub 安装模式**：改代码需 `git push` 后 `pnpm update @yanglaofish/dsh-proxy-pro` 再重启 `dsh web` 生效。
 - **npm 安装模式**：bump 版本 → `npm publish --access=public --registry=https://registry.npmjs.org --replace-registry-host=never` 后，profile 内 `pnpm add @yanglaofish/dsh-proxy-pro@最新版` 再重启 `dsh web` 生效。（scoped 包发布必须 `--access=public`；本机 npm 默认 registry 被公司镜像接管且 `replace-registry-host` 会重写 GET——发布与验证一律显式 `--registry` 官方源 + `--replace-registry-host=never`。）
@@ -150,4 +166,4 @@ npm test
 
 ## 许可
 
-MIT
+MIT

package/docs/LESSONS.md

@@ -991,4 +991,261 @@ PowerShell `env:` 枚举报「已添加了具有相同键的项」就是"证据"
 
 **排查手法（可复用）**：内核打包在 `…\DeepSeek Harness\resources\app.asar` 里，
 PowerShell 读不到；用 asar 头解析脚本（`_asar_probe.mjs` / `_asar_grep.mjs`）列文件、
-按路径取文件、全库 grep 字符串，再顺着 `dsh-app-boot` → 兼容判定看真相。
+按路径取文件、全库 grep 字符串，再顺着 `dsh-app-boot` → 兼容判定看真相。
+
+## 34. 发布后运维：淘宝同步端点 + profile 装包通道（2026-10-08）
+
+**淘宝主动同步（铁律 §28 的正确端点）**：
+
+- ✅ 可用：`PUT https://registry.npmmirror.com/-/sync?name=%40scope%2Fname` → `201 {"ok":true,…}`
+- ❌ 旧写法失效：`PUT https://registry.npmmirror.com/-/sync/@scope%2fname` → **404**；
+  `https://npmmirror.com/sync/@scope/name` → 405。workflow 里的同步步骤已按此改正
+  （此前 `|| true` 吞掉了 404，实际靠 npmmirror 懒同步兜底，属于"看起来同步了"的假象）。
+
+**profile 装包通道（升级 web/test/desktop 时）**：
+
+- profile 的 pnpm registry 是**华为内网镜像** `http://mirrors.tools.huawei.com/npm/`，
+  它对新版本有滞后：publish 完立刻 `pnpm add pkg@新版本` 会报
+  "The latest release of … is <旧版本>"，甚至 `--force` 也无法绕过（元数据是镜像给的）。
+- pnpm **直连** npmmirror / npmjs 报 `EACCES`（不走系统代理，被网络策略挡住）。
+- ✅ 解法：给 pnpm 挂上公司代理 + 显式淘宝 registry——
+  `$env:HTTP_PROXY=$env:HTTPS_PROXY='http://proxyhk.huawei.com:8080'` 然后
+  `pnpm add 'pkg@版本' --registry=https://registry.npmmirror.com`。
+- `pnpm cache delete <pkg>` 会列出/删除三份元数据缓存（huawei / npmjs / npmmirror），
+  可先用它排除缓存干扰。
+
+## 35. dsh 0.2 的 `webServer` 是晚挂载：不要在 apply 里 `ctx.get` 一次就当真（2026-10-08）
+
+**现象**：test profile 里客户端面板显示「宿主未提供配置接口（/dsh-proxy-pro/api/config）」，
+直接 `Invoke-WebRequest http://127.0.0.1:<port>/dsh-proxy-pro/api/config` → **404**
+（服务器活着，是回退处理器答的），而插件其它部分看起来正常。
+
+**根因**：dsh 0.2 里 `webServer`（`@deepseek-ai/dsh-host-webserver`）**在插件行 apply 之后才挂载**。
+我们原来的写法是 apply 里 `const webServer = ctx.get('webServer')`，拿到 `undefined` 就
+`if (webServer !== undefined)` 整块跳过——**静默、无日志**，路由永远没注册。
+
+**解法（0.2 的规范写法）**：用**作用域注入**在服务出现时再注册：
+
+```js
+if (typeof ctx.inject === 'function') {
+  ctx.inject(['webServer'], (childCtx) => { registerApi(childCtx.webServer) })
+}
+registerApi(ctx.get('webServer'))   // 旧内核：apply 时服务已在
+```
+
+- `ctx.inject([name], cb)` 在内核里到处都在用（`ctx.inject(['sessionPersistence'], …)`、
+  `ctx.inject(['settings'], …)`）；服务已存在时立即执行，后到时在执行。
+- 注册成功要打一行 info（`status API registered on …`）——这次就是靠"没有任何日志"才绕了弯路。
+- 用 `apiRegistered` 标志防止两条路径重复注册（重复 `register` 会抛）。
+- **不要**把 `webServer` 写进插件的 `inject` 顶层数组：那会让整个插件在无 web 服务的
+  composition（如纯 TUI）里永久 pending（§6 的坑）。
+
+**可复用教训**：0.2 里凡"我 apply 时它还没挂"的服务，都改用 `ctx.inject([...], cb)`；
+以及**静默跳过是最贵的失败模式**——拿不到依赖时要留日志。
+
+## 36. 设置字段必须 `.volatile()`，否则"点一下开启马上弹回"（2026-10-08）
+
+**现象**：面板能读（GET /config → 200，`enabled:false`），但点开关立刻弹回关闭。
+直接打接口拿到真话：
+
+```json
+POST /dsh-proxy-pro/api/config {"enabled":true}
+503 {"ok":false,"error":"Plugin entry \"dsh-proxy-pro\" has no volatile fields"}
+```
+
+**根因**：dsh 0.2 的 `dsh-settings` 只允许写**声明为 volatile 的字段**——
+`volatileForm(schema)` 要求节点带 `meta.volatile`，`isVolatilePath(schema, path)` 逐级校验；
+我们原来的 `Config` 一个字段都没标 → 任何写入都被拒。前端拿到失败后回滚乐观值，
+看起来就像"UI 坏了"。
+
+**解法**（文档与内核一致）：
+
+```js
+const volatile = (field) => (typeof field?.volatile === 'function' ? field.volatile() : field)
+const Config = z.object({
+  enabled: volatile(z.boolean().default(false)),
+  mode: volatile(z.union([...]).default('system')),
+  customUrl: volatile(z.string().default('http://127.0.0.1:7890')),
+  noProxy: volatile(z.string().default('localhost,127.0.0.1,::1')),
+  systemPollMs: z.number().default(30000).min(0),   // 只在 apply 时读，故意不标
+})
+```
+
+配套（文档给的契约，`cordis` README「Volatile configuration」+ `dsh-settings` README）：
+
+- 解析后的 volatile 字段是 **`Volatile<T>` 引用**，live 值用 **`.get()`** 读
+  （内核实例：`this.config.enabled.get()`）；旧内核/未标注时是普通值，两种都要能吃。
+- 仅 volatile 的改动由 Loader **就地提交**并用 **`loader/volatile-update`** 通知本 fiber
+  （`ctx.on('loader/volatile-update', …)`）——不需要重启、也不会重新 apply。
+- entry id（= 设置命名空间）直接读 **`ctx.fiber.entry?.options.id`**
+  （内核实例：dsh-experimental-speech-to-text），不必去 configEditor 里扫。
+- **自带设置页**的插件要在 `ctx.inject(['settings'], child => …)` 里
+  `configure({ auto: false }, ctx.fiber)`，否则会多出一个自动生成的表单。
+- **前端不许静默回滚**：把宿主的错误原文显示出来（本次就是靠它一句话定位）。
+
+**验证手法（不重启内核也能验）**：把 asar 里的 `schemastery`/`cosmokit` 抽到
+工作区 node_modules，给 `dsh-tools`/`dsh-http-proxy` 建桩，然后 import 插件真实模块，
+用内核同款 `volatileForm`/`isVolatilePath` 逻辑断言（`_core_probe/verify-config.mjs`），
+结果必须 PASS——比"重启了看看"快得多。
+
+## 37. 流程教训：先读包内 README，再逆向代码（2026-10-08）
+
+这一轮我一直在 asar 里逆向 lib 代码推规则，绕了远路。其实**每个 `@deepseek-ai` 包都带
+README.md / README.zh.md**，而且关键契约都写在里面：
+
+- `dsh-app-boot/README.md`：peer 兼容判定（"Before a profile imports a plugin, DSH checks
+  its peerDependencies on @deepseek-ai/dsh and @deepseek-ai/dsh-* against the single runtime
+  version returned by getDshRuntimeVersion()… missing DSH peers impose no constraint;
+  invalid ranges are incompatible"）、denied row/bundle 行为、`compatibility.json` 豁免。
+- `cordis/README.md`：volatile 引用契约（`.get()` + `loader/volatile-update`）。
+- `dsh-settings/README.md`：「字段必须 `.volatile()`」「表单按 profile entry id 识别」
+  「业务插件直接读自己的 Config 引用」「自带页面 `configure({auto:false})`」。
+
+**做法**：`node _asar_probe.mjs <app.asar> list 'README\.md$'` 找文档 →
+`cat` 抽出来读；`_asar_grep.mjs` 按字符串定位到具体包再读那一段。
+本会话早先可用的 `cordis-plugin-development` 技能当时已下线（调用报 unknown），
+所以**包内文档是这版内核唯一可靠的作者指南**。
+
+## 38. 写/移植插件的第一步：`cordis_inspect_*`（2026-10-08）
+
+**这是内核内置的权威契约查询能力**，比读 README 更精确、比逆向 lib 代码快一个数量级。
+`cordis_inspect_list` 列出全部 Provider，`cordis_inspect_query` 按 platform+provider+method 查：
+
+| platform | provider | method | 拿到什么 |
+| --- | --- | --- | --- |
+| host | Service | `listService` | 省略 `service` → 紧凑目录；给定 → **精确方法签名 + 引用类型声明** |
+| host | Event | `listEvents` | 省略 `event` → 事件目录（名称/mode/签名）；给定 → 单个事件契约 |
+| host | Config | `listConfigs` | 按 `name`/`entry` 查活条目目录或某条的**投影 JSON Schema**（volatile 一目了然） |
+| host | Tool | `listTools` | 当前 Agent 可调用的全部工具 schema |
+| client | Service / Event / Builtin / Slots / Theme | `listService` / `listEvents` / `listBuiltins` / `listSubTree` / `listTokens` | 客户端可注入服务、事件、可用内建符号、**实时槽位拓扑与注册契约**、主题 token |
+
+**这一轮用它验到的事实**（全部与本插件的改法对得上）：
+
+- `settings`：`configure(presentation, owner = this.ctx.fiber)`、`update(ns, patch, expectedRevision?)`、
+  `describe()`、`replace`、`mutate`；`ns` 明确是 **Profile entry id**。
+- `webServer.register({kind:'exact'|'prefix', path, handler})`；服务描述里写明
+  「启动期间未被认领的请求由 fallback 回 **404**，直到其 owner 注册」——正是我们那次 404 的机制。
+- **`loader/volatile-update` 不在 Event 目录里**（它是 cordis loader 的内部事件，只在本 fiber 上 emit）；
+  目录在册的是 **`settings/document-updated(ns, revision)`**（"One profile entry's form values,
+  availability, or page policy changed"）。两个都监听最稳，但**备案写法是后者**。
+- client 可注入服务目录（本组合）：`layout / locale / sessions / slots / theme / timer /
+  uiWorkspace / workspaces` —— **`settingsScope` 根本不存在**，`configForms` 也不在第三方可注入目录里。
+  所以"客户端只 inject `slots`、配置读写走插件自己的 HTTP API"是正确选择。
+- `Config` 目录里第三方条目形如 `{id: "include:dsh-mcp-manager", patchId: "dsh-mcp-manager"}`：
+  **entry id 是加载器条目 id（可能带 `include:` 前缀）**，所以要用 `ctx.fiber.entry?.options.id`
+  取，而不是自己拼包名。
+
+**顺序**：写/移植插件前 → `cordis_inspect_list` → 需要什么查什么（Service 签名 / Event 签名 /
+Config schema / Slots 契约）→ 再动手。**先查再写，不要先写再猜。**
+
+## 39. 客户端的两个贡献点必须在同一份状态上（2026-10-08）
+
+**现象**：写入已经成功（POST /config → 200，profile patch 文件也被改写），但**头部胶囊显示
+「代理 · ON」而设置面板显示「代理未启用」**——同一时刻、同一页面，两处结论相反。
+
+**两个独立原因，都要治**：
+
+1. **状态被复制**：胶囊注册在 `conversation.session.header.utilities`，面板注册在
+   `settings.section`——**设置外壳自己渲染一个 React root**，两棵树。原先 `apply()` 里
+   `createProxyStore()` 每次 apply 建一份 store，于是两棵树各看各的快照。
+   → 改为**模块级单例**（`proxyStore()` 惰性创建一份），所有贡献点共用同一状态。
+   **通用规则**：客户端半边的状态 store 一律做成模块级单例，不要放在 `apply()` 里。
+2. **乐观值卡死**：胶囊点击后置 `optimistic=next`，原逻辑只在
+   `settings.value.enabled === optimistic` 时才清除——**宿主拒写时这个条件永远不成立，
+   胶囊就永久停在 ON**。
+   → 改为**写完就结算**：`store.setEnabled(next).then(清乐观, 清乐观)`，
+   成功与否都以宿主答复为准（失败回滚 + 面板显示错误原文）。
+
+**顺带记住的排查手法**：页面自相矛盾时，先打宿主接口拿真值
+（`GET /config`）+ 看落盘文件（profile `cordis.patch.yml` 的 mtime 与内容），
+就能立刻区分"写没成功"和"前端状态不一致"——这次一查就知道**写入早就成功了**。
+
+## 40. 自查（code-review）抓到的问题 + 编码红线（2026-10-08）
+
+**🔴 渲染风暴（真 bug，会一直打接口）**：`useProxySettings` 把
+`store.refresh()` 写在 `subscribe` 回调里，而 subscribe 是**每次渲染新建的闭包**：
+渲染 → React 因 identity 变化重订阅 → subscribe 里 fetch `/config` → 响应 emit 新快照对象
+→ 再渲染 → 无限循环（每轮一次 HTTP 请求）。
+
+修法三条一起上：
+1. `subscribe`/`getSnapshot` 用 **`useCallback`** 固定 identity（依赖 `[store]`）；
+2. **首次加载挪到 `useEffect(() => { store.refresh() }, [store])`**，subscribe 只负责订阅；
+3. store 的 `emit()` 加**同值短路**（比较 status/writable/error/JSON.stringify(value)），
+   值没变就不通知——订阅者不该因为"又读了一遍同样的数据"而重渲染。
+
+**🟢 语义修正**：`configPayload(resolved, writable)` 增加可写标志，由宿主按
+「有 settings 服务且能 update/register」计算；只读 composition 不该在面板上给出可点的开关
+（点了必然 503）。
+
+**🔴 编码红线（我自己犯的）**：用 PowerShell `Get-Content -Raw | Set-Content` 回写
+`lib/index.js` 时，中文与破折号被读成系统代码页再以 UTF-8 写回，**全文变乱码**（`鈥?`）——
+与 §29 的 `Out-File` BOM 坑同源。
+
+- **规则：源码文件只用 `edit`/`write` 工具改；绝不用 shell 命令做文本往返。**
+- 需要批量替换时，先 `git status` 记住改动，出事后 `git checkout -- <file>` 回滚再用 edit 重做
+  （本次就是这么恢复的，回滚前先确认坏文件没有未提交的独有改动）。
+- 事后用乱码特征串（`鈥|锛|鐨|涓|鏄`）全仓扫一遍确认干净。
+
+**护栏**：`test/manifest-compat.test.mjs` 新增
+「the client store never refreshes from inside subscribe」——静态断言 subscribe 体内无
+`refresh()`、首刷在 `useEffect`、`useCallback` 存在、`emit` 有同值短路。
+
+## 41. 版本语义与 npm 管理操作（用户定案，2026-10-08）
+
+**版本约定：插件大版本 = dsh 的代际。**
+
+| 插件 | 服务的 dsh 代际 | 说明 |
+| --- | --- | --- |
+| 1.0.x | dsh 0.1.x（`0.1.5-rc.2` 时代） | 1.0.10 是那一代的稳定版 |
+| 2.0.x | dsh 0.2.x（`0.2.0-rc.2`） | 设置模型/客户端传输全变，属于破坏性适配 |
+
+- 因此 2.x 的 `peerDependencies` **收窄**为 `">=0.2.0-rc.2 <0.3.0"`——只声明真正验证过的代际，
+  不再假装支持 0.1（代码里的 legacy `settings.register` 分支作为防御性兜底保留，但不再承诺）。
+- 1.1.0 是一次失败的中间版本（只有 peer 放宽、缺 volatile/webServer/客户端修复）：
+  **不要把它当成 2.x 的前身**，直接以 2.0.1 作为 0.2 代的首发。
+
+**npm 管理操作（deprecate / unpublish）必须在 CI 里做**：
+
+- deprecate / unpublish 都是**对 registry 的认证写操作**，本地被 SWG 挡（§32）——
+  所以用 `.github/workflows/npm-admin.yml`（`workflow_dispatch`，输入 operation/target/message/otp），
+  在云端 runner 上执行。
+- **优先 deprecate**（npm 官方建议）：版本仍可被已有 lockfile 安装，但任何人解析它都会看到警告。
+  命令：`npm deprecate '<pkg>@<ver>' '<原因>'`。
+- **unpublish 有时间窗**：npm 只允许在发布后 **72 小时内**、且**没有依赖者**时删除，且删除后
+  该版本号不可复用。仅用于"根本没人可能装过"的事故版本。
+- 两者都可能要求 2FA：granular token 通常免 OTP；若被要求，把一次性码填进 `otp` 输入，
+  或直接在 npmjs 网页（版本页 → Delete）操作。
+
+## 42. 脱离公司网时的发布/升级路径（2026-10-08 实测）
+
+**环境特征**（判断当前处在哪种网络，决定走哪条路）：
+
+| 探测 | 在公司网 | 脱离公司网（本轮实测） |
+| --- | --- | --- |
+| 系统代理 | 开（proxyhk 等） | **关**（`ProxyEnable=0`） |
+| 华为内网镜像 `mirrors.tools.huawei.com` | 通 | **ENOTFOUND** |
+| registry.npmjs.org / registry.npmmirror.com | 直连被 SWG 拦（§32） | **直连可达** |
+| github.com | 经代理可推 | 直连不稳（IWR 超时，但 `git push` 常能过） |
+
+**本轮实际路径（都能用，按可用性选）**：
+
+1. **发包**：本地直连 `npm publish --registry=https://registry.npmjs.org` → 返回
+   "Your package is being processed"（staged），**约 2 分钟后**才在 registry 可见——别以为失败，
+   要轮询 `dist-tags`/`versions` 确认。
+2. **淘宝同步**：手动 `PUT https://registry.npmmirror.com/-/sync?name=%40scope%2Fname` → 201。
+3. **deprecate**：本地可做；**unpublish 不行**——免 2FA 的 granular token 被 npm 拒绝
+   （`Granular access tokens that bypass two-factor authentication may not perform this action`），
+   删除只能走网页 2FA 或带 OTP 的会话。
+4. **profile 升级**：内网镜像不可达时必须显式换源——
+   `pnpm add '<pkg>@<ver>' --registry=https://registry.npmmirror.com`；
+   `plugin_manager install_bundle` 同样支持 `registry` 入参（用它还能顺手把 bundles 组合改对）。
+5. **CI 仍可用**：tag 推上去即可；发布步骤已做成幂等（版本已存在就跳过），
+   所以"先本地发、后补 tag"不会报红。
+
+**验证工具（本轮新增，可复用）**：
+
+- `_core_probe/scan-mojibake.mjs`——ASCII 源码（`\u` 转义）+ 按**相对路径**跳过 node_modules，
+  扫真实乱码；注意 PowerShell 里传 CJK 正则本身可能被编码破坏，**别用它做乱码探测**。
+- `_core_probe/scan-workflows.mjs`——现成捕获"未加引号的 `: ` 值"这类会让 GitHub
+  **在零 job 层面拒掉整个 workflow 文件**的错误（现象：出现以文件名为名的失败 run）。
+- 读文件一律用 `read` 工具或 Node `readFileSync(..., 'utf8')`；`Get-Content` 的显示不等于文件内容。

package/lib/client.js

@@ -35,6 +35,7 @@ window.__ModuleLoader__.load({
     var react = require("react");
     var useState = react.useState;
     var useEffect = react.useEffect;
+    var useCallback = react.useCallback;
     var useRef = react.useRef;
     var useSyncExternalStore = react.useSyncExternalStore;
 
@@ -115,22 +116,51 @@ window.__ModuleLoader__.load({
     // scope (`{ status, value, writable }`), so the render code below is
     // unchanged; an older host simply has no /config route and the panel
     // reports itself unavailable instead of crashing.
+    //
+    // ONE store for the whole client half: the header capsule and the settings
+    // page live in different React trees (the settings shell renders its own
+    // root), and per-apply stores left them showing different snapshots —
+    // "header ON but panel OFF" (LESSONS §39). A module-level singleton makes
+    // every contributor observe exactly one state.
+    var sharedProxyStore = null
+
+    function proxyStore() {
+      if (sharedProxyStore === null) sharedProxyStore = createProxyStore()
+      return sharedProxyStore
+    }
+
     function createProxyStore() {
       var listeners = [];
-      var snapshot = { status: "loading", value: undefined, writable: false };
+      var snapshot = { status: "loading", value: undefined, writable: false, error: "" };
       var inflight = null;
+      /** Cheap equality so an unchanged payload does not notify: every emit
+       *  re-renders its subscribers, and a needless emit inside a render path
+       *  is how a store turns into a request storm (review fix, LESSONS §40). */
+      function unchanged(a, b) {
+        return a.status === b.status
+          && a.writable === b.writable
+          && a.error === b.error
+          && JSON.stringify(a.value) === JSON.stringify(b.value);
+      }
       function emit(next) {
+        if (unchanged(snapshot, next)) return;
         snapshot = next;
         listeners.slice().forEach(function (fn) {
           try { fn(); } catch (error) { console.error("[dsh-proxy-pro] listener failed:", error); }
         });
       }
+      /** Keep the last known state but surface why a write was refused: a
+       *  silent rollback is how a rejected settings write looks like a UI bug
+       *  (LESSONS §36 — "点一下马上弹回"). */
+      function fail(message) {
+        emit({ status: snapshot.status, value: snapshot.value, writable: snapshot.writable, error: message });
+      }
       function accept(data) {
         if (data === null || data.ok !== true || data.config === undefined || data.config === null) {
-          emit({ status: "unavailable", value: undefined, writable: false });
+          emit({ status: "unavailable", value: undefined, writable: false, error: (data && data.error) || "" });
           return false;
         }
-        emit({ status: "ready", value: data.config, writable: data.writable !== false });
+        emit({ status: "ready", value: data.config, writable: data.writable !== false, error: "" });
         return true;
       }
       function refresh() {
@@ -151,9 +181,14 @@ window.__ModuleLoader__.load({
           body: JSON.stringify(body),
         }).then(function (data) {
           if (data === null || data.ok !== true) {
-            throw new Error((data && data.error) || "config write failed");
+            var message = (data && data.error) || "配置写入失败（宿主未返回原因）";
+            fail(message);
+            throw new Error(message);
           }
           accept(data);
+        }, function (error) {
+          fail("无法连接宿主配置接口：" + String(error && error.message ? error.message : error));
+          throw error;
         });
       }
       return {
@@ -171,22 +206,23 @@ window.__ModuleLoader__.load({
       };
     }
 
-    /** Subscribe to the host-backed config store → `{ value, writable, ready }`. */
+    /** Subscribe to the host-backed config store → `{ value, writable, ready }`.
+     *  The subscribe/getSnapshot callbacks are identity-stable (`useCallback`)
+     *  and the first load lives in an effect: calling `refresh()` from inside
+     *  subscribe re-subscribed on every render and looped GET /config forever
+     *  (review fix, LESSONS §40). */
     function useProxySettings(store) {
-      var snapshot = useSyncExternalStore(
-        function (onChange) {
-          var unsubscribe = store.subscribe(onChange);
-          store.refresh();
-          return unsubscribe;
-        },
-        function () { return store.getSnapshot(); }
-      );
+      var subscribe = useCallback(function (onChange) { return store.subscribe(onChange); }, [store]);
+      var getSnapshot = useCallback(function () { return store.getSnapshot(); }, [store]);
+      var snapshot = useSyncExternalStore(subscribe, getSnapshot);
+      useEffect(function () { store.refresh(); }, [store]);
       var ready = snapshot.status === "ready" && snapshot.value !== undefined;
       return {
         value: ready ? snapshot.value : undefined,
         writable: snapshot.writable === true && ready,
         ready: snapshot.status === "unavailable" ? false : snapshot.status === "ready",
         unavailable: snapshot.status === "unavailable",
+        error: snapshot.error || "",
       };
     }
 
@@ -269,9 +305,14 @@ window.__ModuleLoader__.load({
         if (!settings.writable) return;
         var next = !shownEnabled;
         setOptimistic(next);
-        store.setEnabled(next).catch(function (error) {
+        // The shared store receives the host's answer for this write, so the
+        // optimistic echo ends as soon as the round trip settles — success or
+        // failure. Waiting for "value === optimistic" left the capsule stuck ON
+        // whenever the host refused the write (LESSONS §39).
+        store.setEnabled(next).then(function () {
+          setOptimistic(null);
+        }, function (error) {
           console.error("[dsh-proxy-pro] toggle failed:", error);
-          // Roll back to the committed value on failure.
           setOptimistic(null);
         });
         // Toggle doubles as a manual "recheck now" even when the settings
@@ -285,6 +326,7 @@ window.__ModuleLoader__.load({
       var title = active
         ? "代理已开启（界面开关）· 点击关闭"
         : "代理已关闭 · 点击开启";
+      if (settings.error) title = title + "\n最近一次写入失败：" + settings.error;
       return react.createElement(
         "button",
         {
@@ -346,8 +388,10 @@ window.__ModuleLoader__.load({
       // Address is configuration-driven: custom mode shows the custom URL
       // immediately (no stale host snapshot), system mode shows the URL the
       // host read from Windows.
+      // 配置输入框保留原始认证信息；状态文字不展示用户名或密码。
+      var publicCustomUrl = (value.customUrl || "").replace(/^(https?:\/\/)[^/?#]*@/i, "$1");
       var shownUrl = modeNow === "custom"
-        ? (value.customUrl || "—")
+        ? (publicCustomUrl || "—")
         : ((status && status.url) || "—");
       var statusLine = cfgActive
         ? "代理生效中 · " + shownUrl
@@ -355,7 +399,7 @@ window.__ModuleLoader__.load({
       var subLine = "";
       if (cfgActive) {
         if (modeNow === "custom") {
-          subLine = "自定义地址（立即生效）" + (status && status.url && status.url !== value.customUrl ? " · 已应用: " + status.url : "");
+          subLine = "自定义地址（立即生效）" + (status && status.url && status.url !== publicCustomUrl ? " · 已应用: " + status.url : "");
         } else if (status !== null && status !== undefined) {
           subLine = status.active === true
             ? "跟随 Windows 系统代理（自动刷新）"
@@ -429,6 +473,15 @@ window.__ModuleLoader__.load({
             }))
         ),
 
+        // --- last write failure (never fail silently: LESSONS §36) ---
+        settings.error
+          ? react.createElement("div", { className: "dsxprx-status", "data-active": "false", "data-proxy-error": true },
+              react.createElement("span", { className: "dsxprx-dot" }),
+              react.createElement("div", { className: "dsxprx-statusbody" },
+                react.createElement("span", { className: "dsxprx-statusline" }, "配置写入失败"),
+                react.createElement("span", { className: "dsxprx-subline" }, settings.error)))
+          : null,
+
         // --- mode ---
         react.createElement("div", { className: "dsxprx-field" },
           react.createElement("label", { htmlFor: "dsxprx-mode" }, "代理地址来源"),
@@ -533,7 +586,7 @@ window.__ModuleLoader__.load({
      * @param ctx - client cordis context.
      */
     function apply(ctx) {
-      var store = createProxyStore();
+      var store = proxyStore();
       ctx.effect(function () { return function () { /* no timers to clear */ }; }, "dsh-proxy-pro: config store");
       ctx.slots.inject("settings.section", function () {
         return ctx.slots.register({
@@ -570,4 +623,4 @@ window.__ModuleLoader__.load({
     ];
     return module.exports;
   },
-});
+});

package/lib/index.js

@@ -34,13 +34,13 @@ import {
   classifyTargetFailure,
   combineDualProbe,
   configPayload,
-  DEFAULT_ENTRY_ID,
-  discoverEntryId,
   headNeedsGetRetry,
   keepaliveHint,
   makeSystemProxyReader,
   normalizeProxyUrl,
-  readEntryConfig,
+  readProxyConfig,
+  redactProxyUrl,
+  resolveEntryId,
   resolveProxyState,
   summarize,
   systemFactsEqual,
@@ -73,14 +73,30 @@ const SECTION_ORDER = 55
 /** Base path for the status HTTP API (client polls this). */
 const ROUTE_BASE = '/dsh-proxy-pro/api'
 
+/**
+ * Mark one Config field live-editable.
+ *
+ * dsh >= 0.2 only accepts a settings write whose paths sit under a field whose
+ * schema node carries `meta.volatile` (`volatileForm`/`isVolatilePath` in
+ * dsh-settings); an unmarked schema answers `Plugin entry "…" has no volatile
+ * fields` and every toggle bounces straight back (LESSONS §36). The guard keeps
+ * the definition loadable on older schemastery builds without `.volatile()`.
+ *
+ * @param field - a schemastery field.
+ * @returns the same field, marked volatile when the API exists.
+ */
+const volatile = (field) => (typeof field?.volatile === 'function' ? field.volatile() : field)
+
 /** Composition-row configuration (also the settings schema). */
 const Config = z.object({
-  enabled: z.boolean().default(false),
+  enabled: volatile(z.boolean().default(false)),
   // 'none' kept only for parsing pre-removal settings.yaml values; the UI and
   // proxy_config never produce it anymore (LESSONS §17.3e).
-  mode: z.union([z.const('system'), z.const('custom'), z.const('none')]).default('system'),
-  customUrl: z.string().default('http://127.0.0.1:7890'),
-  noProxy: z.string().default('localhost,127.0.0.1,::1'),
+  mode: volatile(z.union([z.const('system'), z.const('custom'), z.const('none')]).default('system')),
+  customUrl: volatile(z.string().default('http://127.0.0.1:7890')),
+  noProxy: volatile(z.string().default('localhost,127.0.0.1,::1')),
+  // Deliberately NOT volatile: the poll interval is read once at apply time,
+  // so promising a live edit here would be a lie. It stays a composition knob.
   systemPollMs: z.number().default(30000).min(0),
 })
 
@@ -118,7 +134,8 @@ function makeEnvLike(effective) {
   }
 }
 
-/** Build the agent-facing status text from the latest sync snapshot. */function renderStatusText(snapshot) {
+/** Build the agent-facing status text from the latest sync snapshot. */
+function renderStatusText(snapshot) {
   const effective = snapshot?.effective
   const config = snapshot?.config
   if (effective === undefined || config === undefined) {
@@ -145,7 +162,7 @@ function makeEnvLike(effective) {
   return [
     '## Proxy status: ON',
     '',
-    `The whole runtime (model requests, web_search/web_fetch, and all spawned tools) is routed through the proxy: ${effective.url} (${source}).`,
+    `The whole runtime (model requests, web_search/web_fetch, and all spawned tools) is routed through the proxy: ${redactProxyUrl(effective.url)} (${source}).`,
     '',
     `Bypass list (NO_PROXY, traffic goes direct): ${effective.noProxy || '(none)'}.`,
     '',
@@ -294,7 +311,7 @@ async function probeTarget(url, snapshot, channel = 'dual') {
   let routeName = 'DIRECT'
   try {
     const routeProbe = proxyRouteFor(parsed)
-    routeName = routeProbe.proxied ? `PROXIED ${routeProbe.proxy}` : 'DIRECT'
+    routeName = routeProbe.proxied ? `PROXIED ${redactProxyUrl(routeProbe.proxy)}` : 'DIRECT'
   } catch {
     // proxyRouteFor unavailable in this composition → rely on state snapshot
   }
@@ -346,11 +363,11 @@ async function probeTarget(url, snapshot, channel = 'dual') {
 // dsh-skill-manager ships (its lib/index.js L131-172), matching the loopback
 // verdict of the official fence with zero extra dependencies.
 
-/** Normalized URL of a Host-header authority (hostname lowercased), or undefined. */
+/** 解析请求所访问的 profile 地址，保留端口以区分并行运行的 profile。 */
 function parseHostHeader(host) {
   if (typeof host !== 'string' || !host) return undefined
   try {
-    return new URL(`http://${host}`).hostname.toLowerCase()
+    return new URL(`http://${host}`)
   } catch {
     return undefined
   }
@@ -367,14 +384,16 @@ function isLoopbackHostname(hostname) {
 /** True when the Host is loopback and any attached browser markers are same-origin. */
 function isTrustedPanelRequest(headers) {
   const host = typeof headers?.get === 'function' ? headers.get('host') : headers?.host
-  const hostname = parseHostHeader(host)
-  if (!hostname || !isLoopbackHostname(hostname)) return false
+  const hostUrl = parseHostHeader(host)
+  if (!hostUrl || !isLoopbackHostname(hostUrl.hostname)) return false
   if (headers?.get && headers.get('sec-fetch-site') === 'cross-site') return false
   if (!headers?.get && headers?.['sec-fetch-site'] === 'cross-site') return false
   const originRaw = typeof headers?.get === 'function' ? headers.get('origin') : headers?.origin
   if (originRaw === undefined || originRaw === null || originRaw === '') return true
   try {
-    return new URL(originRaw).hostname.toLowerCase() === hostname
+    // 与 DSH Connection 的校验保持一致：各 profile 只接受自己的 host:port。
+    // Desktop 会把 dsh-app://app 改写为目标 Host 的 origin；无 Origin 的本地 CLI 仍兼容。
+    return new URL(originRaw).host === hostUrl.host
   } catch {
     return false
   }
@@ -397,7 +416,7 @@ function denyIfUntrusted(req, res) {
  * @param ctx - registrant context.
  * @param config - validated composition configuration.
  */
-function apply(ctx, config) {
+async function apply(ctx, config) {
   const systemProxyReader = makeSystemProxyReader(execFileAsync)
   let source = () => config
   let snapshot = undefined
@@ -486,12 +505,13 @@ function apply(ctx, config) {
   //    service (register(ns, schema, {base}) → scope.get()/watch()).
   //  - dsh >= 0.2: register()/watch() are gone. The plugin's OWN composition
   //    entry IS the settings form (namespace = entry id, schema = this Config),
-  //    writes go through settings.update(entryId, patch) and every commit
-  //    emits `settings/document-updated`, which is what re-syncs us live.
+  //    writes go through settings.update(entryId, patch), the live values are
+  //    the Config's volatile references, and Loader announces a volatile-only
+  //    commit with `loader/volatile-update`.
   const settingsService = ctx.get('settings')
   const configEditor = ctx.get('configEditor')
   const legacyRegister = typeof settingsService?.register === 'function'
-  const entryId = discoverEntryId(configEditor, ctx) ?? DEFAULT_ENTRY_ID
+  const entryId = resolveEntryId(ctx, configEditor)
   if (legacyRegister) {
     const proxyScope = settingsService.register(PROXY_NS, Config, { base: config })
     source = () => proxyScope.get()
@@ -499,17 +519,47 @@ function apply(ctx, config) {
       void requestSync().catch(() => {})
     })
   } else if (typeof settingsService?.update === 'function') {
-    source = () => readEntryConfig(configEditor, entryId, config)
+    // Documented volatile contract (cordis README, dsh-settings README, and the
+    // host Service/Event Inspect providers — LESSONS §36/§38): resolved
+    // `.volatile()` fields are `Volatile<T>` references read through `.get()`,
+    // and a volatile-only edit is committed into that same reference. The
+    // catalogued notification is `settings/document-updated(ns, revision)`; the
+    // loader also emits its internal `loader/volatile-update` on this fiber, so
+    // both are observed (sync is idempotent).
+    source = () => readProxyConfig(config)
     ctx.on('settings/document-updated', (ns) => {
       if (ns === entryId) void requestSync().catch(() => {})
     })
+    ctx.on('loader/volatile-update', () => {
+      void requestSync().catch(() => {})
+    })
+  }
+  // We ship our own settings page (代理配置), so opt out of the auto-generated
+  // form — the documented pattern is an effect inside an injected child, so a
+  // late-loading Settings service still picks the policy up.
+  if (typeof ctx.inject === 'function') {
+    ctx.inject(['settings'], (child) => {
+      child.effect(() => {
+        try {
+          return child.settings.configure({ auto: false }, ctx.fiber)
+        } catch (error) {
+          ctx.logger.warn('dsh-proxy-pro: settings page policy not applied: %s', String(error))
+          return () => {}
+        }
+      }, 'dsh-proxy-pro: settings page policy')
+    })
   }
   // Without either generation the plugin still runs read-only on the
   // composition config (source keeps returning it).
 
+  /** Whether this composition can persist a configuration write at all: a
+   *  read-only composition must not offer enabled controls in the panel. */
+  const settingsWritable = settingsService !== undefined
+    && (legacyRegister || typeof settingsService.update === 'function')
+
   /** Persist one config patch through whichever settings generation is present. */
   const writeSettings = async (patch) => {
-    if (settingsService === undefined) {
+    if (!settingsWritable) {
       throw new Error('the settings service is unavailable in this composition — change the proxy configuration in the composition instead')
     }
     await settingsService.update(legacyRegister ? PROXY_NS : entryId, patch)
@@ -633,7 +683,7 @@ function apply(ctx, config) {
         } else {
           const normalized = normalizeProxyUrl(raw)
           if (normalized === null) {
-            throw new Error(`proxy_config: "${args.customUrl}" is not a usable proxy address — expected http(s)://host:port (a bare host:port is also accepted)`)
+            throw new Error('proxy_config: invalid proxy address — expected http(s)://host:port (a bare host:port is also accepted)')
           }
           patch.customUrl = normalized
         }
@@ -684,8 +734,20 @@ function apply(ctx, config) {
     }
   }
 
-  const webServer = ctx.get('webServer')
-  if (webServer !== undefined) {
+  /**
+   * Register the status/config HTTP API on the web server.
+   *
+   * dsh 0.2 mounts `webServer` AFTER plugin rows have applied, so reading
+   * `ctx.get('webServer')` once inside apply() returned undefined and this
+   * whole block was skipped silently — the panel then reported "宿主未提供
+   * 配置接口" while everything else looked healthy (LESSONS §35). The 0.2
+   * idiom is `ctx.inject([...], (child) => …)`: it runs as soon as the service
+   * exists (immediately when it already does). The direct read stays as the
+   * fallback for older cores.
+   */
+  let apiRegistered = false
+  const registerApi = (webServer) => {
+    if (apiRegistered || webServer === undefined || typeof webServer.register !== 'function') return false
     try {
       const unregisterRoute = webServer.register({
         kind: 'prefix',
@@ -738,7 +800,7 @@ function apply(ctx, config) {
             // the browser settings transport (`ctx.settingsScope`), so the panel
             // reads and writes through this API instead (LESSONS §33).
             if (is('/config', 'GET')) {
-              sendJson(res, 200, { ok: true, ...configPayload(source()) })
+              sendJson(res, 200, { ok: true, ...configPayload(source(), settingsWritable) })
               return
             }
             if (is('/config', 'POST')) {
@@ -759,7 +821,7 @@ function apply(ctx, config) {
                 } else {
                   const normalized = normalizeProxyUrl(raw)
                   if (normalized === null) {
-                    sendJson(res, 400, { ok: false, error: `"${body.customUrl}" is not a usable proxy address — expected http(s)://host:port` })
+                    sendJson(res, 400, { ok: false, error: 'invalid proxy address — expected http(s)://host:port' })
                     return
                   }
                   patch.customUrl = normalized
@@ -773,7 +835,7 @@ function apply(ctx, config) {
                 return
               }
               await requestSync()
-              sendJson(res, 200, { ok: true, ...configPayload(source()) })
+              sendJson(res, 200, { ok: true, ...configPayload(source(), settingsWritable) })
               return
             }
             sendJson(res, 404, { ok: false, error: 'not found' })
@@ -783,11 +845,22 @@ function apply(ctx, config) {
         },
       })
       ctx.effect(() => () => { try { unregisterRoute?.() } catch { /* best effort */ } }, 'dsh-proxy-pro: route cleanup')
+      apiRegistered = true
+      ctx.logger.info('dsh-proxy-pro: status API registered on %s', ROUTE_BASE)
+      return true
     } catch (error) {
       ctx.logger.warn('dsh-proxy-pro: webServer unavailable — status API disabled: %s', String(error))
+      return false
     }
   }
 
+  // Late-bound registration (dsh 0.2 mounts webServer after plugin rows).
+  if (typeof ctx.inject === 'function') {
+    ctx.inject(['webServer'], (childCtx) => { registerApi(childCtx.webServer) })
+  }
+  // Older cores where the service is already present at apply time.
+  registerApi(ctx.get('webServer'))
+
   // Follow the Windows system proxy at runtime (change-only re-apply).
   if (config.systemPollMs > 0) {
     pollTimer = setInterval(async () => {
@@ -827,6 +900,10 @@ function apply(ctx, config) {
       }
     }
   }, 'dsh-proxy-pro: cleanup')
+
+  // Loader 等待 apply 完成后再开放能力；首次模型请求前应用保存的配置。
+  // 先登记清理逻辑，以覆盖初始化期间卸载的情况。默认关闭时仍不碰现有传输。
+  await requestSync()
 }
 
-export { Config, apply, inject, name }
+export { Config, apply, inject, name }

package/lib/proxy-core.js

@@ -21,42 +21,67 @@ export const DEFAULT_ENTRY_ID = 'dsh-proxy-pro'
 
 /**
  * Resolve this plugin's composition entry id — the settings namespace on
- * dsh >= 0.2 (LESSONS §33). Prefers the row whose fiber IS this context, then
- * the known bundle id; undefined when the editor cannot be read.
+ * dsh >= 0.2 (LESSONS §33). Core plugins read it straight off the fiber
+ * (`ctx.fiber.entry?.options.id`, e.g. dsh-experimental-speech-to-text); the
+ * config-editor row match is the fallback, then the known bundle id.
  */
-export function discoverEntryId(configEditor, ctx) {
+export function resolveEntryId(ctx, configEditor, fallback = DEFAULT_ENTRY_ID) {
+  const direct = ctx?.fiber?.entry?.options?.id
+  if (typeof direct === 'string' && direct.length > 0) return direct
   try {
     const rows = configEditor?.configuration?.() ?? []
     const own = rows.find((row) => row?.entry?.fiber === ctx?.fiber)
-      ?? rows.find((row) => row?.entry?.options?.id === DEFAULT_ENTRY_ID)
+      ?? rows.find((row) => row?.entry?.options?.id === fallback)
     const id = own?.entry?.options?.id
-    return typeof id === 'string' && id.length > 0 ? id : undefined
+    return typeof id === 'string' && id.length > 0 ? id : fallback
   } catch {
-    return undefined
+    return fallback
   }
 }
 
 /**
- * Effective config of one entry: the composed layers, then the profile patch.
- * Every Config field is a scalar, so a shallow merge is exact.
+ * Read one resolved Config field.
+ *
+ * Cordis' documented volatile contract (vendor loader README, LESSONS §36):
+ * a field declared `.volatile()` resolves to a `Volatile<T>` **reference**
+ * whose live value is read with `.get()`; Loader commits volatile-only edits
+ * into that same reference. Older cores (and our `.volatile()` guard on old
+ * schemastery) hand back a plain value, so both shapes are accepted.
  */
-export function readEntryConfig(configEditor, entryId, fallback) {
-  try {
-    const rows = configEditor?.configuration?.() ?? []
-    const own = rows.find((row) => row?.entry?.options?.id === entryId)
-    if (own !== undefined) return { ...fallback, ...(own.inherited ?? {}), ...(own.override ?? {}) }
-  } catch {
-    /* fall through to the apply-time config */
+export function readConfigField(config, field, fallback) {
+  const value = config?.[field]
+  if (value !== null && typeof value === 'object' && typeof value.get === 'function') {
+    try {
+      const live = value.get()
+      return live === undefined ? fallback : live
+    } catch {
+      return fallback
+    }
+  }
+  return value === undefined ? fallback : value
+}
+
+/** The plain, serializable configuration the tools/client/API consume. */
+export function readProxyConfig(config) {
+  return {
+    enabled: readConfigField(config, 'enabled', false) === true,
+    mode: readConfigField(config, 'mode', 'none'),
+    customUrl: readConfigField(config, 'customUrl', ''),
+    noProxy: readConfigField(config, 'noProxy', ''),
+    systemPollMs: readConfigField(config, 'systemPollMs', 0),
   }
-  return fallback
 }
 
 /**
  * Editable configuration payload for the client panel (`/config` API). The
  * browser cannot reach the settings transport on dsh >= 0.2, so the host hands
  * the panel exactly the fields it edits (LESSONS §33).
+ *
+ * @param resolved - the live configuration (see {@link readProxyConfig}).
+ * @param writable - whether this composition can persist a write at all; a
+ *   read-only composition must not offer enabled controls (review fix).
  */
-export function configPayload(resolved) {
+export function configPayload(resolved, writable = true) {
   return {
     config: {
       enabled: resolved?.enabled === true,
@@ -65,7 +90,7 @@ export function configPayload(resolved) {
       noProxy: resolved?.noProxy ?? '',
       systemPollMs: resolved?.systemPollMs ?? 0,
     },
-    writable: true,
+    writable: writable === true,
   }
 }
 
@@ -85,6 +110,21 @@ export function normalizeProxyUrl(value) {
   return url.toString().replace(/\/+$/, '')
 }
 
+/** 仅用于状态展示；传输层和可编辑配置继续使用完整的原始地址。 */
+export function redactProxyUrl(value) {
+  if (typeof value !== 'string' || value === '') return ''
+  try {
+    const url = new URL(value)
+    if (!url.username && !url.password) return value
+    url.username = ''
+    url.password = ''
+    return url.toString().replace(/\/+$/, '')
+  } catch {
+    // 无效地址也不能把 user:password 原样带入错误提示。
+    return value.replace(/(https?:\/\/)[^\s/?#]*@/gi, '$1[redacted]@')
+  }
+}
+
 /**
  * Parse a Windows `ProxyServer` string: single `host:port` (both protocols)
  * or `http=...;https=...` form; `socks=` ignored (undici speaks HTTP CONNECT).
@@ -299,7 +339,7 @@ export function summarize(snapshot) {
     active: effective?.active === true,
     enabled: config?.enabled === true,
     mode: config?.mode ?? 'none',
-    url: effective?.url ?? '',
+    url: redactProxyUrl(effective?.url ?? ''),
     noProxy: effective?.noProxy ?? composeNoProxy(config?.noProxy),
     reason: effective?.reason ?? 'unknown',
     source: config?.mode === 'system' ? 'system' : config?.mode === 'custom' ? 'custom' : 'none',
@@ -317,7 +357,7 @@ export function summarize(snapshot) {
 export function keepaliveHint(message = '', proxyUrl = '') {
   const text = typeof message === 'string' ? message : ''
   if (!/407|NTLM|proxy authentication|authentication required/i.test(text)) return ''
-  const example = typeof proxyUrl === 'string' && proxyUrl !== '' ? proxyUrl : 'http://localhost:7890'
+  const example = typeof proxyUrl === 'string' && proxyUrl !== '' ? redactProxyUrl(proxyUrl) : 'http://localhost:7890'
   return `该代理要求 NTLM 认证，undici 无法自行协商。最近一次 curl/浏览器到同一代理的连接会保持一段已认证窗口——先执行一次 \`curl -x ${example} -I https://github.com\`，然后重试。`
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanglaofish/dsh-proxy-pro",
-  "version": "1.1.0",
+  "version": "2.0.2",
   "description": "DSH proxy manager: route model requests, web fetches and spawned tools through the Windows system proxy or a custom address; per-URL route diagnosis, one-click toggle from the conversation header, a dedicated Settings page, and keepalive-aware 407 hints.",
   "type": "module",
   "main": "./lib/index.js",
@@ -40,10 +40,10 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.0",
-    "@deepseek-ai/dsh-http-proxy": ">=0.1.5-rc.2 <0.3.0",
-    "@deepseek-ai/dsh-settings": ">=0.1.5-rc.2 <0.3.0",
-    "@deepseek-ai/dsh-system-prompt": ">=0.1.5-rc.2 <0.3.0",
-    "@deepseek-ai/dsh-tools": ">=0.1.5-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-http-proxy": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-settings": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-system-prompt": ">=0.2.0-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-tools": ">=0.2.0-rc.2 <0.3.0",
     "@deepseek-ai/schemastery": "^3.18.0"
   },
   "dsh": {
@@ -53,10 +53,10 @@
     "client": {
       "platform": "web",
       "inject": [
-        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-conversation"
       ]
     }
   }
-}
+}