dsh-session-rollover 1.1.1 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 更新记录
 
+## 1.2.0 — 2026-11-11
+
+- 增加对 DSH `0.2.2-rc.1` 的确切版本支持，完成独立 home / profile 的真实宿主验收；保留旧版范围与原数据路径。
+- 修复新版宿主重建 `uiConversation` 时交接卡插槽未随子作用域释放、重复占用 keyed slot 的问题。
+- 集中宿主能力探测与读取结构预检，不兼容时在建卷和改名前暂停分卷，保留历史快照与只读拦截。
+- 新版优先读取工作目录、活动 Agent 模型的领域服务，保留旧投影接口回退；可选服务热替换时避免旧清理回调误删新服务。
+- 会话状态及面板补充兼容诊断，HTTP 建卷明确返回 503，缺失界面服务不直接中断渲染。
+- 增加所有后续 npm DSH 版本的公开声明检查、Windows/Linux 与 Node 22/24 回归工作流和升级验收指南；不自动扩大兼容范围或发布。
+- 增加实际 tgz 的隔离安装、稳定导出和面板资源校验；兼容策略及新模块随包分发。
+
 ## 1.1.1 — 2026-11-07
 
 - 公开包名改为 `dsh-session-rollover`，作者 Oak-liuhj；不改变运行数据路径、`sessionRollover` 服务和兼容导出。

package/README.md

@@ -8,7 +8,7 @@
 
 适合持续编码、问题排查和多步骤任务。支持 Web 与桌面客户端，无需为插件单独配置 API Key。
 
-**版本 1.1.1** · **已验证 DSH 0.2.1-rc.5** · **维护者 Oak-liuhj**
+**版本 1.2.0** · **支持 DSH 0.2.1-rc.5 / 0.2.2-rc.1** · **维护者 Oak-liuhj**
 
 [使用指南](./docs/DETAIL.zh-CN.md) · [English guide](./docs/DETAIL.md) · [更新记录](./CHANGELOG.md) · [问题反馈](https://github.com/Oak-liuhj/dsh-session-rollover/issues)
 
@@ -44,6 +44,8 @@
 
 需要已配置模型、可正常对话的 DSH 宿主。浏览器入口随包预构建，安装插件时无需自行构建。
 
+`1.2.0` 支持 DSH `0.2.1-rc.5` 和已完成实机验收的 `0.2.2-rc.1`。旧版 `1.1.1` 只声明支持前者，在新版宿主中会被阻止启用；请更新兼容版本，保留原数据目录。后续版本通过逐版检查和真实宿主验收适配；关键接口变化时暂停分卷并提示。维护机制与证据边界见 [DSH 升级适配](docs/COMPATIBILITY.md)。
+
 可在 DSH 插件市场搜索 `dsh-session-rollover` 安装并启用，也可通过插件包名、GitHub 源或本地安装包安装。
 
 ### 通过 npm 包名安装
@@ -75,7 +77,7 @@ dsh plugin --profile desktop add github:Oak-liuhj/dsh-session-rollover
 将路径替换为实际 tgz 文件位置：
 
 ```powershell
-dsh plugin --profile desktop add "D:/release/dsh-session-rollover-1.1.1.tgz"
+dsh plugin --profile desktop add "D:/release/dsh-session-rollover-1.2.0.tgz"
 ```
 
 桌面用户安装后，请通过桌面客户端重启宿主。已安装旧包 `@deepseek-ai/dsh-session-rollover` 时，应先替换旧依赖，避免同时加载新旧两份插件；升级前备份配置与插件数据。详细步骤见 [升级指南](./docs/PUBLISHING.md#从-scoped-旧包迁移)。
@@ -143,7 +145,7 @@ dsh plugin --profile desktop remove dsh-session-rollover
 
 ## 兼容性与开发
 
-已验证 DSH `0.2.1-rc.5`，验证记录覆盖自动分卷、待办续接、来源导航、双向只读开关及浅深主题。旧宿主可能不显示插件长说明，可从会话 `⋯ → 使用说明` 查看内置指南。
+历史基线 DSH `0.2.1-rc.5` 的验证覆盖自动分卷、待办续接、来源导航、双向只读开关及浅深主题；`1.2.0` 对 DSH `0.2.2-rc.1` 的实机验收记录见[升级适配指南](docs/COMPATIBILITY.md)。旧宿主可能不显示插件长说明，可从会话 `⋯ → 使用说明` 查看内置指南。
 
 现有验证使用隔离宿主与本地模型夹具，完整 Bot 群端、生产模型和后续宿主版本仍需单独复验。详见 [功能验证](./docs/r3-validation.md) 与 [市场展示验证](./docs/marketplace-validation.md)。
 

package/client.js

@@ -1,4 +1,4 @@
-// Generated by npm run build; edit src/client/. Version 1.1.1.
+// Generated by npm run build; edit src/client/. Version 1.2.0.
 // dsh-session-rollover · 浏览器半边（B6 一次性提示）。
 // 通道：server 半把「该提示什么」落盘，这里同源 GET /api-dsh-session-rollover/pending 取走渲染。
 // 不碰宿主 Toast 实现、不建 React hooks 面（D-36：bindInjectSources 会剥掉 hooks 字段），纯 DOM。
@@ -311,6 +311,18 @@ function createRolloverUI(React) {
     const entries = new Map();
     let navigate = null;
     let renderInline = false;
+    const clientWarnings = new Set();
+    function unavailable(feature, error) {
+        clientWarnings.add(feature);
+        console.warn('[dsh-session-rollover] client capability unavailable:', feature, error?.message ?? '');
+    }
+    function inject(ctx, names, setup) {
+        try {
+            ctx.inject(names, scope => {
+                try { return setup(scope); } catch (error) { unavailable(names.join(','), error); }
+            });
+        } catch (error) { unavailable(names.join(','), error); }
+    }
 
     async function request(sessionId, action) {
         const response = await fetch(action ? API : `${API}?session=${encodeURIComponent(sessionId)}`, action ? {
@@ -428,8 +440,8 @@ function createRolloverUI(React) {
                     h('p', {className: 'dsr-help-credit'}, 'dsh-session-rollover · Oak-liuhj')) : null,
                 h('div', {className: 'dsr-actions-body'},
                     h('button', {type: 'button', 'aria-expanded': showHelp, onClick: () => setShowHelp(!showHelp)}, showHelp ? '收起使用说明' : '使用说明'),
-                    h('button', {type: 'button', disabled: busy || info.sealed || !navigate, onClick: () => action('rollover')}, '现在换会话'),
-                    h('button', {type: 'button', disabled: busy || !navigate, onClick: () => action('new')}, '新建独立会话'),
+                    h('button', {type: 'button', disabled: busy || info.sealed || !navigate || info.compatibility?.compatible === false, onClick: () => action('rollover')}, '现在换会话'),
+                    h('button', {type: 'button', disabled: busy || !navigate || info.compatibility?.compatible === false, onClick: () => action('new')}, '新建独立会话'),
                     h('button', {type: 'button', onClick: () => dialog.current?.close()}, '关闭'))),
             error ? h('span', {role: 'alert'}, error) : null);
     }
@@ -489,6 +501,8 @@ function createRolloverUI(React) {
         if (!info) return null;
         return h('div', {className: 'dsr-dock'},
             info.error ? h('div', {role: 'alert'}, info.error) : null,
+            info.compatibility?.compatible === false ? h('div', {role: 'alert', className: 'dsr-warning'}, info.compatibility.message) : null,
+            clientWarnings.size ? h('div', {role: 'alert', className: 'dsr-warning'}, '部分会话界面功能与当前 DSH 不兼容，请更新插件。') : null,
             h(ReadonlyControl, {key: props.sessionId, info}),
             info.capped ? h('div', {role: 'status', className: 'dsr-warning'}, '同簇已达 9 卷上限（9/9），请通过会话操作新建独立会话。') : null,
             info.retryLimitReached ? h('div', {role: 'status', className: 'dsr-warning'}, '摘要生成失败，已停止自动重试。可在修正内容后手动换会话。') : null,
@@ -506,7 +520,9 @@ function createRolloverUI(React) {
 
     /** 释放时仅撤销自己的禁用；保留模型选择等其他插件后来设置的阻塞原因。 */
     function blockComposer(blocks, id, reason) {
+        if (typeof blocks?.storeFor !== 'function' || typeof blocks?.set !== 'function') throw new Error('composer blocks unavailable');
         const store = blocks.storeFor(id);
+        if (typeof store?.getSnapshot !== 'function' || typeof store?.subscribe !== 'function') throw new Error('composer store unavailable');
         let previous = store.getSnapshot();
         const own = {reason};
         let writing = false;
@@ -528,13 +544,15 @@ function createRolloverUI(React) {
         style.setAttribute('data-dsh-plugin', 'dsh-session-rollover-ui');
         document.head.appendChild(style);
         ctx.effect?.(() => () => { style.remove(); for (const item of entries.values()) item.stop?.(); entries.clear(); });
-        ctx.inject(['uiWorkspace'], scope => {
+        inject(ctx, ['uiWorkspace'], scope => {
+            if (typeof scope.uiWorkspace?.openSession !== 'function') throw new Error('session navigation unavailable');
             navigate = id => scope.uiWorkspace.openSession(id);
             scope.effect?.(() => () => { navigate = null; });
         });
-        ctx.inject(['slots'], scope => {
+        inject(ctx, ['slots'], scope => {
             const slots = scope.slots;
-            const mount = (name, Component, options = {}) => scope.effect(() => slots.inject(name, () => slots.register({name,
+            if (typeof slots?.inject !== 'function' || typeof slots?.register !== 'function') throw new Error('slots unavailable');
+            const mount = (name, Component, options = {}, owner = scope) => owner.effect(() => owner.slots.inject(name, () => owner.slots.register({name,
                 id: 'dsh-session-rollover', order: 35, ...options}, Component)));
             mount('conversation.session.header.actions', Header);
             mount('conversation.input.dock', Dock);
@@ -543,20 +561,27 @@ function createRolloverUI(React) {
             mount('sidebar.session.row.leading', props => slots.snapshot?.('sidebar.session.row.trailing')?.length
                 ? null : h(Badges, {...props, compact: true}));
             // 使用宿主公开 composer block 服务；覆盖输入组件会破坏其子槽授权。
-            scope.inject(['conversation'], inputScope => {
+            inject(scope, ['conversation'], inputScope => {
+                if (typeof inputScope.conversation?.blocks?.storeFor !== 'function' || typeof inputScope.conversation?.blocks?.set !== 'function') {
+                    throw new Error('composer blocks unavailable');
+                }
                 function ComposerGuard(props) {
                     const info = useInfo(props.sessionId);
                     const reason = !info ? '正在读取会话状态…' : info.readonly
                         ? '归档会话：不可输入，可通过上方开关恢复写入。' : info.error;
-                    useEffect(() => props.sessionId && reason
-                        ? blockComposer(inputScope.conversation.blocks, props.sessionId, reason) : undefined,
+                    useEffect(() => {
+                        if (props.sessionId && reason) {
+                            try { return blockComposer(inputScope.conversation.blocks, props.sessionId, reason); }
+                            catch (error) { unavailable('conversation.blocks', error); }
+                        }
+                    },
                     [props.sessionId, reason]);
                     return null;
                 }
                 inputScope.effect(() => slots.inject('conversation.input.dock', () => slots.register({
                     name: 'conversation.input.dock', id: 'dsr-readonly-guard', order: 34}, ComposerGuard)));
             });
-            scope.inject(['uiConversation'], textScope => {
+            inject(scope, ['uiConversation'], textScope => {
                 if (!textScope.uiConversation.userText?.register) return;
                 textScope.effect(() => textScope.uiConversation.userText.register({id: 'dsr-handoff', order: -100,
                     match(text, from) {
@@ -564,8 +589,10 @@ function createRolloverUI(React) {
                         const payload = parseHandoff(text);
                         return payload ? {id: 'dsr-handoff', start: 0, end: text.length, data: payload} : undefined;
                     }}));
+                // 插槽必须随 uiConversation 的注入子作用域释放，不能挂在较长寿命的 slots 父作用域。
+                // 新宿主重连/热替换领域服务时会重建该子作用域；挂在父级会重复占用同一个 keyed slot。
                 mount('conversation.user.text.node', props => h(Card, {payload: props.node.data,
-                    source: props.node.data.from_session_id && !props.node.data.cluster?.independent ? {sessionId: props.node.data.from_session_id, title: props.node.data.from_title ?? '上一卷'} : null}), {key: 'dsr-handoff'});
+                    source: props.node.data.from_session_id && !props.node.data.cluster?.independent ? {sessionId: props.node.data.from_session_id, title: props.node.data.from_title ?? '上一卷'} : null}), {key: 'dsr-handoff'}, textScope);
                 renderInline = true;
                 textScope.effect?.(() => () => { renderInline = false; });
             });
@@ -586,7 +613,7 @@ body[data-ds-dark-theme] :is(.dsr-header,.dsr-dock,.dsr-card,.dsr-row-badges),ht
 @media(max-width:600px){.dsr-header{gap:3px;flex-wrap:nowrap;max-width:calc(100vw - 156px)}.dsr-header>.dsr-chip,.dsr-header>.dsr-source{display:none}.dsr-header>.dsr-chip:first-child{display:inline-flex;font-size:10px;padding:1px 3px}}
 @media(prefers-reduced-motion:reduce){.dsr-card *{animation:none!important;transition:none!important}}
 `;
-    return {apply, Header, Dock, Card, Badges, useInfo, parseHandoff, publish, blockComposer, CSS};
+    return {apply, Header, Dock, Card, Badges, useInfo, parseHandoff, publish, blockComposer, clientWarnings, CSS};
 }
 
             function apply(ctx) {

package/compatibility/policy.json

@@ -0,0 +1,21 @@
+{
+  "schemaVersion": 1,
+  "package": "@deepseek-ai/dsh",
+  "baseline": "0.2.1-rc.5",
+  "verifiedRuntimeVersions": ["0.2.1-rc.5", "0.2.2-rc.1"],
+  "registry": "https://registry.npmjs.org/",
+  "contracts": [
+    {"package": "@deepseek-ai/dsh-session", "methods": ["get", "list", "snapshotEvents"], "tokens": ["session/event"]},
+    {"package": "@deepseek-ai/dsh-session-title", "methods": ["get", "rename"]},
+    {"package": "@deepseek-ai/dsh-api-session-controller", "methods": ["create", "prompt", "selectModel"]},
+    {"package": "@deepseek-ai/dsh-session-projection", "methods": ["stateOf"]},
+    {"package": "@deepseek-ai/dsh-working-directory", "methods": ["get"]},
+    {"package": "@deepseek-ai/dsh-workspace", "methods": ["list"], "tokens": ["sessionIds"]},
+    {"package": "@deepseek-ai/dsh-agent", "methods": ["get", "current"], "tokens": ["agent/pre-step", "reject"],
+      "versionOverrides": {"0.2.1-rc.5": {"methods": ["get"]}}},
+    {"package": "@deepseek-ai/dsh-client-connection", "methods": ["admit"]},
+    {"package": "@deepseek-ai/dsh-client-ui-conversation", "methods": ["storeFor", "set"], "tokens": ["conversation.session.header.actions", "conversation.input.dock", "blocks"]},
+    {"package": "@deepseek-ai/dsh-client-ui-workspace", "methods": ["openSession"], "alternatives": [["sidebar.session.row.trailing", "sidebar.session.row.leading"]]},
+    {"package": "@deepseek-ai/dsh-client-ui-slots", "methods": ["register"]}
+  ]
+}

package/compatibility/runtime-0.2.2-rc.1.json

@@ -0,0 +1,32 @@
+{
+  "passed": true,
+  "runtimeVerified": true,
+  "checkedAt": "2026-11-11T07:26:36.784Z",
+  "dsh": "0.2.2-rc.1",
+  "plugin": "1.2.0",
+  "platform": "Windows",
+  "environment": "installed DSH CLI with isolated home and profile",
+  "model": "localhost fixture only; no provider credentials or real model quality assessment",
+  "checks": {
+    "tenHumanMessagesOneRollover": true,
+    "workspaceAndDirectoryInherited": true,
+    "modelInherited": true,
+    "frozenTodosAndActiveStep": true,
+    "continuationTodoProgress": true,
+    "archivedReadonly": true,
+    "restoredWritePersistsAcrossRefresh": true,
+    "restoredVolumeDoesNotRolloverAgain": true,
+    "realHostRestartPreservesIndexAndSnapshot": true,
+    "anonymousHTTPStatus": 401,
+    "sourceNavigationAndCopyJSON": true,
+    "inlineSlotLifecycleFixedAndRechecked": true
+  },
+  "browser": "manual automation through computer-use; no plugin warnings after fix and real restart",
+  "limitation": "Host reconnect logged a native released-session-reference error; plugin UI recovered after page reload. No full Bot or production provider acceptance.",
+  "sourceDigests": {
+    "client.js": "25a484847caf9a2ec71b11817d3c147c83fd546f2f80582826df124d742c2b69",
+    "src/server/plugin.mjs": "6afd4b8d5e6c03082240ca2f7304bff9fd3ec0e28bfa32e1fe369458f4a48ae5",
+    "src/server/host-adapter.mjs": "d145284cfa392d64b00d45f40ab308b320d768dc23606bbdbb048c0db6b25dd6",
+    "src/server/compatibility.mjs": "5572940c2bb6fc16dd0393f369417bd9acc025ab65fd7df5f370ededf454ce38"
+  }
+}

package/docs/COMPATIBILITY.md

@@ -0,0 +1,70 @@
+# DSH 升级适配与验收
+
+插件按“公开接口适配、运行前探测、逐版检查、真实宿主验收”维护。不能提前保证尚未发布的 DSH 一定兼容，也不根据版本号猜测新接口。
+
+## 当前范围
+
+- 历史真实宿主验收基线：`0.2.1-rc.5`；`1.2.0` 已在本机安装的 `0.2.2-rc.1` 独立 home / profile 中完成实机验收。
+- `compatibility/policy.json` 的 `verifiedRuntimeVersions` 决定允许安装的 DSH 版本；`engines.dsh` 必须与其逐项一致，发布检查禁止悄悄放宽范围。
+- npm 声明扫描、夹具回归和真实宿主验收分别记录。扫描通过不自动修改版本约束，不自动发布 npm 包，也不自动改用户 profile。
+- `1.2.0` 增加新版宿主支持；已安装 `1.1.1` 的用户需更新插件，npm 同一版本不会被覆盖更新。发布核验记录见 [投稿材料](../marketplace/SUBMISSION.md)。
+
+## 本次验证（2026-11-11）
+
+| 检查 | 结果与范围 |
+| --- | --- |
+| 本地回归 | Windows、Node.js 24.22.1，100 项全部通过（含旧宿主有 agents、无 model.current 时的投影回退） |
+| 公开声明 | `0.2.1-rc.5`、`0.2.2-alpha.3`、`0.2.2-rc.1` 的十一个组件包均通过 |
+| 发布包 | `1.2.0` 实际 tgz 隔离安装、服务端导出、预构建客户端和展示资源通过 |
+| 新版真实宿主 | `0.2.2-rc.1` 验收通过，保留旧基线并增加该确切版本；不放行其他未验收版本 |
+| 远程 CI | 已编写工作流；本地提交不代表远程已启用，需推送默认分支后运行 |
+
+声明报告和安装包校验报告分别保存在 `out/dsh-compatibility.json`、`out/package-verification.json`；它们不是实际宿主验收报告。其他平台及 Node 版本由远程矩阵执行，本轮未在本机验证。
+
+真实宿主记录见 [runtime-0.2.2-rc.1.json](../compatibility/runtime-0.2.2-rc.1.json)：十条用户消息仅分卷一次，继承工作区、目录及模型，待办快照保持不变，新卷实时待办可继续推进，来源跳转、复制 JSON、双向归档开关和宿主重启恢复正常，匿名 HTTP 请求返回 401。本轮使用本地模型夹具，不代表真实服务商模型或 Bot 端完整验收。
+
+重启复验发现并修复 `uiConversation` 子作用域卸载后交接卡 keyed slot 未释放的问题；插槽现在随该子作用域清理，重复注入回归与实机重启复验通过。宿主热重连期间仍观察到原生会话引用已释放的日志，刷新后恢复；这与插件重复插槽问题分开记录，不宣称宿主全局无错误。
+
+## 运行保护
+
+服务端集中在 `src/server/compatibility.mjs` 检查会话存储、标题、创建/提示/模型选择、投影、工作区接口，以及同步读取的返回结构。关键能力不满足时，自动与手动分卷在创建会话、改名、保存重试之前停止；HTTP 建卷操作返回 `503 host-incompatible`，面板显示更新提示。
+
+已有的交接快照与只读状态仍可读取；已注册的服务端归档写入拦截不因分卷暂停而关闭。方法存在不证明事件语义仍相同；如果升级导致插件本身无法加载，这些插件内保护也无法运行，所以仍需遵守宿主版本约束。
+
+新版宿主优先通过 `workingDirectory.get(session)` 和活动 Agent 的 `model.current()` 读取领域状态。缺少这些可选服务时，回退到已验证的 `sessionProjections.stateOf`。后者在较新源码中已弃用，仍纳入声明检查；将来移除时明确失败，由维护者适配，而不是静默换成空目录或默认模型。
+
+基线 `0.2.1-rc.5` 的 Agent 声明尚无 `current()`，检查策略对此确切版本保留显式例外，运行时使用投影回退；后续版本继续检查领域服务接口。未知模型结构会暂停分卷，合法的空选择保持可用。
+
+浏览器针对插槽、导航与输入阻塞服务做能力检查。缺少可选界面能力时记录带插件名的警告，并在可用的面板中提示；不让缺失服务直接导致 React 渲染错误。服务端诊断可通过 `ctx.sessionRollover.compatibility()` 获取；每个会话状态的 `compatibility` 还包含返回结构检查。
+
+## 自动检查
+
+仓库工作流 `.github/workflows/compatibility.yml` 包含：
+
+1. Windows / Linux、Node.js 22 / 24 上运行完整回归、发布格式检查和 tgz 隔离安装校验。
+2. 从官方 npm 注册表枚举基线发布时刻之后的每个 DSH 版本，包含 alpha、rc 与后续补丁；不只检查 `latest`，避免遗漏中间版本。
+3. 下载各版本的十一个公开组件包，核对 SHA512 后只读扫描类型声明，检查插件使用的方法、事件名及界面插槽，并保存报告。不会执行上游安装脚本。
+
+工作流在代码推送、PR、手动触发和每六小时的定时任务中运行；需要提交到 GitHub 默认分支并启用 Actions 才会生效。本地创建文件不等于已启用远程任务。注册表请求或归档校验失败均使任务失败，不视为兼容通过。版本数超过 200 时要求维护基线，不静默截断。
+
+```powershell
+npm test
+npm run check:release
+npm run check:package
+npm run check:dsh -- all
+npm run check:dsh -- 0.2.2-rc.1
+node scripts/check-dsh-compatibility.mjs --list
+```
+
+需要网络与系统 `tar`；Windows 自带的 tar 可用。报告默认写入忽略提交的 `out/dsh-compatibility.json`，也可用 `DSH_COMPATIBILITY_REPORT` 指定位置。`level: public-declaration-smoke`、`runtimeVerified: false` 明确说明证据边界。声明扫描不会证明方法签名、授权、事件顺序或视觉渲染完全兼容。
+
+`check:package` 在自有临时目录安装实际 tgz，复核导出、预构建客户端和全部发布资源，结束后清理隔离目录；包与报告保存在 `out/`。此检查也不代表真实 DSH 宿主验收。
+
+## 每次 DSH 发布后的维护步骤
+
+1. 查看每个新版本的声明扫描和回归结果；发现方法、事件或插槽变化时更新集中适配层，保留旧宿主路径的测试。
+2. 用该版本的真实 DSH，在隔离 home / profile 和本地模型夹具中验证：插件装载、十条真实用户消息只分一次、模型与工作区继承、待办交接、来源导航、重启恢复、归档只读及恢复写入、HTTP owner 授权。不得使用生产会话验收。
+3. 记录 DSH 与插件版本、平台、结果及证据位置。通过后才向 `verifiedRuntimeVersions` 添加确切版本，并同步 `engines.dsh` 的 `||` 列表。旧基线仍用于回归，不能只因新版本号更大便放行。
+4. 更新插件版本、构建预生成客户端、完成打包与隔离安装验证，再发布新 npm 版本。用户通过正常插件升级获得适配；不得覆盖同一 npm 版本。
+
+宿主升级后遇到兼容提示时，应保留数据目录，使用已验收版本组合或更新插件；不要删除快照、绕过宿主版本检查或同时加载两份插件。

package/docs/DETAIL.md

@@ -35,7 +35,7 @@ Default storage: `<DSH_HOME>/plugin-data/dsh-session-rollover`, or `~/.dsh/plugi
 
 Summaries use deterministic extraction, without another model call or API key. Conversation continuation uses the model configured in DSH. Background jobs are recorded as handles and states; processes are not moved, resumed or restarted. Summary text is limited to 1500 characters and the full handoff message to 16 KiB; oversized handoffs fail with a notice. Automatic failures get at most two further retries, triggered by subsequent user messages.
 
-Compatibility was verified against DSH `0.2.1-rc.5` using an isolated host and local model fixture. This is not full acceptance for production models, Bot group channels or future host versions. Older hosts may omit this long description; the conversation `⋯` menu includes a built-in usage guide.
+Version `1.2.0` supports DSH `0.2.1-rc.5` and `0.2.2-rc.1`. The latter was tested in an isolated host with a local model fixture for ten-message rollover, model and workspace inheritance, todo continuation, archive controls and restart recovery. Version `1.1.1` excludes DSH `0.2.2-rc.1`; upgrade the plugin while retaining its data directory. This is not full acceptance for production models, Bot group channels or future host versions. Older hosts may omit this long description; the conversation `⋯` menu includes a built-in usage guide.
 
 Replace the old `@deepseek-ai/dsh-session-rollover` dependency and bundle rather than loading both versions. Back up profile configuration and plugin data before upgrading. See the Chinese [publishing and migration guide](./PUBLISHING.md).
 

package/docs/DETAIL.zh-CN.md

@@ -38,7 +38,7 @@
 
 摘要是确定性摘录，不调用额外模型；继续对话仍使用 DSH 已配置的模型，无需额外 API Key。后台任务只继承句柄和状态，不迁移、恢复或重新启动进程。正文摘要上限 1500 字符、完整交接消息上限 16 KiB，超预算会拒绝交接并提示。自动失败最多再试两次，由后续用户轮次触发。
 
-兼容声明基于 DSH `0.2.1-rc.5`。本地模型夹具已验证十轮分卷和工具待办续接；不代表所有模型、Bot 群端或后续宿主版本均已验收。旧宿主可能不显示本长说明，可从会话 `⋯ → 使用说明` 查看内置指南。
+`1.2.0` 支持 DSH `0.2.1-rc.5` 与 `0.2.2-rc.1`；后者已在独立环境验证十轮分卷、模型和工作区继承、待办续接、归档开关及重启恢复。旧版 `1.1.1` 的版本约束不支持 `0.2.2-rc.1`，需升级插件并保留数据目录。不代表所有模型、Bot 群端或后续宿主版本均已验收。旧宿主可能不显示本长说明，可从会话 `⋯ → 使用说明` 查看内置指南。
 
 ## 升级与支持
 

package/docs/DEVELOPMENT.md

@@ -29,6 +29,8 @@ R2 面板可继续调用原有 rollover/info 服务；无实时 `todo/write` 时
 
 `connection` 为显式必需注入；`jobs`、`agentDefaultModel` 通过独立可选注入获取，避免 Cordis 未声明服务访问报错。
 
+`workingDirectory`、`agents` 同样通过可选注入获取，用于新版领域状态读取。`sessionRollover.compatibility()` 返回关键方法的能力报告；会话 `info().compatibility` 还检查读取结果形状。逐版检查、CI 与真实宿主验收流程见 [升级适配指南](./COMPATIBILITY.md)。
+
 ## 项目结构
 
 ```text
@@ -76,6 +78,7 @@ docs/r3-demo.html               固定数据交互原型
 ```powershell
 npm test
 npm run check:release
+npm run check:package
 npm pack --dry-run
 npm pack --pack-destination <输出目录>
 ```

package/docs/PUBLISHING.md

@@ -1,12 +1,13 @@
 # 发布与升级指南
 
-公开包名为 `dsh-session-rollover`，版本 1.1.1，维护者 Oak-liuhj。仓库：[Oak-liuhj/dsh-session-rollover](https://github.com/Oak-liuhj/dsh-session-rollover)。支持在宿主中直接填写 npm 包名安装；维护者需将实际发布包上传到 npm 官方注册表，市场收录不代替 npm 发布。
+公开包名为 `dsh-session-rollover`，当前版本 1.2.0，维护者 Oak-liuhj。仓库：[Oak-liuhj/dsh-session-rollover](https://github.com/Oak-liuhj/dsh-session-rollover)。支持在宿主中直接填写 npm 包名安装；市场收录不代替 npm 发布。实际公开版本以 npm 官方源和 GitHub Release 为准，发布核验记录见 [投稿材料](../marketplace/SUBMISSION.md)。
 
 ## 构建与打包
 
 ```powershell
 npm test
 npm run check:release
+npm run check:package
 npm pack --pack-destination D:/release
 ```
 
@@ -21,8 +22,8 @@ npm pack --pack-destination D:/release
 ```powershell
 npm login --auth-type=web --registry=https://registry.npmjs.org/
 npm whoami --registry=https://registry.npmjs.org/
-npm publish "D:/release/dsh-session-rollover-1.1.1.tgz" --access public --registry=https://registry.npmjs.org/
-npm view dsh-session-rollover@1.1.1 version dist.integrity --registry=https://registry.npmjs.org/
+npm publish "D:/release/dsh-session-rollover-1.2.0.tgz" --access public --registry=https://registry.npmjs.org/
+npm view dsh-session-rollover@1.2.0 version dist.integrity --registry=https://registry.npmjs.org/
 ```
 
 4. 在隔离目录从 npm 安装并核对包名、版本、挂载补丁、预构建客户端与模块导入；只有 npm 返回该版本且下载验证通过，才确认包名安装可用。
@@ -30,13 +31,29 @@ npm view dsh-session-rollover@1.1.1 version dist.integrity --registry=https://re
 
 `publishConfig.registry` 固定为 npm 官方源；公开包名为 `dsh-session-rollover`。npm 已发布的同一版本不能覆盖，后续发布需先提升版本号。认证和双重验证失败时保留待发布包，完成认证后继续发布，不绕过验证。
 
+### 已进入暂存区时
+
+使用支持 `npm stage` 的 CLI，先查询已有暂存记录，再确认同一个包：
+
+```powershell
+npm stage list dsh-session-rollover --json --registry=https://registry.npmjs.org/
+npm stage view <stage-id> --json --registry=https://registry.npmjs.org/
+npm stage approve <stage-id> --registry=https://registry.npmjs.org/
+```
+
+核对版本、`latest` 标签和 shasum 与已审核 tgz 一致。`staged` 仅表示待审批，同一暂存版本不能再次普通发布；保留原 tgz 和 stage id，完成审批后再执行下载与隔离安装验证。首次暂存可能产生 `0.0.0-stage` 占位版本，不能以包名可查询作为正式版本发布成功的依据。
+
+CLI 登录授权、注册安全密钥和本次发布的本人认证是不同步骤。账号已启用 2FA 但审批仍要求配置时，先核对账号状态并尝试全新登录，不反复注册密钥；认证 URL 失效也不代表 tgz 丢失。若全新登录后问题仍存在，保存不含凭据的错误、时间和 stage id，向 [npm 支持](https://www.npmjs.com/support)反馈。不要通过关闭 2FA 或创建绕过认证的令牌处理审批异常。
+
+认证请求有有效期，应在本人准备好设备验证后再启动命令，并让 npm 直接打开系统浏览器。不要先生成地址再等待聊天确认；手工打开时核对完整地址，避免回调参数混入中文标点或正文。有效期已过时重新运行原审批命令，不复用旧地址。
+
 ## 从 scoped 旧包迁移
 
 1. 记录真实运行的 profile，桌面通常是 `~/.dsh/profiles/desktop`。备份该 profile 的 package.json、锁文件、Cordis 配置和旧插件目录，并备份 `<DSH_HOME>/plugin-data/dsh-session-rollover`；自定义 dataDir 也需备份。
 2. 通过桌面插件管理器/宿主支持的依赖管理渠道，将 `@deepseek-ai/dsh-session-rollover` 替换为新包。CLI 可使用 `dsh plugin --profile desktop remove @deepseek-ai/dsh-session-rollover`，然后 `dsh plugin --profile desktop add <本地tgz或GitHub源>`。分步操作时先停止宿主，避免短暂缺包。
 3. profile 的 `dsh.profile.bundles` 只保留新包一次；显式 Cordis 节点的 `name` 改为新包名，原 `id: session-rollover`、用户配置值和相邻插件保留。不可同时加载两个包来注册同一个服务。不能只覆盖 node_modules 而保留过期依赖来源。
 4. 从桌面客户端重启实际宿主；不要用普通 Web profile 的重启操作接管桌面生命周期。
-5. 核实已加载 1.1.1、面板图标/简介、会话 `⋯ → 使用说明`、旧卷快照和只读状态。不要为了安装验证向生产会话发送测试消息。
+5. 核实已加载目标版本、面板图标/简介、会话 `⋯ → 使用说明`、旧卷快照和只读状态。不要为了安装验证向生产会话发送测试消息。
 
 本次更名不迁移数据；数据目录、`sessionRollover`、HTTP 路由、Cordis id 和旧 `src/*` 导出保持兼容。卸载也不删除数据。回滚时停止宿主，恢复备份的 profile 配置、锁文件和依赖，再重启；不要覆盖更新后已产生的用户数据。
 
@@ -60,4 +77,4 @@ npm view dsh-session-rollover@1.1.1 version dist.integrity --registry=https://re
 3. 等仓库创建满一天并确保 topic 为 `dsh-plugin`。按 [投稿材料](../marketplace/SUBMISSION.md) 向官方插件目录发起 PR。
 4. 确认市场抓取后的简介、图标、截图及安装源正确；外部收录前不要宣称已上架。
 
-`engines.dsh` 保持已验证的 `0.2.1-rc.5`，不推测扩大兼容区间。许可证声明为 `(Apache-2.0 AND MIT)`，必须同时分发 LICENSE、LICENSE.upstream 和 NOTICE。
+`engines.dsh` 由 `compatibility/policy.json` 中实际完成宿主验收的确切版本组成，不推测扩大兼容区间；声明扫描通过后仍需执行 [升级验收](./COMPATIBILITY.md)。许可证声明为 `(Apache-2.0 AND MIT)`，必须同时分发 LICENSE、LICENSE.upstream 和 NOTICE。

package/marketplace/SUBMISSION.md

@@ -9,6 +9,17 @@
 - 唯一新增文件：`data/plugins/Oak-liuhj__dsh-session-rollover.yml`。
 - 校验与审核的实时状态以 PR 页面为准。提交 PR 不等于市场已收录；正式收录还需维护者合并及目录后续构建。
 
+## npm 发布记录
+
+2026-11-11 **13:51（北京时间）**，`dsh-session-rollover@1.1.1` 已正式发布到 [npm](https://www.npmjs.com/package/dsh-session-rollover/v/1.1.1)。npm 发布账号为 `oak-ai`，插件作者与 GitHub 仓库所有者为 `Oak-liuhj`。
+
+- npm 官方源与腾讯镜像的 `latest` 均已确认为 `1.1.1`。
+- 下载的 tgz 与审核通过的原包一致，SHA1 为 `cbe802fe44f8ae14da3eebc8d6a92e3468609ab5`，SHA512 integrity 也已核对。
+- 两个源均已通过按包名隔离安装；已验证服务端入口导入、挂载补丁、预构建客户端、图标、双语资源及许可证文件。
+- 用户可在「填入插件 npm 包名」中输入 `dsh-session-rollover`；CLI 桌面 profile 示例为 `dsh plugin --profile desktop add dsh-session-rollover`。
+
+本次验证未改动生产 DSH profile；正式版本发布与市场目录收录分别核实，npm 的 `0.0.0-stage` 占位版本不作为发布成功依据。
+
 ## 投稿规则与材料
 
 投稿目录为 [awesome-dsh-plugin/awesome-dsh-plugin](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin)，市场应用代码仓库 `dsh-market/dsh-market` 不是插件条目的投稿目标。规则来源：[contributing.md](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin/blob/main/contributing.md)（核对于 2026-11-07）。
@@ -23,4 +34,4 @@
 
 提交前确认公开 main 分支或安装目标包含 `client.js`、图标和截图；仓库 topic 包含 `dsh-plugin`，创建满一天。仓库创建时间核对为 2026-11-06 06:45:34 UTC，最早满一天时间为北京时间 **2026-11-07 14:45:34**。npm 发布可选，未发布 npm 时使用 GitHub 安装源。
 
-本目录的 YAML 已通过上述 PR 提交。市场收录、npm 发布和 GitHub Release 是独立状态；本次投稿不包含 npm 发布或创建 GitHub Release。
+本目录的 YAML 已通过上述 PR 提交。市场收录、npm 发布和 GitHub Release 是独立状态；首次市场投稿未包含 npm 发布，后续 npm 发布见上方记录。本记录不表示已创建 GitHub Release。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-rollover",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "type": "module",
   "description": "DSH 会话分卷与续接：自动分卷、待办交接快照、来源回溯和归档只读，支持 Web 与桌面客户端。",
   "main": "index.js",
@@ -39,6 +39,8 @@
     "docs/screenshots/help-light.png",
     "docs/screenshots/help-dark.png",
     "marketplace/",
+    "compatibility/",
+    "docs/COMPATIBILITY.md",
     "docs/r3-demo.html",
     "docs/screenshots/prototype-fixed.png",
     "docs/live-host-validation.json",
@@ -51,7 +53,9 @@
     "pretest": "npm run build",
     "prepack": "npm run build && node scripts/check-release.mjs",
     "test": "node --test \"test/**/*.test.mjs\"",
-    "check:release": "npm run build:check && node scripts/check-release.mjs"
+    "check:release": "npm run build:check && node scripts/check-release.mjs",
+    "check:dsh": "node scripts/check-dsh-compatibility.mjs",
+    "check:package": "npm run check:release && node scripts/check-package.mjs"
   },
   "dsh": {
     "manifestVersion": 1,
@@ -96,6 +100,6 @@
     "registry": "https://registry.npmjs.org/"
   },
   "engines": {
-    "dsh": "0.2.1-rc.5"
+    "dsh": "0.2.1-rc.5 || 0.2.2-rc.1"
   }
 }

package/scripts/check-dsh-compatibility.mjs

@@ -0,0 +1,44 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {tmpdir} from 'node:os';
+import {registryJSON, publishedTargets, checkPackage} from './dsh-contracts.mjs';
+const policy = JSON.parse(await fs.readFile(new URL('../compatibility/policy.json', import.meta.url), 'utf8'));
+const args = process.argv.slice(2);
+const list = args.includes('--list');
+const target = args.find(value => !value.startsWith('--')) ?? 'latest';
+const metadata = await registryJSON(policy.registry + encodeURIComponent(policy.package));
+const versions = publishedTargets(metadata, policy.baseline);
+if (!versions.length || versions.length > 200) throw new Error('DSH compatibility matrix requires baseline maintenance');
+if (list) {
+    // 超出 GitHub matrix 上限时明确失败，要求维护者调整基线，不静默漏掉新版本。
+    console.log(JSON.stringify({version: versions}));
+} else {
+    const selected = target === 'all' ? versions : [metadata['dist-tags']?.[target] ?? target];
+    const directory = await fs.mkdtemp(path.join(tmpdir(), 'dsh-contracts-'));
+    const report = {level: 'public-declaration-smoke', runtimeVerified: false,
+        checkedAt: new Date().toISOString(), baseline: policy.baseline, targets: []};
+    try {
+        for (const version of selected) {
+            const results = [];
+            for (const contract of policy.contracts) {
+                try { results.push(await checkPackage(contract, version, policy, directory)); }
+                catch (error) { results.push({package: contract.package, version, error: String(error.message)}); }
+            }
+            const passed = results.every(result => !result.error && !result.missing?.length);
+            report.targets.push({version, passed, packages: results});
+            console.log(`${version}: ${passed ? 'PASS' : 'FAIL'} (public declarations; not runtime verification)`);
+            for (const result of results.filter(r => r.error || r.missing?.length)) console.error(JSON.stringify(result));
+        }
+        report.passed = report.targets.every(target => target.passed);
+        const output = process.env.DSH_COMPATIBILITY_REPORT ?? path.resolve('out/dsh-compatibility.json');
+        await fs.mkdir(path.dirname(output), {recursive: true});
+        await fs.writeFile(output, JSON.stringify(report, null, 2) + '\n');
+        if (!report.passed) process.exitCode = 1;
+    } finally {
+        // 只删除 mkdtemp 创建并持有的独立目录。
+        if (path.dirname(path.resolve(directory)) !== path.resolve(tmpdir()) || !path.basename(directory).startsWith('dsh-contracts-')) {
+            throw new Error('Refusing cleanup outside the owned temporary directory');
+        }
+        await fs.rm(directory, {recursive: true, force: true});
+    }
+}

package/scripts/check-package.mjs

@@ -0,0 +1,51 @@
+/** 校验真正交付的 tgz：隔离安装、稳定导出、清单和预构建浏览器入口；不接触 DSH profile。 */
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import {tmpdir} from 'node:os';
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import {pathToFileURL, fileURLToPath} from 'node:url';
+import {createHash} from 'node:crypto';
+const run = promisify(execFile);
+const root = fileURLToPath(new URL('../', import.meta.url));
+const npm = process.env.npm_execpath;
+assert.ok(npm && path.basename(npm) === 'npm-cli.js', 'Run this check with npm run check:package');
+const owned = await fs.mkdtemp(path.join(tmpdir(), 'dsh-rollover-package-'));
+const output = path.join(root, 'out');
+try {
+    // 调用方已完成 build:check 和发布检查；这里禁用生命周期，确保检查同一份构建产物。
+    const packed = JSON.parse((await run(process.execPath, [npm, 'pack', '--json', '--ignore-scripts', '--pack-destination', owned],
+        {cwd: root, windowsHide: true, maxBuffer: 4 * 1024 * 1024})).stdout)[0];
+    const archive = path.join(owned, path.basename(packed.filename));
+    const install = path.join(owned, 'install');
+    await fs.mkdir(install);
+    await fs.writeFile(path.join(install, 'package.json'), '{"name":"dsh-rollover-package-check","private":true}\n');
+    await run(process.execPath, [npm, 'install', archive, '--ignore-scripts', '--no-audit', '--no-fund', '--package-lock=false'],
+        {cwd: install, windowsHide: true, maxBuffer: 4 * 1024 * 1024});
+    const installed = path.join(install, 'node_modules', 'dsh-session-rollover');
+    const manifest = JSON.parse(await fs.readFile(path.join(installed, 'package.json'), 'utf8'));
+    const entry = await import(pathToFileURL(path.join(installed, manifest.main)).href);
+    assert.equal(entry.default, entry.SessionRolloverPlugin);
+    assert.equal(typeof entry.default, 'function');
+    const files = packed.files.map(file => file.path);
+    for (const required of ['client.js', 'src/server/compatibility.mjs', 'compatibility/policy.json', 'docs/COMPATIBILITY.md']) {
+        assert.ok(files.includes(required), `Missing packed resource: ${required}`);
+    }
+    // 从安装后的目录重新校验全部面板资源和 ModuleLoader，避免只检查源码目录。
+    await run(process.execPath, [path.join(installed, 'scripts/check-release.mjs')], {cwd: installed, windowsHide: true});
+    const bytes = await fs.readFile(archive);
+    await fs.mkdir(output, {recursive: true});
+    await fs.copyFile(archive, path.join(output, packed.filename));
+    const report = {passed: true, level: 'isolated-package-install', runtimeVerified: false,
+        checkedAt: new Date().toISOString(), platform: process.platform, node: process.version,
+        name: manifest.name, version: manifest.version, files: files.length,
+        sha256: createHash('sha256').update(bytes).digest('hex'), artifact: packed.filename};
+    await fs.writeFile(path.join(output, 'package-verification.json'), JSON.stringify(report, null, 2) + '\n');
+    console.log(`Package PASS: ${manifest.name}@${manifest.version}; isolated install, exports, client and resources (${files.length} files).`);
+} finally {
+    if (path.dirname(path.resolve(owned)) !== path.resolve(tmpdir()) || !path.basename(owned).startsWith('dsh-rollover-package-')) {
+        throw new Error('Refusing cleanup outside the owned temporary directory');
+    }
+    await fs.rm(owned, {recursive: true, force: true});
+}

package/scripts/check-release.mjs

@@ -25,7 +25,19 @@ assert.equal(pkg.bugs.url, repo + '/issues');
 assert.ok(pkg.keywords.includes('dsh-plugin'));
 assert.equal(pkg.dsh.manifestVersion, 1);
 assert.equal(pkg.dsh.client.platform, 'web');
-assert.equal(pkg.engines.dsh, pkg.dsh.verifiedDsh);
+const compatibility = JSON.parse(await readFile(await localFile('compatibility/policy.json'), 'utf8'));
+assert.equal(compatibility.baseline, pkg.dsh.verifiedDsh);
+assert.ok(compatibility.verifiedRuntimeVersions.includes(compatibility.baseline));
+assert.ok(compatibility.verifiedRuntimeVersions.every(version => /^\d+\.\d+\.\d+(?:-[\w.-]+)?$/.test(version)));
+assert.equal(pkg.engines.dsh, compatibility.verifiedRuntimeVersions.join(' || '));
+for (const version of compatibility.verifiedRuntimeVersions.filter(version => version !== compatibility.baseline)) {
+    const evidence = JSON.parse(await readFile(await localFile(`compatibility/runtime-${version}.json`), 'utf8'));
+    assert.equal(evidence.passed, true);
+    assert.equal(evidence.runtimeVerified, true);
+    assert.equal(evidence.dsh, version);
+    assert.equal(evidence.plugin, pkg.version);
+}
+await localFile('docs/COMPATIBILITY.md');
 assert.deepEqual(Object.keys(pkg.dependencies ?? {}), []);
 assert.equal(pkg.scripts.prepare, undefined);
 assert.equal(pkg.scripts.postinstall, undefined);

package/scripts/dsh-contracts.mjs

@@ -0,0 +1,69 @@
+/** 检查 npm 公共声明中的依赖面；不执行上游包，不把声明扫描当作真实宿主验收。 */
+import assert from 'node:assert/strict';
+import {createHash} from 'node:crypto';
+import {execFile} from 'node:child_process';
+import {promisify} from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const run = promisify(execFile);
+
+export async function registryJSON(url) {
+    const response = await fetch(url, {signal: AbortSignal.timeout(30000)});
+    assert.equal(response.status, 200, `Registry unavailable: ${url} (${response.status})`);
+    return response.json();
+}
+
+/** 按官方发布时刻枚举基线之后的每个版本，包含 alpha/rc 和后续补丁。 */
+export function publishedTargets(metadata, baseline) {
+    const since = Date.parse(metadata.time?.[baseline]);
+    assert.ok(Number.isFinite(since), 'Missing baseline publication time');
+    const versions = Object.keys(metadata.versions ?? {});
+    assert.ok(versions.includes(baseline), 'Missing baseline package version');
+    for (const version of versions) {
+        assert.match(version, /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/);
+        assert.ok(Number.isFinite(Date.parse(metadata.time?.[version])), `Missing publication time: ${version}`);
+    }
+    return versions.filter(version => Date.parse(metadata.time?.[version]) >= since)
+        .sort((a, b) => Date.parse(metadata.time[a]) - Date.parse(metadata.time[b]));
+}
+
+export function inspectDeclarations(text, contract) {
+    // 去除注释，避免已删除的方法只在弃用说明中出现时误判通过。
+    const source = text.replace(/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*/g, '');
+    const missing = [];
+    for (const method of contract.methods ?? []) {
+        assert.match(method, /^\w+$/);
+        if (!new RegExp(`\\b${method}\\s*(?:<[^;{}]*?>\\s*)?\\(`).test(source)) missing.push(method + '()');
+    }
+    for (const token of contract.tokens ?? []) if (!source.includes(token)) missing.push(token);
+    for (const group of contract.alternatives ?? []) {
+        if (!group.some(token => source.includes(token))) missing.push(group.join(' | '));
+    }
+    return missing;
+}
+
+export async function checkPackage(contract, version, policy, directory) {
+    const metadata = await registryJSON(policy.registry + encodeURIComponent(contract.package) + '/' + encodeURIComponent(version));
+    assert.equal(metadata.version, version);
+    assert.equal(new URL(metadata.dist.tarball).hostname, new URL(policy.registry).hostname);
+    assert.match(metadata.dist.integrity, /^sha512-[A-Za-z0-9+/=]+$/);
+    const response = await fetch(metadata.dist.tarball, {signal: AbortSignal.timeout(30000)});
+    assert.equal(response.status, 200);
+    const archive = Buffer.from(await response.arrayBuffer());
+    assert.equal('sha512-' + createHash('sha512').update(archive).digest('base64'), metadata.dist.integrity);
+    const file = path.join(directory, contract.package.replace(/[^\w-]/g, '_') + '.tgz');
+    await fs.writeFile(file, archive);
+    const {stdout} = await run('tar', ['-tzf', file], {windowsHide: true, maxBuffer: 4 * 1024 * 1024});
+    const declarations = stdout.split(/\r?\n/).filter(name => /^package\/lib\/.*\.d\.ts$/.test(name));
+    assert.ok(declarations.length > 0, 'Missing public type declarations');
+    let text = '';
+    for (let offset = 0; offset < declarations.length; offset += 40) {
+        const names = declarations.slice(offset, offset + 40);
+        assert.ok(names.every(name => !name.split('/').includes('..') && !name.includes('\\')));
+        // 只读 tar stdout，不把上游归档解压到任何宿主目录。
+        text += (await run('tar', ['-xOf', file, ...names], {windowsHide: true, maxBuffer: 16 * 1024 * 1024})).stdout + '\n';
+    }
+    return {package: contract.package, version, integrity: metadata.dist.integrity,
+        declarations: declarations.length,
+        missing: inspectDeclarations(text, {...contract, ...contract.versionOverrides?.[version]})};
+}

package/src/client/rollover-ui.js

@@ -5,6 +5,18 @@ export function createRolloverUI(React) {
     const entries = new Map();
     let navigate = null;
     let renderInline = false;
+    const clientWarnings = new Set();
+    function unavailable(feature, error) {
+        clientWarnings.add(feature);
+        console.warn('[dsh-session-rollover] client capability unavailable:', feature, error?.message ?? '');
+    }
+    function inject(ctx, names, setup) {
+        try {
+            ctx.inject(names, scope => {
+                try { return setup(scope); } catch (error) { unavailable(names.join(','), error); }
+            });
+        } catch (error) { unavailable(names.join(','), error); }
+    }
 
     async function request(sessionId, action) {
         const response = await fetch(action ? API : `${API}?session=${encodeURIComponent(sessionId)}`, action ? {
@@ -122,8 +134,8 @@ export function createRolloverUI(React) {
                     h('p', {className: 'dsr-help-credit'}, 'dsh-session-rollover · Oak-liuhj')) : null,
                 h('div', {className: 'dsr-actions-body'},
                     h('button', {type: 'button', 'aria-expanded': showHelp, onClick: () => setShowHelp(!showHelp)}, showHelp ? '收起使用说明' : '使用说明'),
-                    h('button', {type: 'button', disabled: busy || info.sealed || !navigate, onClick: () => action('rollover')}, '现在换会话'),
-                    h('button', {type: 'button', disabled: busy || !navigate, onClick: () => action('new')}, '新建独立会话'),
+                    h('button', {type: 'button', disabled: busy || info.sealed || !navigate || info.compatibility?.compatible === false, onClick: () => action('rollover')}, '现在换会话'),
+                    h('button', {type: 'button', disabled: busy || !navigate || info.compatibility?.compatible === false, onClick: () => action('new')}, '新建独立会话'),
                     h('button', {type: 'button', onClick: () => dialog.current?.close()}, '关闭'))),
             error ? h('span', {role: 'alert'}, error) : null);
     }
@@ -183,6 +195,8 @@ export function createRolloverUI(React) {
         if (!info) return null;
         return h('div', {className: 'dsr-dock'},
             info.error ? h('div', {role: 'alert'}, info.error) : null,
+            info.compatibility?.compatible === false ? h('div', {role: 'alert', className: 'dsr-warning'}, info.compatibility.message) : null,
+            clientWarnings.size ? h('div', {role: 'alert', className: 'dsr-warning'}, '部分会话界面功能与当前 DSH 不兼容，请更新插件。') : null,
             h(ReadonlyControl, {key: props.sessionId, info}),
             info.capped ? h('div', {role: 'status', className: 'dsr-warning'}, '同簇已达 9 卷上限（9/9），请通过会话操作新建独立会话。') : null,
             info.retryLimitReached ? h('div', {role: 'status', className: 'dsr-warning'}, '摘要生成失败，已停止自动重试。可在修正内容后手动换会话。') : null,
@@ -200,7 +214,9 @@ export function createRolloverUI(React) {
 
     /** 释放时仅撤销自己的禁用；保留模型选择等其他插件后来设置的阻塞原因。 */
     function blockComposer(blocks, id, reason) {
+        if (typeof blocks?.storeFor !== 'function' || typeof blocks?.set !== 'function') throw new Error('composer blocks unavailable');
         const store = blocks.storeFor(id);
+        if (typeof store?.getSnapshot !== 'function' || typeof store?.subscribe !== 'function') throw new Error('composer store unavailable');
         let previous = store.getSnapshot();
         const own = {reason};
         let writing = false;
@@ -222,13 +238,15 @@ export function createRolloverUI(React) {
         style.setAttribute('data-dsh-plugin', 'dsh-session-rollover-ui');
         document.head.appendChild(style);
         ctx.effect?.(() => () => { style.remove(); for (const item of entries.values()) item.stop?.(); entries.clear(); });
-        ctx.inject(['uiWorkspace'], scope => {
+        inject(ctx, ['uiWorkspace'], scope => {
+            if (typeof scope.uiWorkspace?.openSession !== 'function') throw new Error('session navigation unavailable');
             navigate = id => scope.uiWorkspace.openSession(id);
             scope.effect?.(() => () => { navigate = null; });
         });
-        ctx.inject(['slots'], scope => {
+        inject(ctx, ['slots'], scope => {
             const slots = scope.slots;
-            const mount = (name, Component, options = {}) => scope.effect(() => slots.inject(name, () => slots.register({name,
+            if (typeof slots?.inject !== 'function' || typeof slots?.register !== 'function') throw new Error('slots unavailable');
+            const mount = (name, Component, options = {}, owner = scope) => owner.effect(() => owner.slots.inject(name, () => owner.slots.register({name,
                 id: 'dsh-session-rollover', order: 35, ...options}, Component)));
             mount('conversation.session.header.actions', Header);
             mount('conversation.input.dock', Dock);
@@ -237,20 +255,27 @@ export function createRolloverUI(React) {
             mount('sidebar.session.row.leading', props => slots.snapshot?.('sidebar.session.row.trailing')?.length
                 ? null : h(Badges, {...props, compact: true}));
             // 使用宿主公开 composer block 服务；覆盖输入组件会破坏其子槽授权。
-            scope.inject(['conversation'], inputScope => {
+            inject(scope, ['conversation'], inputScope => {
+                if (typeof inputScope.conversation?.blocks?.storeFor !== 'function' || typeof inputScope.conversation?.blocks?.set !== 'function') {
+                    throw new Error('composer blocks unavailable');
+                }
                 function ComposerGuard(props) {
                     const info = useInfo(props.sessionId);
                     const reason = !info ? '正在读取会话状态…' : info.readonly
                         ? '归档会话：不可输入，可通过上方开关恢复写入。' : info.error;
-                    useEffect(() => props.sessionId && reason
-                        ? blockComposer(inputScope.conversation.blocks, props.sessionId, reason) : undefined,
+                    useEffect(() => {
+                        if (props.sessionId && reason) {
+                            try { return blockComposer(inputScope.conversation.blocks, props.sessionId, reason); }
+                            catch (error) { unavailable('conversation.blocks', error); }
+                        }
+                    },
                     [props.sessionId, reason]);
                     return null;
                 }
                 inputScope.effect(() => slots.inject('conversation.input.dock', () => slots.register({
                     name: 'conversation.input.dock', id: 'dsr-readonly-guard', order: 34}, ComposerGuard)));
             });
-            scope.inject(['uiConversation'], textScope => {
+            inject(scope, ['uiConversation'], textScope => {
                 if (!textScope.uiConversation.userText?.register) return;
                 textScope.effect(() => textScope.uiConversation.userText.register({id: 'dsr-handoff', order: -100,
                     match(text, from) {
@@ -258,8 +283,10 @@ export function createRolloverUI(React) {
                         const payload = parseHandoff(text);
                         return payload ? {id: 'dsr-handoff', start: 0, end: text.length, data: payload} : undefined;
                     }}));
+                // 插槽必须随 uiConversation 的注入子作用域释放，不能挂在较长寿命的 slots 父作用域。
+                // 新宿主重连/热替换领域服务时会重建该子作用域；挂在父级会重复占用同一个 keyed slot。
                 mount('conversation.user.text.node', props => h(Card, {payload: props.node.data,
-                    source: props.node.data.from_session_id && !props.node.data.cluster?.independent ? {sessionId: props.node.data.from_session_id, title: props.node.data.from_title ?? '上一卷'} : null}), {key: 'dsr-handoff'});
+                    source: props.node.data.from_session_id && !props.node.data.cluster?.independent ? {sessionId: props.node.data.from_session_id, title: props.node.data.from_title ?? '上一卷'} : null}), {key: 'dsr-handoff'}, textScope);
                 renderInline = true;
                 textScope.effect?.(() => () => { renderInline = false; });
             });
@@ -280,5 +307,5 @@ body[data-ds-dark-theme] :is(.dsr-header,.dsr-dock,.dsr-card,.dsr-row-badges),ht
 @media(max-width:600px){.dsr-header{gap:3px;flex-wrap:nowrap;max-width:calc(100vw - 156px)}.dsr-header>.dsr-chip,.dsr-header>.dsr-source{display:none}.dsr-header>.dsr-chip:first-child{display:inline-flex;font-size:10px;padding:1px 3px}}
 @media(prefers-reduced-motion:reduce){.dsr-card *{animation:none!important;transition:none!important}}
 `;
-    return {apply, Header, Dock, Card, Badges, useInfo, parseHandoff, publish, blockComposer, CSS};
+    return {apply, Header, Dock, Card, Badges, useInfo, parseHandoff, publish, blockComposer, clientWarnings, CSS};
 }

package/src/server/compatibility.mjs

@@ -0,0 +1,84 @@
+// 只探测已声明的宿主服务；不根据版本号猜测方法签名，也不在探测时写会话。
+const REQUIRED = {
+    sessions: ['get', 'list'],
+    sessionTitle: ['get', 'rename'],
+    sessionController: ['create', 'prompt', 'selectModel'],
+    sessionProjections: ['stateOf'],
+    workspaceRegistry: ['list'],
+};
+
+export const INCOMPATIBLE_MESSAGE = '当前 DSH 的会话接口与插件不兼容，已暂停分卷。原会话与归档数据保留，请更新插件后重试。';
+
+/** 方法存在只代表能力探测通过；事件语义、权限和界面仍需逐版本验收。 */
+export function inspectHost(ctx, session) {
+    const missing = [];
+    for (const [service, methods] of Object.entries(REQUIRED)) {
+        for (const method of methods) {
+            try { if (typeof ctx[service]?.[method] !== 'function') missing.push(`${service}.${method}`); }
+            catch { missing.push(`${service}.${method}`); }
+        }
+    }
+    if (session && typeof session.snapshotEvents !== 'function') missing.push('session.snapshotEvents');
+    return {contractVersion: 1, compatible: missing.length === 0, missing,
+        message: missing.length ? INCOMPATIBLE_MESSAGE : null};
+}
+
+/** 在创建新卷之前检查同步读取面的形状；遇到变化时停止，不用空数据继续交接。 */
+export function preflightHost(ctx, session, services = ctx) {
+    const report = inspectHost(ctx, session);
+    if (!report.compatible) return report;
+    try {
+        if (!Array.isArray(session.snapshotEvents())) throw new Error('session.snapshotEvents:array-required');
+        const sessions = ctx.sessions.list();
+        if (!Array.isArray(sessions) || sessions.some(s => !s || typeof s.id !== 'string' || !s.id)) {
+            throw new Error('sessions.list:session-id-required');
+        }
+        const workspaces = ctx.workspaceRegistry.list();
+        if (!Array.isArray(workspaces) || workspaces.some(w => !w || typeof w.id !== 'string' || !w.id ||
+            !Array.isArray(w.sessionIds) || w.sessionIds.some(id => typeof id !== 'string'))) {
+            throw new Error('workspaceRegistry.list:sessionIds-required');
+        }
+        const title = ctx.sessionTitle.get(session);
+        if (title != null && (typeof title !== 'object' || typeof title.title !== 'string')) {
+            throw new Error('sessionTitle.get:title-required');
+        }
+        const cwd = readWorkingDirectory(ctx, services, session);
+        if (cwd != null && typeof cwd !== 'string') throw new Error('workingDirectory:string-required');
+        readModelSelection(ctx, services, session);
+    } catch (error) {
+        return {...report, compatible: false, missing: [String(error?.message ?? error)], message: INCOMPATIBLE_MESSAGE};
+    }
+    return report;
+}
+
+/** 新版优先使用领域服务；旧宿主回退到已验证的公开投影入口。 */
+export function readWorkingDirectory(ctx, services, session) {
+    return typeof services.workingDirectory?.get === 'function'
+        ? services.workingDirectory.get(session)
+        : ctx.sessionProjections.stateOf(session, 'workingDirectory');
+}
+
+function validateModel(selection) {
+    if (selection != null && (typeof selection.provider !== 'string' || typeof selection.model !== 'string' ||
+        !selection.provider || !selection.model ||
+        (selection.reasoningEffort != null && typeof selection.reasoningEffort !== 'string'))) {
+        throw new Error('modelSelection:provider-model-required');
+    }
+    return selection;
+}
+
+export function readModelSelection(ctx, services, session) {
+    const agent = services.agents?.get?.(session.id);
+    // 旧宿主也可能提供 agents，但尚无 model.current；此时仍走经过结构校验的投影入口。
+    if (typeof agent?.model?.current === 'function') {
+        const current = validateModel(agent.model.current());
+        if (current != null) return current;
+    }
+    const selection = ctx.sessionProjections.stateOf(session, 'modelSelection');
+    if (selection == null) return undefined;
+    if (typeof selection !== 'object' || Array.isArray(selection) ||
+        !('pending' in selection || 'lastUsed' in selection)) throw new Error('modelSelection:projection-shape-required');
+    validateModel(selection.pending);
+    validateModel(selection.lastUsed);
+    return selection.pending ?? selection.lastUsed;
+}

package/src/server/host-adapter.mjs

@@ -2,6 +2,7 @@
 import {eventType} from '../domain/turns.mjs';
 import {openToolCalls} from '../domain/inflight.mjs';
 import {lastTodos} from '../domain/todos.mjs';
+import {preflightHost, readWorkingDirectory, readModelSelection} from './compatibility.mjs';
 
 /**
  * 为一个来源会话创建适配器。新卷继承其工作区和模型选择。
@@ -14,6 +15,8 @@ import {lastTodos} from '../domain/todos.mjs';
  * @returns {object} performRollover 所需的异步宿主接口
  */
 export function createHostAdapter({ctx, session, state, sessionOf, log, services = ctx}) {
+    const compatibility = preflightHost(ctx, session, services);
+    if (!compatibility.compatible) throw new Error(`host-incompatible: ${compatibility.missing.join(', ')}`);
     const id = session.id;
     const sourceEvents = session.snapshotEvents().slice();
     const registry = services.jobs;
@@ -101,16 +104,17 @@ export function createHostAdapter({ctx, session, state, sessionOf, log, services
         },
         createSession: async () => {
             // 优先归入来源工作区；来源不属于工作区时才按其 cwd 建会话。
-            const cwd = ctx.sessionProjections.stateOf(session, 'workingDirectory');
+            const cwd = readWorkingDirectory(ctx, services, session);
             const workspace = ctx.workspaceRegistry.list().find(w => w.sessionIds.includes(session.id));
-            return ctx.sessionController.create(workspace ? {workspaceId: workspace.id} : typeof cwd === 'string' ? {cwd} : {});
+            const created = await ctx.sessionController.create(workspace ? {workspaceId: workspace.id} : typeof cwd === 'string' ? {cwd} : {});
+            if (!/^[\w-]{1,160}$/.test(created?.sessionId ?? '')) throw new Error('host-incompatible: create.sessionId');
+            return created;
         },
         injectFirstMessage: async (sessionId, text) => {
             // 宿主 create() 建的是空壳会话，没有 model selection，会落到默认 provider
             // （实测 "deepseek-official" 无 key → MISSING_CREDENTIAL）。先继承旧卷的模型，再注入。
             try {
-                const sel = ctx.sessionProjections.stateOf(session, 'modelSelection');
-                const pick = sel?.pending ?? sel?.lastUsed;
+                const pick = readModelSelection(ctx, services, session);
                 if (pick?.provider && pick?.model) {
                     await ctx.sessionController.selectModel({
                         sessionId, provider: pick.provider, model: pick.model,

package/src/server/notice-route.mjs

@@ -54,6 +54,12 @@ export async function handleSessionRequest(plugin, req, res) {
         try { input = JSON.parse(body); } catch { return send(400, {error: 'invalid-json'}); }
         if (!/^[\w-]{1,160}$/.test(input?.sessionId ?? '')) return send(400, {error: 'invalid-session'});
         if (!plugin.sessionOf(input.sessionId)) return send(404, {error: 'session-unavailable'});
+        if (['rollover', 'new'].includes(input.action)) {
+            const compatibility = plugin.handoffInfo(input.sessionId).compatibility;
+            if (compatibility && !compatibility.compatible) {
+                return send(503, {error: 'host-incompatible', message: compatibility.message, compatibility});
+            }
+        }
         if (input.action === 'readonly' && typeof input.readonly === 'boolean') {
             if (!plugin.handoffInfo(input.sessionId).sealed) return send(409, {error: 'session-not-archived'});
             return send(200, plugin.setReadonly(input.sessionId, input.readonly));

package/src/server/plugin.mjs

@@ -11,6 +11,7 @@ import {transitionInFlight} from '../domain/mode.mjs';
 import {createNoticeStore} from '../storage/notices.mjs';
 import {createHostAdapter} from './host-adapter.mjs';
 import {attachNoticeRoutes, handlePendingNotices} from './notice-route.mjs';
+import {inspectHost, preflightHost, INCOMPATIBLE_MESSAGE} from './compatibility.mjs';
 
 const inflightKey = (id) => `rollover:${id}`;
 
@@ -27,6 +28,7 @@ const NOTICE_TEXT = {
     'cluster-cap': '同簇已达 9 卷上限，请新建独立会话继续。',
     'storage-unavailable': '分卷数据目录不可写，已保留原会话，请检查目录后重试。',
     'user-renamed': '已保留手动设置的会话名称。',
+    'host-incompatible': INCOMPATIBLE_MESSAGE,
 };
 
 /**
@@ -52,9 +54,10 @@ export default class SessionRolloverPlugin {
         this.ctx = ctx;
         this.services = typeof ctx.inject === 'function' ? {} : ctx;
         if (ctx.inject) {
-            for (const name of ['jobs', 'agentDefaultModel']) ctx.inject([name], scope => {
-                this.services[name] = scope[name];
-                scope.effect?.(() => () => { delete this.services[name]; });
+            for (const name of ['jobs', 'agentDefaultModel', 'workingDirectory', 'agents']) ctx.inject([name], scope => {
+                const service = scope[name];
+                this.services[name] = service;
+                scope.effect?.(() => () => { if (this.services[name] === service) delete this.services[name]; });
             });
         }
         this.config = {mode: 'auto', threshold: DEFAULT_THRESHOLD, ...config};
@@ -72,6 +75,7 @@ export default class SessionRolloverPlugin {
             rollover: (id) => this.rolloverNow(id),
             info: (id) => this.handoffInfo(id),
             setReadonly: (id, value) => this.setReadonly(id, value),
+            compatibility: () => inspectHost(this.ctx),
         });
         ctx.effect(() => () => {
             this.busy.clear();
@@ -87,6 +91,7 @@ export default class SessionRolloverPlugin {
         this.log('boot', {
             dataDir: this.dataDir, mode: this.config.mode, threshold: this.config.threshold,
             degraded: this.persistence.degraded, notices: this.notices.path, noticesDegraded: this.notices.degraded,
+            compatibility: inspectHost(ctx),
         });
     }
 
@@ -126,13 +131,21 @@ export default class SessionRolloverPlugin {
 
     /** 启动修复缓存缺项；失败注入产生的待清理卷不参与有效父链。 */
     reconcileIndex() {
+        if (!inspectHost(this.ctx).compatible) return;
+        let sessions;
+        try { sessions = this.ctx.sessions.list(); } catch { return; }
+        if (!Array.isArray(sessions)) return;
         let changed = false;
         const abandoned = new Set(this.state.pendingList().map(r => r.sessionId));
         const snapshots = new Map();
-        for (const session of this.ctx.sessions.list()) {
+        for (const session of sessions) {
+            if (!session || typeof session.id !== 'string') continue;
             if (abandoned.has(session.id)) continue;
             let h;
-            for (const e of session.snapshotEvents()) {
+            let events;
+            try { events = session.snapshotEvents(); } catch { continue; }
+            if (!Array.isArray(events)) continue;
+            for (const e of events) {
                 const text = textOf(e);
                 if (!text.startsWith('【分卷交接】')) continue;
                 try { h = JSON.parse(/```json\s*([\s\S]*?)```/.exec(text)?.[1]); } catch { /* 非本插件快照 */ }
@@ -204,20 +217,24 @@ export default class SessionRolloverPlugin {
         const parent = handoff?.cluster?.independent ? null : handoff?.from_session_id ?? record?.parent_session_id;
         let title = handoff?.from_title || parent;
         const source = parent && this.sessionOf(parent);
-        if (source) title = this.ctx.sessionTitle.get(source)?.title || title;
+        if (source) { try { title = this.ctx.sessionTitle.get(source)?.title || title; } catch {} }
         const session = this.sessionOf(id);
-        const events = session?.snapshotEvents() ?? [];
+        let events = [];
+        try { const snapshot = session?.snapshotEvents?.(); if (Array.isArray(snapshot)) events = snapshot; } catch {}
+        let sessionTitle = '';
+        try { sessionTitle = session ? this.ctx.sessionTitle.get(session)?.title ?? '' : ''; } catch {}
         const sealed = record?.rollover_state === 'sealed';
         const turnCount = countTurns(events);
         const children = record ? this.index.cluster(record.cluster_id).filter(r => r.parent_session_id === id) : [];
         const retry = this.state.retryGet(id).attempts;
         return {source: parent ? {sessionId: parent, title} : null, handoff,
             readonly: this.isReadonly(id), sealed, sessionId: id,
-            title: session ? this.ctx.sessionTitle.get(session)?.title ?? '' : '',
+            title: sessionTitle,
+            compatibility: session ? preflightHost(this.ctx, session, this.services) : inspectHost(this.ctx),
             turnCount, threshold: this.config.threshold, volume: record?.vol_no ?? null, cap: 9,
             capped: record?.vol_no >= 9, summaryRetry: retry,
             retryLimitReached: retry >= 3, degraded: this.persistence.degraded || !!this.stateDegraded?.has(id),
-            previousTurnCount: parent && this.sessionOf(parent) ? countTurns(this.sessionOf(parent).snapshotEvents()) : null,
+            previousTurnCount: source ? (() => { try { const e = source.snapshotEvents(); return Array.isArray(e) ? countTurns(e) : null; } catch { return null; } })() : null,
             nextSessionId: children[0]?.sessionId ?? null};
     }
 
@@ -241,6 +258,8 @@ export default class SessionRolloverPlugin {
     async rolloverNow(id) {
         const session = this.sessionOf(id);
         if (!session) return {status: 'failed', reason: 'session-unavailable'};
+        const compatibility = preflightHost(this.ctx, session, this.services);
+        if (!compatibility.compatible) return {status: 'failed', reason: 'host-incompatible', compatibility};
         if (this.busy.has(inflightKey(id))) return {status: 'skipped', reason: 'busy'};
         if (this.index.get(id)?.rollover_state === 'sealed') return {status: 'skipped', reason: 'readonly'};
         this.busy.add(inflightKey(id));
@@ -300,6 +319,11 @@ export default class SessionRolloverPlugin {
         const session = agent?.session;
         if (!session?.id) return;
         const id = session.id;
+        const compatibility = preflightHost(this.ctx, session, this.services);
+        if (!compatibility.compatible) {
+            this.notifyOnce(session, {reason: 'host-incompatible'});
+            return;
+        }
         if (this.busy.has(inflightKey(id))) return;
         // 已封卷的 -N 永不再分卷：B9 的手动开关只放行「在旧卷继续写」，不等于再开新卷。
         try {