dsh-kingdom 3.2.0 → 3.2.1

package/docs/V3.2-RELEASE-NOTES.md

@@ -1,103 +1,108 @@
-# dsh-Kingdom 3.2.0 本地候选说明
-
-3.2.0 只有两类产品变更：**主管与领地的完全绑定**（任命时必须同时指定领地、一个主管只主理一个
-领地，席位与主理同一事务原子写入；退任时同时解除主理）与**交付区版面修复**（控制区不再抢宽导致
-正文退化成竖排）。没有新增表、没有新增迁移，沿用 schema v4 与既有事件类型。
-
-## 验证状态（本轮实际执行过的）
-
-| 项 | 结果 |
-|---|---|
-| `npm run typecheck`（`tsc -p tsconfig.json --noEmit`） | 通过，0 错误 |
-| 全量 `node --test tests/*.test.ts` | 594 项：**592 通过 / 0 失败 / 2 跳过**（2 项在 Windows 上跳过：1 项是 `process.platform === 'win32'` 的平台门，1 项是宿主无法创建符号链接时的运行时跳过） |
-| 新增定向用例 `tests/v320-supervisor-territory-binding.test.ts` | 6/6 通过（AC1–AC5 + 事务嵌套） |
-| `scripts/p2-smoke.mjs` | 36/36 通过 |
-| `scripts/p3-smoke.mjs` | 19/19 通过 |
-| `scripts/hotplug-audit.mjs` | 26/26 通过 |
-
-**未执行（NOT_RUN）**：发布门 `scripts/release.ps1 -DryRun`（须在干净工作区、冻结提交后运行）；
-真实浏览器人工交互验收（含新版表单在四种主题与窄屏下的实际观感）；把本版 tgz 装进本机
-profile 后的 DSH `0.1.7-rc.2` 实机加载回归；Linux 平台；收益与成本测量。未运行过的项不得当作
-已通过。本版发布前的独立审查结论与 Owner 验收记录见发布回执（不在包内）。
-
-## 1. 主管与领地完全绑定
-
-**问题**：此前"任命主管"与"指定它的领地"是两条独立命令。中途放弃第二步，就会留下一个没有
-领地的在任主管：席位显示已任命，GUI 里那块领地却仍显示"没有主管"，而治理操作按
-`TERRITORY_SUPERVISOR_MISSING` fail-closed。
-
-**现在的规则**（Owner 口径 2026-09-28 + 1:1 裁定 2026-09-29）：
-
-- **任命主管必须同时给出领地**：`role.bind` 的 `role_type=SUPERVISOR` 需要 `territory_id`；
-  缺省即拒绝，不写入任何事实。非主管角色携带 `territory_id` 同样拒绝（不静默忽略）。
-- **同一事务原子写入**：席位与「该领地的主理」一起提交或一起回滚。领地侧被拒时，已经插入的
-  席位随事务回滚，**不会**留下"有主管、没领地"的中间态。
-- **不静默替换在任主理**：目标领地已有**在任 ACTIVE** 主理时，改派被拒绝并提示先解除；
-  解除（`supervisor_binding_id: null`）后再指派。指向**已退任席位**的历史悬挂引用属于修复，
-  可以直接改派（direct Slash 与 Owner GUI 窗口是同一条判据）。
-- **一个主管席位只主理一个领地（1:1）**：席位已隶属其它未删除领地时，指派被拒绝并提示先解除
-  原领地的主理。要在领地之间移动一个主管，必须"先解除原领地，再指派到新领地"。
-  已被删除（tombstone）的领地不参与治理，其历史指针不锁住席位。
-- **退任联动**：`role.unbind` 退任一个主管时，**同一事务**里解除它在领地上的主理关系并写出一条
-  明确的解除事实（`TERRITORY_SUPERVISOR_UPDATED`，`unassigned: true`），不留下指向 RETIRED
-  席位的悬挂引用。
-- **存量未隶属席位**：3.2.0 之前建立的、没有领地的在任主管**不会被自动归属**。席位投影会给出
-  它实际主理的领地列表，为空时由界面标注「未隶属领地（待处理）」，由 Owner 决定指派或解除。
-  这类遗留席位同样受 1:1 约束（已经主理某领地的席位不会被自动改派）。
-
-命令与界面：
-
-```
-/kingdom role.bind {"role_type":"SUPERVISOR","role_name":"主理","territory_id":"<领地 id>","session_id":"<真实 DSH session>"}
-/kingdom role.bind {"role_type":"WORKER","role_name":"执行者"}                 # 非主管不带 territory_id
-/kingdom territory.supervisor {"territory_id":"...","supervisor_binding_id":null}   # 解除该领地主理
-/kingdom role.unbind {"binding_id":"<主管 binding id>","reason":"换届"}        # 同时解除其领地主理
-```
-
-Owner GUI 管理窗口的 `role.bind` 表单在角色为主管时出现**必选**领地下拉（内容来自本次授权范围
-目录），其它角色隐藏该字段；`kingdom_draft_owner_binding_intent` 的自然语言草案对主管改为
-**单步**可执行命令（`role.bind` 自带 `territory_id`），不再是旧的两步。
-
-**领地范围判据**：主管任命的目标领地必须**显式**出现在本次管理窗口的授权范围内
-（`catalog.territories` 与提交判定完全一致，不用 `kingdomWide` 放宽）。若要在窗口里给新建的
-领地任命主管，请重新激活一个包含该领地的窗口。
-
-**管理窗口现在也能解除主理**：`territory.supervisor` 的 `supervisor_binding_id` 接受**显式 `null`**
-（表单上是"解除现任主理（不指派新主管）"勾选框；省略该字段仍是输入错误，不会被当成解除）。
-因此 1:1 之下"把主理从领地 A 换到领地 B"可以完全在窗口里完成：先在 A 上解除、再到 B 上指派。
-解除同样受未结算执行守卫约束（有在途工作时不允许解除责任），预览会写清"解除后该领地无主理 →
-fail-closed 直到指派新的"。
-
-**存量数据的说明**：3.2.0 之前可能留下两类与上面规则不符的存量——① 没有隶属领地的在任主管席位；
-② 一个席位同时挂在多个领地（旧能力允许）。本版**不会自动收敛**它们：① 只作可见标注，② 只约束
-**新的**指派。两者在退任时都会被一并解除（退任联动遍历该席位名下的所有未删除领地）。
-
-**事务嵌套**：直接 Slash 的 `ownerWrite` 与 Owner GUI 窗口的 `apply` 各自已经开了一层事务，
-而这条原子通道还要求自己的边界。`KingdomStore.withImmediateTransaction` 因此改为真正的嵌套：
-外层 `BEGIN IMMEDIATE`/`COMMIT`/`ROLLBACK`，内层 `SAVEPOINT`/`RELEASE`/`ROLLBACK TO`。
-只做"加入外层"是不够的——内层把拒绝变成返回文案时，它已写下的行会留在外层事务里被提交。
-`schema`、表结构与事件类型均未改动。
-
-**边界**：`bindRole()` 仍是低层原语，本身不承载"主管必须有领地"这条策略；策略在全部 Owner 入口
-（direct Slash、Owner GUI 窗口、GUI 表单）强制执行，并统一由 `bindSupervisorForTerritory` 完成
-原子写入。这样既保证产品层面不存在"有主管、没领地"的创建路径，又不改动只用于构造测试夹具的
-低层调用。Agent Tool（`kingdom_bind_role` 等）依旧是 zero-write。
-
-**未结算执行的拦截范围（3.2.0 审计 r1 更正）**：`UNSETTLED_EXECUTION` / `UNSETTLED_LEASE` /
-`UNSETTLED_DISPATCH` 守卫只覆盖 **Owner 管理窗口**这条路径（`guardUnsettled`）。direct Slash 与
-core 的 `role.bind` / `territory.supervisor` **没有**等价守卫——这是 3.1.0 的既有语义，本版没有
-改动它，文档也不得声称"旧主管的未结算执行一定会拦住改派"。需要该守卫时请走 Owner 管理窗口。
-
-## 2. 交付区版面修复
-
-交付条目的控制区里有一条 `flex: 1 0 100%` 的状态文本，而它在 `grid-template-columns:
-minmax(0, 1fr) auto` 的右列（`auto` = max-content）里。右轨被撑到最宽，左轨被压成 0 宽，
-正文因此退化成每行一两个字、竖排显示。现在改成分行 flex：正文占弹性主列（20rem 起），
-控制区按自身内容窄排，放不下时整体换行。这是纯 CSS 改动，不改变任何数据、事件或判断。
-交付条目里显示的 `UNKNOWN` 是**数据**（v1.0.0 旧格式的弱接受证据），产品按设计不推断。
-
-## 不适用范围
-
-- 不改 schema，不新增迁移；不改 Owner Control Plane 的授权模型。
-- 不改 `resolveTrustedToolSession`，不改 3.1.0 的 peer 分线声明。
-- 不处理 3.1.0 审计遗留的文档残留（另行处理）。
+# dsh-Kingdom 3.2.0 本地候选说明
+
+3.2.0 只有两类产品变更：**主管与领地的完全绑定**（任命时必须同时指定领地、一个主管只主理一个
+领地，席位与主理同一事务原子写入；退任时同时解除主理）与**交付区版面修复**（控制区不再抢宽导致
+正文退化成竖排）。没有新增表、没有新增迁移，沿用 schema v4 与既有事件类型。
+
+## 验证状态（本轮实际执行过的）
+
+| 项 | 结果 |
+|---|---|
+| `npm run typecheck`（`tsc -p tsconfig.json --noEmit`） | 通过，0 错误 |
+| 全量 `node --test tests/*.test.ts` | 596 项：**594 通过 / 0 失败 / 2 跳过**（2 项在 Windows 上跳过：1 项是 `process.platform === 'win32'` 的平台门，1 项是宿主无法创建符号链接时的运行时跳过） |
+| 新增定向用例 `tests/v320-supervisor-territory-binding.test.ts` | 6/6 通过（AC1–AC5 + 事务嵌套） |
+| `tests/owner-window.test.ts` | 28/28 通过（含"窗口解除主理"与"缺字段/范围外拒绝"两个新用例） |
+| `scripts/p2-smoke.mjs` | 36/36 通过 |
+| `scripts/p3-smoke.mjs` | 19/19 通过 |
+| `scripts/hotplug-audit.mjs` | 26/26 通过 |
+| 发布门 `pwsh -File scripts/release.ps1 -Version 3.2.0 -DryRun` | **P0–P3 全 PASS**（在提交 `075e410` 后的干净工作树运行；P3 产出 `dsh-kingdom-3.2.0.tgz`，722 669 字节，SHA-256 `6d40dc00d3457b223850f66cfa5a3ed0f2c42588d9e2042037607147ec7e3053`） |
+| GitHub Actions（push 到 `main`，ubuntu-latest / Node 24） | 成功（typecheck + 全量测试 + 三个 smoke + `npm pack --dry-run`） |
+| 独立审查 | `AUDIT_PASS`（AC1–AC7 全 PASS；AC8 的发布门在提交后补跑通过）。审查只读，未改动候选 |
+| npm | `dsh-kingdom@3.2.0` 已发布（`latest`），shasum `0bc97ac894519774a4aaf773bdc343a6aa74a946`；从 registry 取回的 tgz 与上面冻结的 tgz **字节一致** |
+
+**未执行（NOT_RUN）**：真实浏览器人工交互验收（新表单的"解除现任主理"勾选框与四种主题/窄屏下的
+实际观感；交付区版面只有"同源 CSS + 同构 DOM"的等效渲染对比）；把本版 tgz 装进本机 profile 后的
+DSH `0.1.7-rc.2` 实机加载回归；Linux 之外平台的产品行为；收益与成本测量；Owner 正式验收。
+未运行过的项不得当作已通过。
+
+## 1. 主管与领地完全绑定
+
+**问题**：此前"任命主管"与"指定它的领地"是两条独立命令。中途放弃第二步，就会留下一个没有
+领地的在任主管：席位显示已任命，GUI 里那块领地却仍显示"没有主管"，而治理操作按
+`TERRITORY_SUPERVISOR_MISSING` fail-closed。
+
+**现在的规则**（Owner 口径 2026-09-28 + 1:1 裁定 2026-09-29）：
+
+- **任命主管必须同时给出领地**：`role.bind` 的 `role_type=SUPERVISOR` 需要 `territory_id`；
+  缺省即拒绝，不写入任何事实。非主管角色携带 `territory_id` 同样拒绝（不静默忽略）。
+- **同一事务原子写入**：席位与「该领地的主理」一起提交或一起回滚。领地侧被拒时，已经插入的
+  席位随事务回滚，**不会**留下"有主管、没领地"的中间态。
+- **不静默替换在任主理**：目标领地已有**在任 ACTIVE** 主理时，改派被拒绝并提示先解除；
+  解除（`supervisor_binding_id: null`）后再指派。指向**已退任席位**的历史悬挂引用属于修复，
+  可以直接改派（direct Slash 与 Owner GUI 窗口是同一条判据）。
+- **一个主管席位只主理一个领地（1:1）**：席位已隶属其它未删除领地时，指派被拒绝并提示先解除
+  原领地的主理。要在领地之间移动一个主管，必须"先解除原领地，再指派到新领地"。
+  已被删除（tombstone）的领地不参与治理，其历史指针不锁住席位。
+- **退任联动**：`role.unbind` 退任一个主管时，**同一事务**里解除它在领地上的主理关系并写出一条
+  明确的解除事实（`TERRITORY_SUPERVISOR_UPDATED`，`unassigned: true`），不留下指向 RETIRED
+  席位的悬挂引用。
+- **存量未隶属席位**：3.2.0 之前建立的、没有领地的在任主管**不会被自动归属**。席位投影会给出
+  它实际主理的领地列表，为空时由界面标注「未隶属领地（待处理）」，由 Owner 决定指派或解除。
+  这类遗留席位同样受 1:1 约束（已经主理某领地的席位不会被自动改派）。
+
+命令与界面：
+
+```
+/kingdom role.bind {"role_type":"SUPERVISOR","role_name":"主理","territory_id":"<领地 id>","session_id":"<真实 DSH session>"}
+/kingdom role.bind {"role_type":"WORKER","role_name":"执行者"}                 # 非主管不带 territory_id
+/kingdom territory.supervisor {"territory_id":"...","supervisor_binding_id":null}   # 解除该领地主理
+/kingdom role.unbind {"binding_id":"<主管 binding id>","reason":"换届"}        # 同时解除其领地主理
+```
+
+Owner GUI 管理窗口的 `role.bind` 表单在角色为主管时出现**必选**领地下拉（内容来自本次授权范围
+目录），其它角色隐藏该字段；`kingdom_draft_owner_binding_intent` 的自然语言草案对主管改为
+**单步**可执行命令（`role.bind` 自带 `territory_id`），不再是旧的两步。
+
+**领地范围判据**：主管任命的目标领地必须**显式**出现在本次管理窗口的授权范围内
+（`catalog.territories` 与提交判定完全一致，不用 `kingdomWide` 放宽）。若要在窗口里给新建的
+领地任命主管，请重新激活一个包含该领地的窗口。
+
+**管理窗口现在也能解除主理**：`territory.supervisor` 的 `supervisor_binding_id` 接受**显式 `null`**
+（表单上是"解除现任主理（不指派新主管）"勾选框；省略该字段仍是输入错误，不会被当成解除）。
+因此 1:1 之下"把主理从领地 A 换到领地 B"可以完全在窗口里完成：先在 A 上解除、再到 B 上指派。
+解除同样受未结算执行守卫约束（有在途工作时不允许解除责任），预览会写清"解除后该领地无主理 →
+fail-closed 直到指派新的"。
+
+**存量数据的说明**：3.2.0 之前可能留下两类与上面规则不符的存量——① 没有隶属领地的在任主管席位；
+② 一个席位同时挂在多个领地（旧能力允许）。本版**不会自动收敛**它们：① 只作可见标注，② 只约束
+**新的**指派。两者在退任时都会被一并解除（退任联动遍历该席位名下的所有未删除领地）。
+
+**事务嵌套**：直接 Slash 的 `ownerWrite` 与 Owner GUI 窗口的 `apply` 各自已经开了一层事务，
+而这条原子通道还要求自己的边界。`KingdomStore.withImmediateTransaction` 因此改为真正的嵌套：
+外层 `BEGIN IMMEDIATE`/`COMMIT`/`ROLLBACK`，内层 `SAVEPOINT`/`RELEASE`/`ROLLBACK TO`。
+只做"加入外层"是不够的——内层把拒绝变成返回文案时，它已写下的行会留在外层事务里被提交。
+`schema`、表结构与事件类型均未改动。
+
+**边界**：`bindRole()` 仍是低层原语，本身不承载"主管必须有领地"这条策略；策略在全部 Owner 入口
+（direct Slash、Owner GUI 窗口、GUI 表单）强制执行，并统一由 `bindSupervisorForTerritory` 完成
+原子写入。这样既保证产品层面不存在"有主管、没领地"的创建路径，又不改动只用于构造测试夹具的
+低层调用。Agent Tool（`kingdom_bind_role` 等）依旧是 zero-write。
+
+**未结算执行的拦截范围（3.2.0 审计 r1 更正）**：`UNSETTLED_EXECUTION` / `UNSETTLED_LEASE` /
+`UNSETTLED_DISPATCH` 守卫只覆盖 **Owner 管理窗口**这条路径（`guardUnsettled`）。direct Slash 与
+core 的 `role.bind` / `territory.supervisor` **没有**等价守卫——这是 3.1.0 的既有语义，本版没有
+改动它，文档也不得声称"旧主管的未结算执行一定会拦住改派"。需要该守卫时请走 Owner 管理窗口。
+
+## 2. 交付区版面修复
+
+交付条目的控制区里有一条 `flex: 1 0 100%` 的状态文本，而它在 `grid-template-columns:
+minmax(0, 1fr) auto` 的右列（`auto` = max-content）里。右轨被撑到最宽，左轨被压成 0 宽，
+正文因此退化成每行一两个字、竖排显示。现在改成分行 flex：正文占弹性主列（20rem 起），
+控制区按自身内容窄排，放不下时整体换行。这是纯 CSS 改动，不改变任何数据、事件或判断。
+交付条目里显示的 `UNKNOWN` 是**数据**（v1.0.0 旧格式的弱接受证据），产品按设计不推断。
+
+## 不适用范围
+
+- 不改 schema，不新增迁移；不改 Owner Control Plane 的授权模型。
+- 不改 `resolveTrustedToolSession`，不改 3.1.0 的 peer 分线声明。
+- 不处理 3.1.0 审计遗留的文档残留（另行处理）。

package/docs/V3.2.1-RELEASE-NOTES.md

@@ -0,0 +1,39 @@
+# dsh-Kingdom 3.2.1
+
+3.2.1 修复派发、恢复和授权事务中的正确性缺口。它在已发布的3.2.0上合入有限整改，保留主管与领地完全绑定、交付记录、schema v4和既有DSH兼容范围。没有数据库迁移。
+
+## 本版变化
+
+- **派发前保存关联。** 每次派发先生成Kingdom ID，并可由Adapter纯准备一个独立Runtime消息引用。在Runtime入队前，Execution、Lease、Dispatch Intent和计划引用已提交。计划引用不是接受回执。
+- **可靠Receipt经过持久化屏障。** DSH prepared消息和单次token绑定Adapter、Session、文本与两端引用。只有公开` sessions.flush `返回true才返回可靠Receipt。缺失、false、异常或超时不会触发重发；同一token不能再次入队。Receipt必须匹配已提交的Runtime/instance/Session/ref。
+- **丢回执或原上下文后可只读对账。** 当前主管可通过Tool或GUI查询同一计划引用。新Adapter只读live或公开持久化事件，不resume、不补Receipt、不建执行权限、不生成Claim、不清理或释放Lease。读取最多10000事件，每次持久化操作最多5000ms；读取前后重验授权及关键账本关系。
+- **收紧事务授权。** 受理及派发事务内重新验证原调用者；ACCEPT重新确认主管绑定和Task领地，使用条件状态更新，变化时整体拒绝或回滚。3.2的交付改动证据与SAVEPOINT嵌套事务保持有效。
+- **明确资源占用。** 占用提示提供有界、脱敏的执行/租约引用，并要求前序结束或对账后重新请求；没有自动排队。
+- **计划引用不计作已接受执行。** 用量入口和事务内持久化都要求精确引用及Receipt。稀疏或损坏事件数组按不可读处理。
+
+## 验证范围
+
+本版新基线在Windows/Node24下执行：
+
+| 验证 | 结果 |
+|---|---|
+| TypeScript typecheck和当前源码构建 | 通过 |
+| 完整TS测试与新增探针契约测试 | 665项：663通过、0失败、2跳过（平台条件） |
+| 隔离governance / GUI / lifecycle smoke | 36 / 19 / 26项全部通过 |
+| 官方0.1.5-rc.2实际组件产品探针 | 两例通过：flush后强杀再读为QUEUED；COMMIT后未发送再读为UNKNOWN |
+| 官方0.1.7-rc.2实际组件产品探针 | 同上两例通过 |
+| 两条线的产品探针数据不变断言 | Core行/事件不变，Receipt缺失，Claim0，模型turn0 |
+
+真实探针经过本版Adapter准备、Core TX-3、DSH入队/flush、owned writer强杀和fresh reader公开只读读取。Authority/Binding/Capability/enforcement前置使用隔离fake fixture，未加载Provider；它证明消息关联与持久化读取，不是完整受治理模型执行。Requested model为null，effective model为UNKNOWN。更多API与证据边界见[探针说明](DISPATCH-IDENTITY-PROBE.md)。
+
+本版还覆盖真实子进程提交边界与两个进程竞争同Session Lease；这些SQLite测试的Runtime为明确fake，不把它们当作DSH执行证明。首次全量检查发现的两处旧fixture缺flush和稀疏数组回归已修复，最终结果如上。
+
+## 升级与保留边界
+
+安装准确的`dsh-kingdom-3.2.1.tgz`或从官方npm获取`dsh-kingdom@3.2.1`。升级前核对未决执行并一致备份SQLite；本版不对正式数据库进行自动迁移或作废旧执行。
+
+找到精确输入是正观察；**找不到输入仍为UNKNOWN，不能证明未派发、已停机或可安全重试**。排队输入可能在未来resume时执行。本版没有安全作废按钮、冷启动Fence/cleanup重建、子目录WRITE并发、PostgreSQL或SSE。
+
+0.1.7的公开snapshot兼容读取已deprecated；本版既有兼容面仍使用该API，持久化冷读使用公开handle。未来Runtime版本需要单独验证，不能外推。完整付费Provider、真人GUI验收、任意旧库迁移和生产性能没有在本次发布中执行。
+
+GitHub Release与npm的公开版本、资产及integrity是发布状态的核对入口；打包/CI不等于Owner最终验收或Kingdom Task DONE。

package/lib/adapter/dsh-backend.js

@@ -14,7 +14,7 @@
 import { randomUUID } from 'node:crypto';
 import { cleanupDshEnforcement, materializeDshEnforcement, readEnforceableSet, } from '../capability/dsh-enforcement.js';
 import { terminalOutcomeOf } from '../dispatch/evidence.js';
-import { locateDshDispatchRef, readDshSessionEvents } from './dsh-session-events.js';
+import { DSH_RECONCILE_EVENT_LIMIT, locateDshDispatchRef, readBoundedDshSessionEvents, readDshSessionEvents, } from './dsh-session-events.js';
 /** Deliberately not exported: only this backend can issue a fence token. */
 class DshTrustFenceToken {
     // Runtime identity is checked through an Adapter-instance-private WeakMap;
@@ -48,6 +48,28 @@ function boundedFenceReason(value) {
 function fenceResult(ok, status, reservation, generation, reason) {
     return { ok, status, reservation, generation, reason: boundedFenceReason(reason) };
 }
+const DEFAULT_DSH_IO_TIMEOUT_MS = 5000;
+/** Timeout never cancels/resends a Runtime operation; its outcome stays uncertain. */
+async function boundedWait(operation, milliseconds, code) {
+    let timer;
+    try {
+        return await Promise.race([
+            operation,
+            new Promise((_resolve, reject) => { timer = setTimeout(() => reject(new Error(code)), milliseconds); }),
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+function freezeUserMessage(text) {
+    const message = buildUserMessage(text);
+    Object.freeze(message.content[0]);
+    Object.freeze(message.content);
+    Object.freeze(message.source);
+    return Object.freeze(message);
+}
 function asAgents(value) {
     return value;
 }
@@ -120,6 +142,8 @@ export class DshRuntimeAdapter {
     runtimeType = 'dsh';
     /** Fence tokens are accepted only by the exact Adapter instance that issued them. */
     trustFenceStates = new WeakMap();
+    /** The exposed ref cannot replace the original single-use preparation token. */
+    preparedDispatches = new WeakMap();
     deps;
     constructor(deps) {
         this.deps = {
@@ -128,6 +152,10 @@ export class DshRuntimeAdapter {
             model: deps.model ?? null,
             agents: asAgents(deps.agents),
             sessionPersistence: asPersistence(deps.sessionPersistence),
+            sessions: deps.sessions,
+            dispatchFlushTimeoutMs: Number.isFinite(deps.dispatchFlushTimeoutMs) && (deps.dispatchFlushTimeoutMs ?? 0) > 0
+                ? Math.min(deps.dispatchFlushTimeoutMs, DEFAULT_DSH_IO_TIMEOUT_MS)
+                : DEFAULT_DSH_IO_TIMEOUT_MS,
             presets: asPresets(deps.presets),
             policy: {
                 toolDisclosure: deps.toolDisclosure,
@@ -535,12 +563,80 @@ export class DshRuntimeAdapter {
         return materializeDshEnforcement(this.deps.policy, ctx, request);
     }
     // ── Dispatch / Evidence / Reconcile ────────────────────────────────────────
+    async prepareDispatch(input) {
+        if (!input.kingdomDispatchId.trim() || !input.sessionRef.trim())
+            throw new Error('dsh prepare: DISPATCH_IDENTITY_REQUIRED');
+        const agent = this.deps.agents.get(input.sessionRef);
+        if (!agent || agent.id !== input.sessionRef)
+            throw new Error('dsh prepare: EXACT_LIVE_SESSION_REQUIRED');
+        const message = freezeUserMessage(input.text);
+        const baseline = readDshSessionEvents(agent.session);
+        if (baseline === null)
+            throw new Error('dsh prepare: BASELINE_UNREADABLE');
+        if (locateDshDispatchRef(baseline, message.id) >= 0)
+            throw new Error('dsh prepare: RUNTIME_REF_ALREADY_PRESENT');
+        const token = Object.freeze({ runtimeDispatchRef: message.id });
+        this.preparedDispatches.set(token, {
+            kingdomDispatchId: input.kingdomDispatchId,
+            sessionRef: input.sessionRef,
+            text: input.text,
+            message,
+            agent,
+            session: agent.session,
+            used: false,
+        });
+        return token;
+    }
     async dispatch(input) {
         const agent = this.deps.agents.get(input.sessionRef);
         if (!agent)
             throw new Error(`dsh dispatch: session ${input.sessionRef} 不在 live registry（无法 dispatch）`);
-        const message = buildUserMessage(input.text);
-        agent.followup(message); // 持久 splice 插入即「已接受」
+        let message;
+        if (input.preparedDispatch !== undefined) {
+            const prepared = input.preparedDispatch !== null && typeof input.preparedDispatch === 'object'
+                ? this.preparedDispatches.get(input.preparedDispatch)
+                : undefined;
+            if (!prepared)
+                throw new Error('dsh dispatch: UNKNOWN_PREPARED_TOKEN');
+            if (prepared.used)
+                throw new Error('dsh dispatch: PREPARED_TOKEN_ALREADY_USED');
+            if (prepared.kingdomDispatchId !== input.kingdomDispatchId || prepared.sessionRef !== input.sessionRef
+                || prepared.text !== input.text || prepared.agent !== agent || prepared.session !== agent.session
+                || agent.id !== input.sessionRef || prepared.message.id !== input.preparedDispatch.runtimeDispatchRef) {
+                throw new Error('dsh dispatch: PREPARED_IDENTITY_MISMATCH');
+            }
+            if (typeof this.deps.sessions?.flush !== 'function')
+                throw new Error('dsh dispatch: DURABILITY_BARRIER_UNAVAILABLE');
+            const baseline = readDshSessionEvents(agent.session);
+            if (baseline === null)
+                throw new Error('dsh dispatch: BASELINE_UNREADABLE');
+            if (locateDshDispatchRef(baseline, prepared.message.id) >= 0)
+                throw new Error('dsh dispatch: RUNTIME_REF_ALREADY_PRESENT');
+            // Consume before any side effect. A thrown followup or uncertain barrier
+            // must never make this token usable for an automatic second send.
+            prepared.used = true;
+            message = prepared.message;
+            agent.followup(message);
+            let durable;
+            try {
+                durable = await boundedWait(Promise.resolve(this.deps.sessions.flush(agent.session)), this.deps.dispatchFlushTimeoutMs, 'dsh dispatch: DURABILITY_BARRIER_TIMEOUT');
+            }
+            catch (error) {
+                throw new Error(error instanceof Error && error.message === 'dsh dispatch: DURABILITY_BARRIER_TIMEOUT'
+                    ? 'dsh dispatch: DURABILITY_BARRIER_TIMEOUT'
+                    : 'dsh dispatch: DURABILITY_BARRIER_UNCERTAIN');
+            }
+            if (durable !== true)
+                throw new Error('dsh dispatch: DURABILITY_BARRIER_NOT_CONFIRMED');
+        }
+        else {
+            // Explicit compatibility seam for historical direct Adapter consumers;
+            // correlated governed dispatch cannot fall back to this non-durable path.
+            if (input.kingdomDispatchId !== undefined)
+                throw new Error('dsh dispatch: PREPARED_TOKEN_REQUIRED');
+            message = buildUserMessage(input.text);
+            agent.followup(message);
+        }
         return {
             refs: {
                 runtimeType: this.runtimeType,
@@ -557,23 +653,105 @@ export class DshRuntimeAdapter {
             return 'UNKNOWN';
         return reconstructExecutionObservation(live, refs.runtimeDispatchRef);
     }
+    async persistedEvents(sessionRef) {
+        const persistence = this.deps.sessionPersistence;
+        if (typeof persistence?.open !== 'function')
+            return { events: [], complete: false, reason: 'UNREADABLE' };
+        let reader;
+        let openTimedOut = false;
+        let result = { events: [], complete: false, reason: 'UNREADABLE' };
+        try {
+            const opening = Promise.resolve(persistence.open(sessionRef, 'read'));
+            // If open finishes after our deadline, release only its read handle.
+            void opening.then(handle => {
+                if (openTimedOut)
+                    void Promise.resolve().then(() => handle.close()).catch(() => undefined);
+            }, () => undefined);
+            try {
+                reader = await boundedWait(opening, DEFAULT_DSH_IO_TIMEOUT_MS, 'PERSISTENCE_OPEN_TIMEOUT');
+            }
+            catch {
+                openTimedOut = true;
+                return result;
+            }
+            if (reader.id !== sessionRef || reader.access !== 'read' || typeof reader.read !== 'function' || typeof reader.close !== 'function')
+                return result;
+            const slice = await boundedWait(Promise.resolve(reader.read(0, DSH_RECONCILE_EVENT_LIMIT)), DEFAULT_DSH_IO_TIMEOUT_MS, 'PERSISTENCE_READ_TIMEOUT');
+            // At the exact limit we cannot know whether the log has a later tail.
+            result = readBoundedDshSessionEvents({ events: slice.events });
+            if (result.events.length === DSH_RECONCILE_EVENT_LIMIT)
+                result = { ...result, complete: false, reason: 'EVENT_LIMIT' };
+        }
+        catch {
+            result = { events: [], complete: false, reason: 'UNREADABLE' };
+        }
+        finally {
+            if (reader && typeof reader.close === 'function') {
+                try {
+                    await boundedWait(Promise.resolve(reader.close()), DEFAULT_DSH_IO_TIMEOUT_MS, 'PERSISTENCE_CLOSE_TIMEOUT');
+                }
+                catch {
+                    result = { events: [], complete: false, reason: 'UNREADABLE' };
+                }
+            }
+        }
+        return result;
+    }
     async reconcile(kingdomDispatchId, refs) {
-        // session 维：live registry 或持久可恢复 → AVAILABLE；否则 UNKNOWN（GONE 需显式删除证据，S5 细化）
         const live = this.deps.agents.get(refs.sessionRef);
         let sessionObservation = 'UNKNOWN';
-        if (live)
-            sessionObservation = 'AVAILABLE';
-        else if (this.deps.sessionPersistence?.has?.(refs.sessionRef) === true)
+        let source = 'NONE';
+        let projection = { events: [], complete: false, reason: 'UNREADABLE' };
+        if (live?.id === refs.sessionRef) {
             sessionObservation = 'AVAILABLE';
-        // execution 维：live 会话事件链；不可判定 → UNKNOWN（fail-closed，不盲发、不 ABORT）
+            source = 'LIVE';
+            projection = readBoundedDshSessionEvents(live.session);
+        }
+        else if (typeof this.deps.sessionPersistence?.open === 'function') {
+            source = 'PERSISTED';
+            projection = await this.persistedEvents(refs.sessionRef);
+            if (projection.complete || projection.reason === 'EVENT_LIMIT')
+                sessionObservation = 'AVAILABLE';
+        }
+        if (sessionObservation === 'UNKNOWN') {
+            try {
+                // Presence metadata never establishes a dispatch or its terminal.
+                const persistence = this.deps.sessionPersistence;
+                const present = typeof persistence?.stat === 'function'
+                    ? await boundedWait(Promise.resolve(persistence.stat(refs.sessionRef)), DEFAULT_DSH_IO_TIMEOUT_MS, 'PERSISTENCE_STAT_TIMEOUT')
+                    : persistence?.has?.(refs.sessionRef) === true;
+                if (present)
+                    sessionObservation = 'AVAILABLE';
+            }
+            catch { /* unknown presence stays unknown */ }
+        }
+        const located = Boolean(refs.runtimeDispatchRef && locateDshDispatchRef(projection.events, refs.runtimeDispatchRef) >= 0);
         let executionObservation = 'UNKNOWN';
-        if (live && refs.runtimeDispatchRef) {
-            executionObservation = reconstructExecutionObservation(live.session, refs.runtimeDispatchRef);
+        if (projection.complete && located && refs.runtimeDispatchRef) {
+            const start = locateDshDispatchRef(projection.events, refs.runtimeDispatchRef);
+            const foreign = projection.events.slice(start).some(event => {
+                if (event.type === 'user/message')
+                    return eventMessageId(event) !== refs.runtimeDispatchRef;
+                return event.type === 'agent/inbox/spliced' && Array.isArray(event.data?.inserted)
+                    && event.data.inserted.some(item => item === null || typeof item !== 'object' || item.id !== refs.runtimeDispatchRef);
+            });
+            if (!foreign)
+                executionObservation = reconstructExecutionObservation({ header: {}, events: projection.events }, refs.runtimeDispatchRef);
         }
         return {
             executionObservation,
             sessionObservation,
-            evidence: { kingdomDispatchId, runtimeDispatchRef: refs.runtimeDispatchRef ?? null, observedAt: new Date().toISOString() },
+            evidence: {
+                kingdomDispatchId,
+                runtimeDispatchRef: refs.runtimeDispatchRef ?? null,
+                source,
+                located,
+                eventsRead: projection.events.length,
+                complete: projection.complete,
+                reason: projection.reason !== 'READABLE' ? projection.reason === 'EVENT_LIMIT' ? 'EVENT_LIMIT' : 'OBSERVATION_UNREADABLE'
+                    : located ? 'EXACT_INPUT_FOUND' : 'INPUT_NOT_LOCATED',
+                observedAt: new Date().toISOString(),
+            },
         };
     }
 }