dsh-default-model-lock 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,81 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![](https://img.shields.io/badge/powered_by-dafeiyu-4D6BFE?style=flat-square&logo=deepseek&logoColor=white)](https://github.com/Dafeiyu111)
+
+# 默认模型锁定
+
+为 DeepSeek Harness 提供一把共享默认模型的锁：在设置页选好 provider、model 和推理档位，启用保存后，**共享默认值被钉死**。
+
+起因：在 UI 里切一次模型，会把 `cordis.yml` 里的默认模型一起改掉（还会丢掉 `reasoningEffort` 行），于是心跳、看板定时任务、新会话全都跟着换模型。本插件把这件事变成显式开关。
+
+## 安装
+
+```powershell
+# 先看会做什么（不写任何文件）
+pwsh -File scripts/install-profile.ps1 -DryRun
+
+# 装进目标 profile（自动备份 package.json 与 cordis.patch.yml）
+pwsh -File scripts/install-profile.ps1 -Profile "$env:USERPROFILE\.dsh\profiles\desktop"
+```
+
+重载插件后，设置页出现「默认模型锁定」一节；改源码后必须重载/重启 DSH 才生效（刷新页面不够）。
+卸载与还原步骤见 [docs/INSTALL.md](docs/INSTALL.md)。
+
+## 行为
+
+- **聊天里仍可自由切换模型**：`session.selectModel()` 只影响当前会话。
+- **但切不动共享默认值**：`saveSelection()` 在进入原服务保存队列之前就被拦下，写入直接 fulfilled。
+- `currentSelection()` 返回配置里的精确选择；新会话、headless、心跳、定时任务读到的是锁定值。
+- 关闭锁定即恢复官方行为，并把 provider/model 从配置里 `unset`，官方默认值重新生效（插件从不改写官方默认模型配置）。
+- 推理档位留空 = 交给模型适配器的默认档；填了就按填的。
+- 无效 provider/model **fail closed**：不猜、不 fallback、不写任何东西。
+- 只在加载了本插件的 profile 里生效。
+
+## 拦截点
+
+包装 `@deepseek-ai/dsh-agent-default-model` 服务实例上的 `currentSelection()` 与 `saveSelection()`：
+
+- 用 Cordis 的 `symbols.original` 取回原始服务对象，在**实例**上包装 own methods —— 覆盖普通 `ctx` 属性、`ctx.get()`、`root`、headless 的同形读取，以及已缓存的服务对象。
+- 不改 prototype、不改磁盘、不调模型接口。
+- 卸载时恢复原 descriptor；服务重建时自动重新安装。
+
+## 设置页
+
+`settings.section` 槽位注册（经 `ctx.slots.inject`），页面读真实目录：`ctx.remote.session.modelCatalog()` → Typert `{ ok, value }` → `{ groups[{ id, name, models[{ id, name, reasoning: { efforts[{ id, name }], defaultEffort } }] }] }`。
+
+- provider → model → effort 三级联动，只显示目录里真实存在的东西。
+- 保存走一次原子 `mutate(ops, revision)`，`SettingsPathOpView` 操作，带 revision fence。
+- 目录加载失败 → 显示错误、不给选项，此时只能关闭锁定。
+- 已保存的模型若已不可用 → 标「不可用」，**不自动替换**。
+- 关闭锁定时允许 provider/model 为空。
+
+设置服务存在时，插件会调 `settings.configure({ auto: false })` 隐藏官方自动生成的通用表单，保证设置页只有这一个入口；设置服务本身按**可选注入**处理（缺席时不报错，锁定照常工作）。
+
+已在独立 `DSH_HOME` + 端口 3199 的真实 Electron carrier 上跑通完整链路（真实 Loader 加载、Config 投影、`settings/update` 落盘、`currentSelection()` 拦截生效、官方配置零写入、解锁复原），结果见 [docs/INSTALL.md](docs/INSTALL.md) 第 6 节。
+
+## 目录
+
+```
+index.js               插件入口 + Config schema（volatile 字段）
+core.mjs               锁的实现（服务实例方法包装）
+lib/client.js          客户端产物：手写 __ModuleLoader__ 模块（无构建步骤）
+client/types.ts        真实 DSH 契约类型（参考，不参与安装）
+client/index.tsx       初稿的迁移记录（已废弃）
+test/core.test.mjs     后端 6 项：真 Cordis + 真 AgentDefaultModel
+test/client.test.mjs   前端 9 项：直接加载 lib/client.js
+scripts/install-profile.ps1    装进 profile（默认 dry-run，自动备份）
+scripts/restore-backup.ps1     按备份回滚（只删 junction，不删源码）
+scripts/isolation-probe.mjs    隔离验证探针（独立 DSH_HOME + 3199）
+docs/INSTALL.md        安装、边界与隔离验证结果
+```
+
+## 自检
+
+```bash
+npm run check   # node --check：骨架与产物语法
+npm test        # 15 项全绿
+```
+
+## 兼容性与边界
+
+目标 DSH 0.2.1-rc.2 / Cordis 4.0.5；升级 DSH 后需重新验证包装契约。**已经提交进原保存队列的写入无法撤销** —— 锁定生效前那一刻排队的那次保存仍会落盘；此外，别的插件若在包装前缓存了方法引用，也可能绕开包装。插件不改核心源码，也不采用「监听配置变化再写回」的方案。
+
+安装与实机验证见 [docs/INSTALL.md](docs/INSTALL.md)。

package/README_EN.md

@@ -0,0 +1,82 @@
+[![](https://img.shields.io/badge/powered_by-dafeiyu-4D6BFE?style=flat-square&logo=deepseek&logoColor=white)](https://github.com/Dafeiyu111)
+
+# Default Model Lock
+
+A shared-default-model lock for DeepSeek Harness. Pick a provider, a model and an optional reasoning effort in Settings, enable the lock, and the shared default stays pinned.
+
+Why it exists: switching the model once in the UI also rewrites the default in `cordis.yml` (and drops the `reasoningEffort` line), so heartbeats, scheduled board runs and new sessions silently change model too. This plugin makes that an explicit switch instead.
+
+## Install
+
+```powershell
+# Dry run first — writes nothing
+pwsh -File scripts/install-profile.ps1 -DryRun
+
+# Install into a profile (backs up package.json and cordis.patch.yml)
+pwsh -File scripts/install-profile.ps1 -Profile "$env:USERPROFILE\.dsh\profiles\desktop"
+```
+
+After reloading the plugin, a "Default Model Lock" section appears in Settings. Editing plugin
+sources requires a reload/restart of DSH — refreshing the page is not enough.
+Uninstall and restore steps: [docs/INSTALL.md](docs/INSTALL.md).
+
+## Behavior
+
+- **Chat model switching keeps working**: `session.selectModel()` still applies to the current session.
+- **The shared default cannot be moved**: `saveSelection()` is intercepted *before* it reaches the original save queue, and the call resolves without writing.
+- `currentSelection()` returns the exact configured selection, so new sessions, headless runs, heartbeats and scheduled tasks all read the locked value.
+- Disabling the lock restores official behavior and `unset`s provider/model, so the original default applies again. The plugin never rewrites the official default-model configuration.
+- An empty reasoning effort delegates to the adapter's per-model default.
+- An invalid provider/model **fails closed**: no guessing, no fallback, no write.
+- Effective only in profiles that load this plugin.
+
+## Where it intercepts
+
+It wraps `currentSelection()` and `saveSelection()` on the `@deepseek-ai/dsh-agent-default-model` service *instance*:
+
+- The original service object is recovered through Cordis `symbols.original`, and own methods are replaced on the instance, which covers plain `ctx` properties, `ctx.get()`, `root`, headless-shaped reads and already-cached service references.
+- No prototype edits, no disk writes, no model API calls.
+- Original descriptors are restored on disposal; the lock reinstalls itself when the service is rebuilt.
+
+## Settings page
+
+Registered on the `settings.section` slot through `ctx.slots.inject`, reading the real catalog: `ctx.remote.session.modelCatalog()` → Typert `{ ok, value }` → `{ groups[{ id, name, models[{ id, name, reasoning: { efforts[{ id, name }], defaultEffort } }] }] }`.
+
+- Linked provider → model → effort selects, listing only what the catalog actually contains.
+- One atomic `mutate(ops, revision)` per save, using `SettingsPathOpView` operations fenced by the namespace revision.
+- A failed catalog read shows the error and offers no options; with no catalog you can still disable the lock.
+- A stored model that is no longer available is labeled unavailable and **never auto-replaced**.
+- Disabling the lock allows an empty provider/model.
+
+When the settings service is present, the plugin calls `settings.configure({ auto: false })` to hide the official auto-generated generic form, so there is exactly one entry; the settings service itself is an **optional injection** (absent it does not fail, the lock keeps working).
+
+The full chain has been exercised on a real Electron carrier with an isolated `DSH_HOME` and port 3199 (real Loader load, Config projection, `settings/update` persistence, `currentSelection()` interception taking effect, zero writes to the official config, restore on unlock). See section 6 of [docs/INSTALL.md](docs/INSTALL.md).
+
+## Layout
+
+```
+index.js               entry point + Config schema (volatile fields)
+core.mjs               the lock (service-instance method wrapping)
+lib/client.js          client artifact: hand-written __ModuleLoader__ module
+client/types.ts        verified DSH contract types (reference only)
+client/index.tsx       migration notes for the abandoned draft
+test/core.test.mjs     6 backend tests: real Cordis + real AgentDefaultModel
+test/client.test.mjs   9 frontend tests: load lib/client.js directly
+scripts/install-profile.ps1    install into a profile (dry-run by default, auto-backup)
+scripts/restore-backup.ps1     rollback from backup (removes the junction only)
+scripts/isolation-probe.mjs    isolation probe (own DSH_HOME + port 3199)
+docs/INSTALL.md        install, limits, and isolation results
+```
+
+## Checks
+
+```bash
+npm run check   # node --check over the runtime and the client artifact
+npm test        # 15 tests, all green
+```
+
+## Compatibility and limits
+
+Built against DSH 0.2.1-rc.2 / Cordis 4.0.5; the wrapping contract must be re-verified after a DSH upgrade. **Writes already queued in the original save queue cannot be withdrawn** — a save submitted just before the lock engages still lands. A plugin that cached an independent method reference before wrapping may also bypass it. No core source edits, and no watch-then-rewrite scheme.
+
+Installation and on-device verification: [docs/INSTALL.md](docs/INSTALL.md).

package/cordis.patch.yml

@@ -0,0 +1,8 @@
+- insert:
+    - id: default-model-lock
+      name: dsh-default-model-lock
+      config:
+        enabled: false
+        provider: ''
+        model: ''
+        reasoningEffort: ''

package/core.mjs

@@ -0,0 +1,79 @@
+// Runtime-only lock: no profile writes and no model selection requests.
+export function readPolicy(config) {
+  const read = (key) => {
+    const value = config[key];
+    return value && typeof value.get === 'function' ? value.get() : value;
+  };
+  const enabled = read('enabled');
+  if (typeof enabled !== 'boolean') throw new TypeError('default-model-lock: enabled must be boolean');
+  if (!enabled) return { enabled: false };
+  const provider = read('provider');
+  const model = read('model');
+  const effort = read('reasoningEffort');
+  for (const [key, value] of [['provider', provider], ['model', model]]) {
+    if (typeof value !== 'string' || !value.trim() || value !== value.trim()) {
+      throw new TypeError(`default-model-lock: ${key} must be a non-empty, trimmed string`);
+    }
+  }
+  if (typeof effort !== 'string' || effort !== effort.trim()) {
+    throw new TypeError('default-model-lock: reasoningEffort must be a trimmed string (empty means omitted)');
+  }
+  return { enabled: true, selection: { provider, model, ...(effort === '' ? {} : { reasoningEffort: effort }) } };
+}
+
+const installations = new WeakMap();
+
+export function installLock(ctx, config, originalSymbol) {
+  const service = ctx.get('agentDefaultModel');
+  if (!service) throw new Error('default-model-lock: agentDefaultModel is unavailable');
+  const target = service[originalSymbol] ?? service;
+  if (installations.has(target)) throw new Error('default-model-lock: another lock owns this service');
+  const keys = ['currentSelection', 'saveSelection'];
+  const descriptors = new Map(keys.map((key) => [key, Object.getOwnPropertyDescriptor(target, key)]));
+  const original = Object.fromEntries(keys.map((key) => [key, target[key]]));
+  for (const key of keys) {
+    if (typeof original[key] !== 'function') throw new TypeError(`default-model-lock: missing ${key}`);
+    const descriptor = descriptors.get(key);
+    if (descriptor && !descriptor.configurable) throw new TypeError(`default-model-lock: ${key} is not configurable`);
+  }
+  if (!Object.isExtensible(target)) throw new TypeError('default-model-lock: service is not extensible');
+  let active = true;
+  const wrappers = {
+    currentSelection: function (...args) {
+      if (!active) return Reflect.apply(original.currentSelection, this, args);
+      const policy = readPolicy(config);
+      return policy.enabled ? { ...policy.selection } : Reflect.apply(original.currentSelection, this, args);
+    },
+    saveSelection: async function (...args) {
+      if (!active) return Reflect.apply(original.saveSelection, this, args);
+      const policy = readPolicy(config);
+      if (!policy.enabled) return Reflect.apply(original.saveSelection, this, args);
+      // Intentionally never enter the original serialized save queue while locked.
+    },
+  };
+  const token = {};
+  installations.set(target, token);
+  const dispose = () => {
+    if (!active) return;
+    active = false;
+    for (const key of keys) {
+      // Do not clobber a later third-party patch.
+      if (Object.getOwnPropertyDescriptor(target, key)?.value !== wrappers[key]) continue;
+      const descriptor = descriptors.get(key);
+      if (descriptor) Object.defineProperty(target, key, descriptor);
+      else delete target[key];
+    }
+    if (installations.get(target) === token) installations.delete(target);
+  };
+  try {
+    for (const key of keys) Object.defineProperty(target, key, {
+      configurable: true, writable: true, enumerable: descriptors.get(key)?.enumerable ?? false,
+      value: wrappers[key],
+    });
+    ctx.effect(() => dispose);
+  } catch (error) {
+    dispose();
+    throw error;
+  }
+  return dispose;
+}

package/docs/INSTALL.md

@@ -0,0 +1,101 @@
+# 安装与验证
+
+目标环境：DSH 0.2.1-rc.2、Cordis 4.0.5。插件目录：`~/.deepseek harness/dsh-default-model-lock`。
+
+## 1. 没有构建步骤
+
+客户端产物 `lib/client.js` 是**手写**模块，启动时就带 `window.__ModuleLoader__.load({ id, inject, apply, factory })` 封装。页面用这个 envelope 收客户端插件，`factory(require)` 的 `require` 只能解析已声明的注入包，所以 esbuild 输出的 ESM 无法注册自己 —— 本插件不做打包。
+
+`client/index.tsx`、`client/types.ts` 只作类型参考与迁移记录，不参与安装（`package.json` 的 `files` 也不含 `client/`）。
+
+## 2. 装进 profile
+
+插件通过 `link:` 依赖 + `cordis.patch.yml` 进入 profile：
+
+```yaml
+# cordis.patch.yml（随包发布）
+- insert:
+    - id: default-model-lock
+      name: dsh-default-model-lock
+      config:
+        enabled: false
+        provider: ''
+        model: ''
+        reasoningEffort: ''
+```
+
+在目标 profile 目录（例如 `~/.dsh/profiles/desktop`）里：
+
+```bash
+# 1) 把插件目录挂进 profile 的 node_modules（不要复制，改源码后重载即生效）
+#    在 <profile>/package.json 里加依赖："dsh-default-model-lock": "link:<插件绝对路径>"
+# 2) 确认 profile 的 cordis.patch.yml 已包含上面的 insert 段
+```
+
+重载插件后，设置页出现「默认模型锁定」一节。修改插件源码后必须重载/重启 DSH 才生效，刷新页面不够。
+
+### 用脚本装 / 回滚
+
+```powershell
+# 先看会做什么（不写任何文件）
+pwsh -File scripts/install-profile.ps1 -DryRun
+
+# 真装：自动备份 package.json 与 cordis.patch.yml 到 .install-backup/<时间戳>/
+pwsh -File scripts/install-profile.ps1 -Profile "$env:USERPROFILE\.dsh\profiles\desktop"
+
+# 回滚：还原两个文件，并只删除 junction（不删插件源码目录）
+pwsh -File scripts/restore-backup.ps1 -Profile "$env:USERPROFILE\.dsh\profiles\desktop" -BackupDir "<.install-backup 里的时间戳目录>"
+```
+
+脚本幂等：依赖已指向同一路径、patch 已含条目时跳过，不重复插入。
+
+## 3. 自检（无需启动 DSH）
+
+```bash
+cd "~/.deepseek harness/dsh-default-model-lock"
+npm run check     # node --check：index.js / core.mjs / lib/client.js
+npm test          # 15 项：后端 6 项（真 Cordis + 真 AgentDefaultModel）+ 前端 9 项
+```
+
+前端测试用 `vm.runInThisContext` 加载真实的 `lib/client.js`，注入假的 `window.__ModuleLoader__`、`react`、`ctx`，因此测的是发布产物本身，不是它的副本。
+
+## 4. 实机验证清单
+
+1. 设置页 → 默认模型锁定 → 选出 provider / model（有 reasoning 的模型再选档位）→ 启用 → 保存。保存只发一次 `mutate`。
+2. 聊天里切换模型：只改本会话；再看默认模型锁定的已保存值未被改写。
+3. 新开会话：默认模型是锁定值。
+4. 关闭锁定并保存：`enabled=false` 且 provider/model 被 `unset`，官方默认值恢复。
+5. 把 provider 或 model 改成一个目录里不存在的值：页面显示「不可用」，不自动替换；启用状态下保存被拒。
+6. 断开 Host 后打开设置页：显示目录加载错误，不出现任何伪造选项；此时仍可关闭锁定并保存。
+
+## 5. 已知边界
+
+- 插件在服务实例上包装 `currentSelection()` / `saveSelection()`，不改 prototype、不改磁盘、不调用模型接口。
+- **已经排进原服务保存队列的写入无法撤销**：锁定生效前提交、尚未落盘的那一次保存仍会完成。
+- 其他插件若在包装前缓存了方法的独立引用，可能绕过包装；通过 `ctx.agentDefaultModel`、`ctx.get('agentDefaultModel')`、`root.agentDefaultModel` 读取仍被覆盖。
+- 只在加载了本插件的 profile/进程内生效。
+- `settings` 采用可选注入：设置服务缺席时插件照常加载、锁定照常工作，只是不会隐藏官方自动生成的通用表单。因此设置页出现「两个入口」只会在 settings 不可用时发生。
+
+## 6. 隔离运行验证（2026-10-20 实测）
+
+用独立 `DSH_HOME` + 独立端口 3199 跑真实 Electron carrier，**不碰生产 profile**：
+
+```powershell
+node scripts/isolation-probe.mjs prepare    # 新建 .sandbox（已存在则拒绝覆盖）
+node scripts/isolation-probe.mjs app-help   # 只打印 CLI 帮助
+node scripts/isolation-probe.mjs start      # 前台起 127.0.0.1:3199（需手动 Ctrl+C）
+```
+
+实测结论（`settings/describe` 与 `session/modelCatalog` RPC，隔离实例内）：
+
+| 项 | 结果 |
+| --- | --- |
+| 插件被真实 Loader 加载 | ✅ `settings.describe` 的 22 个 ns 里有 `default-model-lock` |
+| Config 投影 | ✅ `enabled/provider/model/reasoningEffort` 四字段，默认全空/关闭，`applies: live` |
+| 自动页去重 | ✅ `autoGenerate: false`（自定义设置页唯一入口） |
+| 设置写入链路 | ✅ `settings/update` 落 `user` 段，revision 0→1，同时 `value` 立即生效 |
+| `currentSelection()` 拦截 | ✅ 锁到 `probe-provider/probe-model` 后，`session/modelCatalog` 的 `default` 从 `deepseek-official/deepseek-flash` 变为 `probe-provider/probe-model` |
+| 官方配置零写入 | ✅ `agent-default-model` ns 全程 `revision: 0`、值保持官方默认 |
+| 解锁复原 | ✅ 关闭锁定后 `default` 回到 `deepseek-official/deepseek-flash` |
+
+未覆盖：`saveSelection()` 被拦截后的具体落盘结果，因为隔离实例无凭据，`session/initializeDefaultModel` 在进入保存前就以 `provider "deepseek-account" has no available models` 退出；该行为的等价验证见 `test/core.test.mjs` 的 6 项真 Cordis 测试。

package/index.js

@@ -0,0 +1,21 @@
+import z from '@deepseek-ai/schemastery';
+import { symbols } from '@deepseek-ai/cordis';
+import { installLock } from './core.mjs';
+
+export const name = 'default-model-lock';
+export const inject = ['agentDefaultModel'];
+export const Config = z.object({
+  enabled: z.boolean().default(false).description('锁定全局默认模型；不改变已有会话的显式模型').volatile(),
+  provider: z.string().default('').description('精确 provider ID；启用时不能为空').volatile(),
+  model: z.string().default('').description('精确 model ID；不会自动选择替代模型').volatile(),
+  reasoningEffort: z.string().default('').description('推理档位；留空则省略，使用模型默认').volatile(),
+});
+
+export function apply(ctx, config) {
+  installLock(ctx, config, symbols.original);
+  // 自定义设置页已承载这四个字段；settings 可选注入，拿到时才隐藏 Loader 自动生成的通用表单，
+  // 不把它写进 inject，避免 settings 缺席时整个插件挂起、锁定也不生效。
+  ctx.inject(['settings'], (child) => {
+    child.effect(() => child.settings.configure({ auto: false }, ctx.fiber));
+  });
+}

package/lib/client.js

@@ -0,0 +1,649 @@
+/**
+ * Browser half of dsh-default-model-lock.
+ *
+ * Written directly in the loader format every shipped client bundle uses
+ * (`window.__ModuleLoader__.load`), so the artifact needs no bundler: the id is
+ * the package name, React comes from the browser module table, and the returned
+ * object carries `inject` and `apply` like any other Client plugin.
+ *
+ * Contracts this file obeys (dsh 0.2.1-rc.2 / cordis 4.0.5):
+ * - settings registration goes through `ctx.slots.inject('settings.section', …)`
+ *   wrapping `ctx.slots.register({ name, id, order, label, inject }, Component)`;
+ * - the model list is `ctx.remote.session.modelCatalog()`, which answers a
+ *   Typert wrapper (`{ ok: true, value: ModelCatalog }`), not a catalog itself;
+ * - writes go through `ConfigForm.mutate(ops, expectedRevision)` once per save,
+ *   with `SettingsPathOpView` operations, never `set(wholeObject)`.
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-default-model-lock',
+  factory(require) {
+    'use strict';
+
+    const React = require('react');
+    const h = React.createElement;
+    const { useState, useEffect, useMemo } = React;
+
+    /** Settings section identity; the order puts it right after Models. */
+    const SECTION_ID = 'default-model-lock';
+    // Shipped settings sections use 0/10/20/30/100/…; 25 keeps this page unique
+    // so its nav position never depends on registration order.
+    const SECTION_ORDER = 25;
+    const SECTION_LABEL = '默认模型锁';
+    /** Settings namespace === Host plugin entry id declared by cordis.patch.yml. */
+    const NAMESPACE = 'default-model-lock';
+    /** Fields this plugin's Config schema declares. */
+    const FIELD_KEYS = ['enabled', 'provider', 'model', 'reasoningEffort'];
+
+    const EMPTY_CONFIG = Object.freeze({ enabled: false, provider: '', model: '', reasoningEffort: '' });
+
+    // ---------------------------------------------------------------------
+    // Pure view-model helpers (exported through `__internals` for the tests).
+    // ---------------------------------------------------------------------
+
+    /** Coerce an unknown wire field to a string. */
+    function text(value) {
+      return typeof value === 'string' ? value : '';
+    }
+
+    /** Narrow a settings section (or nothing) to this plugin's four fields. */
+    function normalizeConfig(value) {
+      const source = value !== null && typeof value === 'object' ? value : {};
+      return {
+        enabled: source.enabled === true,
+        provider: text(source.provider),
+        model: text(source.model),
+        reasoningEffort: text(source.reasoningEffort),
+      };
+    }
+
+    /** @returns provider groups from a ModelCatalog, tolerating a missing catalog. */
+    function groupsOf(catalog) {
+      const value = catalog !== null && typeof catalog === 'object' ? catalog.value : undefined;
+      const groups = value !== null && typeof value === 'object' ? value.groups : undefined;
+      return Array.isArray(groups) ? groups.filter((group) => group !== null && typeof group === 'object') : [];
+    }
+
+    /** @returns one provider group by id, or undefined. */
+    function findGroup(catalog, providerId) {
+      if (!providerId) return undefined;
+      return groupsOf(catalog).find((group) => group.id === providerId);
+    }
+
+    /** @returns the models of one provider, in catalog order. */
+    function modelsOf(catalog, providerId) {
+      const group = findGroup(catalog, providerId);
+      return group !== undefined && Array.isArray(group.models) ? group.models.filter((model) => model !== null && typeof model === 'object') : [];
+    }
+
+    /** @returns one model entry by provider id and model id, or undefined. */
+    function findModel(catalog, providerId, modelId) {
+      if (!modelId) return undefined;
+      return modelsOf(catalog, providerId).find((model) => model.id === modelId);
+    }
+
+    /** @returns the adapter-owned reasoning efforts of one model (`reasoning.efforts`). */
+    function effortOptionsOf(model) {
+      const reasoning = model !== null && typeof model === 'object' ? model.reasoning : undefined;
+      const efforts = reasoning !== null && typeof reasoning === 'object' ? reasoning.efforts : undefined;
+      if (!Array.isArray(efforts)) return [];
+      return efforts
+        .filter((effort) => effort !== null && typeof effort === 'object' && typeof effort.id === 'string')
+        .map((effort) => ({ id: effort.id, name: text(effort.name) || effort.id, description: text(effort.description) }));
+    }
+
+    /** @returns provider select options built from the live catalog. */
+    function providerOptions(catalog) {
+      return groupsOf(catalog).map((group) => ({ value: group.id, label: text(group.name) || group.id }));
+    }
+
+    /** @returns model select options for one provider. */
+    function modelOptions(catalog, providerId) {
+      return modelsOf(catalog, providerId).map((model) => ({ value: model.id, label: text(model.name) || model.id }));
+    }
+
+    /** @returns effort select options for one exact model route. */
+    function effortOptions(catalog, providerId, modelId) {
+      return effortOptionsOf(findModel(catalog, providerId, modelId)).map((effort) => ({ value: effort.id, label: effort.name, description: effort.description }));
+    }
+
+    /**
+     * Describe whether a selection still exists in the live catalog. Never
+     * substitutes another model: a stale saved value stays visible as stale.
+     * @returns `{ state, text }` where state is available|provider|model|effort|unknown.
+     */
+    function describeAvailability(catalog, selection) {
+      if (catalog === null || typeof catalog !== 'object' || catalog.status !== 'ready' || !catalog.value) {
+        return { state: 'unknown', text: '模型目录尚未就绪，暂时无法确认它是否可用。' };
+      }
+      const group = findGroup(catalog, selection.provider);
+      if (group === undefined) {
+        return { state: 'provider', text: `provider「${selection.provider || '（空）'}」当前不在模型目录中。` };
+      }
+      const model = findModel(catalog, selection.provider, selection.model);
+      if (model === undefined) {
+        return { state: 'model', text: `模型「${selection.model || '（空）'}」当前不可用。` };
+      }
+      if (selection.reasoningEffort) {
+        const efforts = effortOptionsOf(model);
+        if (!efforts.some((effort) => effort.id === selection.reasoningEffort)) {
+          return { state: 'effort', text: `模型「${text(model.name) || model.id}」没有推理档位「${selection.reasoningEffort}」。` };
+        }
+      }
+      return { state: 'available', text: '' };
+    }
+
+    /**
+     * Build the single atomic write for a draft, or refuse it.
+     * Refusing is the fail-closed branch: an enabled lock never falls back to
+     * another model, and it is never written from a catalog we could not read.
+     * @returns `{ ok: true, ops }` or `{ ok: false, message }`.
+     */
+    function planSave(draft, catalog, saved) {
+      const current = normalizeConfig(saved);
+      const next = normalizeConfig(draft);
+      if (!next.enabled) {
+        // Disabling the lock is always allowed, with empty provider/model.
+        const ops = [];
+        if (current.enabled !== false) ops.push({ op: 'set', path: ['enabled'], value: false });
+        if (current.provider !== '') ops.push({ op: 'unset', path: ['provider'] });
+        if (current.model !== '') ops.push({ op: 'unset', path: ['model'] });
+        if (current.reasoningEffort !== '') ops.push({ op: 'unset', path: ['reasoningEffort'] });
+        return { ok: true, ops };
+      }
+      if (catalog === null || typeof catalog !== 'object' || catalog.status !== 'ready' || !catalog.value) {
+        return { ok: false, message: '模型目录未就绪，启用锁定必须先读到真实目录（不会猜测模型）。可以先关闭锁定后保存。' };
+      }
+      const provider = next.provider.trim();
+      const model = next.model.trim();
+      const effort = next.reasoningEffort.trim();
+      if (provider === '') return { ok: false, message: '启用锁定必须先选择一个 provider。' };
+      if (model === '') return { ok: false, message: '启用锁定必须先选择一个 model。' };
+      if (findGroup(catalog, provider) === undefined) return { ok: false, message: `provider「${provider}」不在当前模型目录中。` };
+      const entry = findModel(catalog, provider, model);
+      if (entry === undefined) return { ok: false, message: `模型「${model}」不属于 provider「${provider}」。` };
+      if (effort !== '' && !effortOptionsOf(entry).some((option) => option.id === effort)) {
+        return { ok: false, message: `模型「${model}」没有推理档位「${effort}」。` };
+      }
+      const ops = [
+        { op: 'set', path: ['enabled'], value: true },
+        { op: 'set', path: ['provider'], value: provider },
+        { op: 'set', path: ['model'], value: model },
+        effort === '' ? { op: 'unset', path: ['reasoningEffort'] } : { op: 'set', path: ['reasoningEffort'], value: effort },
+      ];
+      return { ok: true, ops };
+    }
+
+    /** @returns a readable message for a rejected Typert response or thrown value. */
+    function errorText(error) {
+      if (error === null || error === undefined) return '未知错误';
+      if (typeof error === 'string') return error;
+      const message = typeof error.message === 'string' ? error.message : '';
+      return message || String(error);
+    }
+
+    /** @returns the failure message of a `{ ok: false, error }` response. */
+    function failureMessage(response) {
+      const failure = response !== null && typeof response === 'object' ? response.error : undefined;
+      return errorText(failure !== undefined ? failure : response);
+    }
+
+    /** @returns whether a namespace schema declares this plugin's fields. */
+    function looksLikeThisPlugin(schema) {
+      let serialized;
+      try {
+        serialized = JSON.stringify(schema);
+      } catch {
+        return false;
+      }
+      if (typeof serialized !== 'string') return false;
+      return FIELD_KEYS.every((key) => serialized.includes(key));
+    }
+
+    // ---------------------------------------------------------------------
+    // Store shared by the section component.
+    // ---------------------------------------------------------------------
+
+    /**
+     * Owns the ConfigForm subscription, the live catalog read, and the draft.
+     * @param ctx - client root context carrying `configForms` and `remote`.
+     */
+    function createStore(ctx) {
+      let state = {
+        phase: 'loading',
+        writable: false,
+        revision: undefined,
+        config: EMPTY_CONFIG,
+        draft: EMPTY_CONFIG,
+        dirty: false,
+        saving: false,
+        notice: null,
+        catalog: { status: 'idle', value: null, error: null },
+      };
+      const listeners = new Set();
+      let form;
+      let detachForm = null;
+      let catalogLoading = false;
+      let disposed = false;
+
+      const getState = () => state;
+
+      const put = (patch) => {
+        if (disposed) return;
+        state = Object.assign({}, state, patch);
+        for (const listener of listeners) {
+          try {
+            listener();
+          } catch (error) {
+            console.error('default-model-lock: listener failed', error);
+          }
+        }
+      };
+
+      const subscribe = (listener) => {
+        listeners.add(listener);
+        return () => {
+          listeners.delete(listener);
+        };
+      };
+
+      /** Re-read the Host form snapshot into state, keeping an edited draft. */
+      const syncForm = () => {
+        if (!form) return;
+        const snapshot = form.getSnapshot();
+        const status = snapshot !== null && typeof snapshot === 'object' ? snapshot.status : undefined;
+        const config = normalizeConfig(snapshot !== null && typeof snapshot === 'object' ? snapshot.value : undefined);
+        const patch = {
+          phase: status === 'ready' ? 'ready' : status === 'unavailable' ? 'unavailable' : 'loading',
+          writable: snapshot !== null && typeof snapshot === 'object' && snapshot.writable === true,
+          revision: snapshot !== null && typeof snapshot === 'object' ? snapshot.revision : undefined,
+          config,
+        };
+        if (!state.dirty) patch.draft = config;
+        put(patch);
+      };
+
+      const attach = (namespace) => {
+        if (detachForm) {
+          detachForm();
+          detachForm = null;
+        }
+        form = ctx.configForms.get(namespace);
+        syncForm();
+        detachForm = form !== null && typeof form === 'object' && typeof form.subscribe === 'function' ? form.subscribe(syncForm) : null;
+      };
+
+      /** Fall back to a describe scan when the entry id is not the expected one. */
+      const watchDescribe = () => {
+        const face = typeof ctx.configForms.describe === 'function' ? ctx.configForms.describe() : undefined;
+        if (!face || typeof face.ensure !== 'function') return;
+        Promise.resolve()
+          .then(() => face.ensure())
+          .then(() => {
+            if (disposed || state.phase === 'ready') return;
+            const snapshot = face.getSnapshot();
+            const view = snapshot !== null && typeof snapshot === 'object' ? snapshot.view : undefined;
+            const namespaces = view !== null && typeof view === 'object' && Array.isArray(view.namespaces) ? view.namespaces : [];
+            if (namespaces.some((entry) => entry !== null && typeof entry === 'object' && entry.ns === NAMESPACE)) {
+              if (state.phase !== 'ready') attach(NAMESPACE);
+              return;
+            }
+            const match = namespaces.find((entry) => entry !== null && typeof entry === 'object' && looksLikeThisPlugin(entry.schema));
+            if (match !== undefined) attach(match.ns);
+          })
+          .catch((error) => {
+            console.warn('default-model-lock: settings describe scan failed', error);
+          });
+      };
+
+      /** Read the live model catalog through the session remote face. */
+      const loadCatalog = async () => {
+        if (disposed || catalogLoading) return;
+        catalogLoading = true;
+        put({ catalog: { status: 'loading', value: state.catalog.value, error: null } });
+        try {
+          const response = await ctx.remote.session.modelCatalog();
+          if (!response || response.ok !== true) throw new Error(failureMessage(response));
+          put({ catalog: { status: 'ready', value: response.value, error: null } });
+        } catch (error) {
+          put({ catalog: { status: 'error', value: null, error: errorText(error) } });
+        } finally {
+          catalogLoading = false;
+        }
+      };
+
+      /** Load the catalog once, on first render. */
+      const ensureCatalog = () => {
+        if (state.catalog.status !== 'idle') return;
+        void loadCatalog();
+      };
+
+      /** Re-read the catalog on demand. */
+      const refreshCatalog = async () => {
+        if (catalogLoading) return;
+        await loadCatalog();
+      };
+
+      /** Edit the draft, keeping provider → model → effort consistent. */
+      const setDraft = (patch) => {
+        const next = Object.assign({}, state.draft);
+        if (Object.prototype.hasOwnProperty.call(patch, 'enabled')) next.enabled = patch.enabled === true;
+        if (Object.prototype.hasOwnProperty.call(patch, 'provider')) {
+          const value = text(patch.provider);
+          if (value !== next.provider) {
+            next.provider = value;
+            next.model = '';
+            next.reasoningEffort = '';
+          }
+        }
+        if (Object.prototype.hasOwnProperty.call(patch, 'model')) {
+          const value = text(patch.model);
+          if (value !== next.model) {
+            next.model = value;
+            const efforts = effortOptionsOf(findModel(state.catalog, next.provider, value));
+            if (!efforts.some((effort) => effort.id === next.reasoningEffort)) next.reasoningEffort = '';
+          }
+        }
+        if (Object.prototype.hasOwnProperty.call(patch, 'reasoningEffort')) next.reasoningEffort = text(patch.reasoningEffort);
+        put({ draft: next, dirty: true, notice: null });
+      };
+
+      /** Discard the draft. */
+      const resetDraft = () => {
+        put({ draft: state.config, dirty: false, notice: null });
+      };
+
+      /** Write the draft as one atomic namespace mutation. */
+      const save = async () => {
+        if (!form || state.saving) return false;
+        const plan = planSave(state.draft, state.catalog, state.config);
+        if (!plan.ok) {
+          put({ notice: { kind: 'error', text: plan.message } });
+          return false;
+        }
+        if (plan.ops.length === 0) {
+          put({ dirty: false, notice: { kind: 'info', text: '没有需要保存的改动。' } });
+          return true;
+        }
+        put({ saving: true, notice: null });
+        try {
+          const accepted = await form.mutate(plan.ops, state.revision);
+          put({ saving: false });
+          if (accepted === true) {
+            put({ dirty: false });
+            syncForm();
+            put({ notice: { kind: 'success', text: '已保存：共享默认模型立即生效，无需重启。' } });
+            return true;
+          }
+          put({ notice: { kind: 'error', text: 'Host 拒绝或跳过了这次写入（配置可能已被别处修改），请刷新后重试。' } });
+          return false;
+        } catch (error) {
+          put({ saving: false, notice: { kind: 'error', text: errorText(error) } });
+          return false;
+        }
+      };
+
+      attach(NAMESPACE);
+      if (state.phase !== 'ready') watchDescribe();
+
+      return {
+        getState,
+        subscribe,
+        ensureCatalog,
+        refreshCatalog,
+        setDraft,
+        resetDraft,
+        save,
+        dispose() {
+          disposed = true;
+          if (detachForm) detachForm();
+          detachForm = null;
+          listeners.clear();
+        },
+      };
+    }
+
+    // ---------------------------------------------------------------------
+    // Rendering.
+    // ---------------------------------------------------------------------
+
+    const styles = {
+      root: { display: 'grid', gap: 16, maxWidth: 680, padding: '4px 0 24px', color: 'var(--dsw-alias-label-primary, inherit)', fontSize: 14, lineHeight: 1.55 },
+      title: { margin: 0, fontSize: 18, fontWeight: 600 },
+      description: { margin: 0, color: 'var(--dsw-alias-label-secondary, #666)' },
+      card: {
+        display: 'grid',
+        gap: 12,
+        padding: 16,
+        border: '1px solid var(--dsw-alias-settings-card-stroke, var(--dsw-alias-border-l3, #d8d8d8))',
+        borderRadius: 'var(--dsw-radius-md, 8px)',
+        background: 'var(--dsw-alias-settings-card-fill, transparent)',
+      },
+      row: { display: 'grid', gap: 6 },
+      label: { fontWeight: 600, color: 'var(--dsw-alias-label-primary, inherit)' },
+      help: { color: 'var(--dsw-alias-label-tertiary, #888)', fontSize: 12 },
+      select: {
+        minHeight: 34,
+        padding: '6px 8px',
+        borderRadius: 'var(--dsw-radius-sm, 6px)',
+        border: '1px solid var(--dsw-alias-border-l3, #d8d8d8)',
+        background: 'transparent',
+        color: 'inherit',
+        font: 'inherit',
+      },
+      actions: { display: 'flex', alignItems: 'center', gap: 12, flexWrap: 'wrap' },
+      button: {
+        minHeight: 34,
+        padding: '6px 18px',
+        borderRadius: 'var(--dsw-radius-sm, 6px)',
+        border: '1px solid var(--dsw-alias-border-l3, #d8d8d8)',
+        background: 'transparent',
+        color: 'inherit',
+        font: 'inherit',
+        cursor: 'pointer',
+      },
+      error: { color: 'var(--dsw-alias-state-error-primary, #c0392b)', fontSize: 13 },
+      warn: { color: 'var(--dsw-alias-state-warn-label, #a06000)', fontSize: 13 },
+      success: { color: 'var(--dsw-alias-state-success-primary, #1f7a3d)', fontSize: 13 },
+      info: { color: 'var(--dsw-alias-label-secondary, #666)', fontSize: 13 },
+      mono: { fontFamily: 'var(--ds-font-family-code, monospace)', fontSize: 12 },
+    };
+
+    const NOTICE_STYLE = { error: styles.error, success: styles.success, info: styles.info };
+
+    /** Subscribe a component to the store without pulling in an extra hook library. */
+    function useStoreState(store) {
+      const [snapshot, setSnapshot] = useState(() => store.getState());
+      useEffect(() => {
+        setSnapshot(store.getState());
+        return store.subscribe(() => setSnapshot(store.getState()));
+      }, [store]);
+      return snapshot;
+    }
+
+    function Field(props) {
+      return h('div', { style: styles.row }, h('span', { style: styles.label }, props.label), props.children, props.help ? h('span', { style: styles.help }, props.help) : null);
+    }
+
+    function Select(props) {
+      return h(
+        'select',
+        {
+          style: styles.select,
+          value: props.value,
+          disabled: props.disabled === true,
+          'aria-label': props.ariaLabel,
+          onChange: (event) => props.onChange(event.target.value),
+        },
+        props.options.map((option) => h('option', { key: option.value, value: option.value }, option.label)),
+      );
+    }
+
+    function Notice(props) {
+      if (!props.notice) return null;
+      return h('span', { style: NOTICE_STYLE[props.notice.kind] || styles.info, role: props.notice.kind === 'error' ? 'alert' : undefined }, props.notice.text);
+    }
+
+    function DefaultModelLockSection(props) {
+      const store = props.store;
+      const state = useStoreState(store);
+      useEffect(() => {
+        store.ensureCatalog();
+      }, [store]);
+
+      const draft = state.draft;
+      const plan = useMemo(() => planSave(draft, state.catalog, state.config), [draft, state.catalog, state.config]);
+      const providers = providerOptions(state.catalog);
+      const models = modelOptions(state.catalog, draft.provider);
+      const efforts = effortOptions(state.catalog, draft.provider, draft.model);
+      const catalogStatus = state.catalog.status;
+      const savedAvailability = describeAvailability(state.catalog, state.config);
+      const showSavedWarning = state.config.enabled && savedAvailability.state !== 'available' && savedAvailability.state !== 'unknown';
+      const busy = state.saving;
+      const canEdit = state.writable && state.phase === 'ready';
+      const canSave = canEdit && !busy && plan.ok && (state.dirty || plan.ops.length > 0);
+
+      const catalogBlock = [];
+      if (catalogStatus === 'idle' || catalogStatus === 'loading') {
+        catalogBlock.push(h('span', { key: 'loading', style: styles.info }, '正在读取模型目录…'));
+      } else if (catalogStatus === 'error') {
+        catalogBlock.push(h('div', { key: 'error', style: styles.error, role: 'alert' }, `模型目录加载失败：${state.catalog.error}`));
+        catalogBlock.push(h('span', { key: 'error-hint', style: styles.help }, '这里不会伪造选项。可以重试读取，或先关闭锁定再保存。'));
+      } else if (providers.length === 0) {
+        catalogBlock.push(h('span', { key: 'empty', style: styles.warn }, '模型目录里没有任何可用 provider。'));
+      } else {
+        catalogBlock.push(
+          h(
+            Field,
+            { key: 'provider', label: 'Provider' },
+            h(Select, {
+              ariaLabel: 'Provider',
+              value: draft.provider,
+              disabled: !canEdit || busy,
+              options: [{ value: '', label: '请选择 provider' }].concat(providers),
+              onChange: (value) => store.setDraft({ provider: value }),
+            }),
+          ),
+          h(
+            Field,
+            { key: 'model', label: 'Model', help: draft.provider === '' ? '先选择 provider。' : undefined },
+            h(Select, {
+              ariaLabel: 'Model',
+              value: draft.model,
+              disabled: !canEdit || busy || draft.provider === '' || models.length === 0,
+              options: [{ value: '', label: models.length === 0 ? '该 provider 没有可选模型' : '请选择 model' }].concat(models),
+              onChange: (value) => store.setDraft({ model: value }),
+            }),
+          ),
+          h(
+            Field,
+            {
+              key: 'effort',
+              label: 'Reasoning effort',
+              help: draft.model === '' ? '先选择 model。' : efforts.length === 0 ? '该模型没有声明 reasoning.efforts，将使用模型默认档位。' : '留空表示使用模型默认档位。',
+            },
+            h(Select, {
+              ariaLabel: 'Reasoning effort',
+              value: draft.reasoningEffort,
+              disabled: !canEdit || busy || efforts.length === 0,
+              options: [{ value: '', label: '模型默认' }].concat(efforts),
+              onChange: (value) => store.setDraft({ reasoningEffort: value }),
+            }),
+          ),
+        );
+      }
+
+      return h(
+        'section',
+        { style: styles.root, 'data-dsh-plugin': 'dsh-default-model-lock', 'aria-label': SECTION_LABEL },
+        h('h2', { style: styles.title }, SECTION_LABEL),
+        h('p', { style: styles.description }, '锁定共享默认模型：新会话、headless、心跳与定时任务都从这里取值；在聊天里手动切换模型仍只影响当前会话，不会改写这个默认值。'),
+        state.phase === 'unavailable'
+          ? h('div', { style: styles.error, role: 'alert' }, `没有找到 settings 命名空间「${NAMESPACE}」，请确认插件已随 profile 加载。`)
+          : null,
+        state.phase !== 'unavailable' && state.writable !== true
+          ? h('div', { style: styles.warn }, '当前 profile 是只读的，无法保存。')
+          : null,
+        h(
+          'div',
+          { style: styles.card },
+          h(
+            Field,
+            {
+              label: '启用锁定',
+              help: '启用时必须从真实目录里选好 provider 与 model；关闭后默认模型回到 composition 里的值。',
+            },
+            h('input', {
+              type: 'checkbox',
+              checked: draft.enabled,
+              disabled: !canEdit || busy,
+              onChange: (event) => store.setDraft({ enabled: event.target.checked }),
+            }),
+          ),
+          h('div', { style: styles.row }, catalogBlock),
+          showSavedWarning ? h('div', { style: styles.warn }, `已保存的默认模型当前不可用（不会自动替换）：${savedAvailability.text}`) : null,
+          showSavedWarning || draft.reasoningEffort === '' ? null : h('span', { style: styles.help }, `将写入：${draft.provider} / ${draft.model} / ${draft.reasoningEffort}`),
+        ),
+        h(
+          'div',
+          { style: styles.actions },
+          h(
+            'button',
+            {
+              type: 'button',
+              style: canSave ? styles.button : Object.assign({}, styles.button, { cursor: 'not-allowed', opacity: 0.6 }),
+              disabled: !canSave,
+              onClick: () => void store.save(),
+            },
+            busy ? '保存中…' : '保存',
+          ),
+          h(
+            'button',
+            { type: 'button', style: styles.button, disabled: !canEdit || busy || !state.dirty, onClick: () => store.resetDraft() },
+            '重置',
+          ),
+          h('button', { type: 'button', style: styles.button, disabled: busy || catalogStatus === 'loading', onClick: () => void store.refreshCatalog() }, '刷新目录'),
+          plan.ok === false ? h('span', { style: styles.warn }, plan.message) : null,
+          plan.ok === true && plan.ops.length > 0 ? h('span', { style: styles.mono }, `${plan.ops.length} 项变更待提交`) : null,
+          h(Notice, { notice: state.notice }),
+        ),
+      );
+    }
+
+    return {
+      inject: ['slots', 'remote', 'remote.session', 'configForms'],
+      apply(ctx) {
+        const store = createStore(ctx);
+        ctx.effect(() => () => store.dispose(), 'default-model-lock: settings store');
+        ctx.slots.inject('settings.section', () =>
+          ctx.slots.register(
+            {
+              name: 'settings.section',
+              id: SECTION_ID,
+              order: SECTION_ORDER,
+              label: SECTION_LABEL,
+              inject: () => ({ store }),
+            },
+            DefaultModelLockSection,
+          ),
+        );
+      },
+      __internals: {
+        SECTION_ID,
+        SECTION_ORDER,
+        NAMESPACE,
+        normalizeConfig,
+        groupsOf,
+        findGroup,
+        findModel,
+        effortOptionsOf,
+        providerOptions,
+        modelOptions,
+        effortOptions,
+        describeAvailability,
+        planSave,
+        createStore,
+        looksLikeThisPlugin,
+      },
+    };
+  },
+});

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "dsh-default-model-lock",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "在设置页固定共享默认模型，并在会话模型选择器保存默认值前拦截写入",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "core.mjs",
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "README_EN.md",
+    "docs"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "dsh": {
+    "engines": {
+      "dsh": ">=0.2.1-rc.2"
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-api-session-controller"
+      ],
+      "platform": "web"
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh": ">=0.2.1-rc.2",
+    "@deepseek-ai/cordis": "~4.0.5",
+    "@deepseek-ai/schemastery": "~3.18.5",
+    "react": "^18.2.0"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "check": "node --check index.js && node --check core.mjs && node --check lib/client.js"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hZsFN/dsh-default-model-lock.git"
+  },
+  "homepage": "https://github.com/hZsFN/dsh-default-model-lock#readme",
+  "bugs": {
+    "url": "https://github.com/hZsFN/dsh-default-model-lock/issues"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "plugin",
+    "cordis",
+    "model",
+    "default-model",
+    "reasoning-effort"
+  ],
+  "author": "hZsFN"
+}